LukeParke/plexgo
1
0
Fork 0
mirror of https://github.com/LukeHagar/plexgo.git synced 2025-12-06 04:20:46 +00:00
Code Issues Packages Projects Releases Wiki Activity

ci: regenerated with OpenAPI Doc , Speakeasy CLI 1.459.2

Browse Source
This commit is contained in:
speakeasybot
2024-12-21 00:10:31 +00:00
parent 4bea7ae0d8
commit 16bb49d558
87 changed files with 2047 additions and 3580 deletions
Download Patch File Download Diff File Expand all files Collapse all files

39
.speakeasy/gen.lock
View File

File diff suppressed because one or more lines are too long

2
.speakeasy/gen.yaml
View File

@@ -13,7 +13,7 @@ generation:
oAuth2ClientCredentialsEnabled: true
oAuth2PasswordEnabled: false
go:
version: 0.16.1
version: 0.17.0
additionalDependencies: {}
allowUnknownFieldsInWeakUnions: false
clientServerStatusCodesAsErrors: true

14
.speakeasy/workflow.lock
View File

@@ -1,4 +1,4 @@
speakeasyVersion: 1.438.3
speakeasyVersion: 1.459.2
sources:
my-source:
sourceNamespace: my-source
@@ -9,19 +9,19 @@ sources:
- main
plexapi:
sourceNamespace: plexapi
sourceRevisionDigest: sha256:37c6bfb15f4154eb89b112465107f20757411f22bd1cc7d0a04335df7127fcb4
sourceBlobDigest: sha256:290473ebc909cada80ff428c685b897f4621cf121397e1417355e06d334e7206
sourceRevisionDigest: sha256:ccba0c42f1644923e2209e28da7a78195a843e48da1aeaaedbf8759f1a8a0fe0
sourceBlobDigest: sha256:b362c110ef633288220a55ab50627374b996c64f2d9b8e020944e84ea2840332
tags:
- latest
- main
- speakeasy-sdk-regen-1734739746
targets:
plexgo:
source: plexapi
sourceNamespace: plexapi
sourceRevisionDigest: sha256:37c6bfb15f4154eb89b112465107f20757411f22bd1cc7d0a04335df7127fcb4
sourceBlobDigest: sha256:290473ebc909cada80ff428c685b897f4621cf121397e1417355e06d334e7206
sourceRevisionDigest: sha256:ccba0c42f1644923e2209e28da7a78195a843e48da1aeaaedbf8759f1a8a0fe0
sourceBlobDigest: sha256:b362c110ef633288220a55ab50627374b996c64f2d9b8e020944e84ea2840332
codeSamplesNamespace: code-samples-go-plexgo
codeSamplesRevisionDigest: sha256:3d3923d5080a3df76181c5e2c153e6f9c88470f8366cbdea5628bb47fd67fd1b
codeSamplesRevisionDigest: sha256:41f5625e2b9341f86b5070f1425b466d26339870e28947bc87cb7c3fb30a9177
workflow:
workflowVersion: 1.0.0
speakeasyVersion: latest

82
README.md
View File

@@ -40,16 +40,24 @@ The following SDKs are generated from the OpenAPI Specification. They are automa
<!-- Start Table of Contents [toc] -->
## Table of Contents
<!-- $toc-max-depth=2 -->
* [github.com/LukeHagar/plexgo](#githubcomlukehagarplexgo)
* [Plex Media Server OpenAPI Specification](#plex-media-server-openapi-specification)
* [Documentation](#documentation)
* [SDKs](#sdks)
* [SDK Installation](#sdk-installation)
* [SDK Example Usage](#sdk-example-usage)
* [Available Resources and Operations](#available-resources-and-operations)
* [Retries](#retries)
* [Error Handling](#error-handling)
* [Server Selection](#server-selection)
* [Custom HTTP Client](#custom-http-client)
* [Authentication](#authentication)
* [Special Types](#special-types)
* [Development](#development)
* [Maturity](#maturity)
* [Contributions](#contributions)
* [SDK Installation](#sdk-installation)
* [SDK Example Usage](#sdk-example-usage)
* [Available Resources and Operations](#available-resources-and-operations)
* [Retries](#retries)
* [Error Handling](#error-handling)
* [Server Selection](#server-selection)
* [Custom HTTP Client](#custom-http-client)
* [Authentication](#authentication)
* [Special Types](#special-types)
<!-- End Table of Contents [toc] -->
<!-- Start SDK Installation [installation] -->
@@ -76,16 +84,12 @@ import (
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Server.GetServerCapabilities(ctx)
if err != nil {
log.Fatal(err)
@@ -250,16 +254,12 @@ import (
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Server.GetServerCapabilities(ctx, operations.WithRetries(
retry.Config{
Strategy: "backoff",
@@ -293,6 +293,8 @@ import (
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithRetryConfig(
retry.Config{
@@ -306,14 +308,8 @@ func main() {
RetryConnectionErrors: false,
}),
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Server.GetServerCapabilities(ctx)
if err != nil {
log.Fatal(err)
@@ -355,16 +351,12 @@ import (
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Server.GetServerCapabilities(ctx)
if err != nil {
@@ -414,17 +406,13 @@ import (
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithServerURL("https://10.10.10.47:32400"),
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Server.GetServerCapabilities(ctx)
if err != nil {
log.Fatal(err)
@@ -450,16 +438,12 @@ import (
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Plex.GetCompanionsData(ctx, operations.WithServerURL("https://plex.tv/api/v2"))
if err != nil {
log.Fatal(err)
@@ -523,16 +507,12 @@ import (
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Server.GetServerCapabilities(ctx)
if err != nil {
log.Fatal(err)

10
RELEASES.md
View File

@@ -973,3 +973,13 @@ Based on:
- [go v0.16.1] .
### Releases
- [Go v0.16.1] https://github.com/LukeHagar/plexgo/releases/tag/v0.16.1 - .
## 2024-12-21 00:09:02
### Changes
Based on:
- OpenAPI Doc
- Speakeasy CLI 1.459.2 (2.483.1) https://github.com/speakeasy-api/speakeasy
### Generated
- [go v0.17.0] .
### Releases
- [Go v0.17.0] https://github.com/LukeHagar/plexgo/releases/tag/v0.17.0 - .

8
USAGE.md
View File

@@ -9,16 +9,12 @@ import (
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Server.GetServerCapabilities(ctx)
if err != nil {
log.Fatal(err)

36
activities.go
View File

@@ -10,7 +10,7 @@ import (
"github.com/LukeHagar/plexgo/internal/utils"
"github.com/LukeHagar/plexgo/models/operations"
"github.com/LukeHagar/plexgo/models/sdkerrors"
"github.com/cenkalti/backoff/v4"
"github.com/LukeHagar/plexgo/retry"
"net/http"
"net/url"
)
@@ -54,7 +54,12 @@ func (s *Activities) GetServerActivities(ctx context.Context, opts ...operations
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := url.JoinPath(baseURL, "/activities")
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -82,6 +87,10 @@ func (s *Activities) GetServerActivities(ctx context.Context, opts ...operations
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -112,7 +121,11 @@ func (s *Activities) GetServerActivities(ctx context.Context, opts ...operations
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)
@@ -285,7 +298,12 @@ func (s *Activities) CancelServerActivities(ctx context.Context, activityUUID st
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := utils.GenerateURL(ctx, baseURL, "/activities/{activityUUID}", request, nil)
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -313,6 +331,10 @@ func (s *Activities) CancelServerActivities(ctx context.Context, activityUUID st
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -343,7 +365,11 @@ func (s *Activities) CancelServerActivities(ctx context.Context, activityUUID st
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)

68
authentication.go
View File

@@ -10,7 +10,7 @@ import (
"github.com/LukeHagar/plexgo/internal/utils"
"github.com/LukeHagar/plexgo/models/operations"
"github.com/LukeHagar/plexgo/models/sdkerrors"
"github.com/cenkalti/backoff/v4"
"github.com/LukeHagar/plexgo/retry"
"net/http"
"net/url"
)
@@ -53,7 +53,12 @@ func (s *Authentication) GetTransientToken(ctx context.Context, type_ operations
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := url.JoinPath(baseURL, "/security/token")
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -85,6 +90,10 @@ func (s *Authentication) GetTransientToken(ctx context.Context, type_ operations
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -115,7 +124,11 @@ func (s *Authentication) GetTransientToken(ctx context.Context, type_ operations
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)
@@ -269,7 +282,12 @@ func (s *Authentication) GetSourceConnectionInformation(ctx context.Context, sou
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := url.JoinPath(baseURL, "/security/resources")
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -301,6 +319,10 @@ func (s *Authentication) GetSourceConnectionInformation(ctx context.Context, sou
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -331,7 +353,11 @@ func (s *Authentication) GetSourceConnectionInformation(ctx context.Context, sou
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)
@@ -470,7 +496,6 @@ func (s *Authentication) GetTokenDetails(ctx context.Context, opts ...operations
o := operations.Options{}
supportedOptions := []string{
operations.SupportedOptionServerURL,
operations.SupportedOptionRetries,
operations.SupportedOptionTimeout,
}
@@ -513,6 +538,10 @@ func (s *Authentication) GetTokenDetails(ctx context.Context, opts ...operations
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -543,7 +572,11 @@ func (s *Authentication) GetTokenDetails(ctx context.Context, opts ...operations
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)
@@ -700,17 +733,8 @@ func (s *Authentication) PostUsersSignInData(ctx context.Context, request operat
SecuritySource: nil,
}
globals := operations.PostUsersSignInDataGlobals{
ClientID: s.sdkConfiguration.Globals.ClientID,
ClientName: s.sdkConfiguration.Globals.ClientName,
DeviceNickname: s.sdkConfiguration.Globals.DeviceNickname,
ClientVersion: s.sdkConfiguration.Globals.ClientVersion,
Platform: s.sdkConfiguration.Globals.Platform,
}
o := operations.Options{}
supportedOptions := []string{
operations.SupportedOptionServerURL,
operations.SupportedOptionRetries,
operations.SupportedOptionTimeout,
}
@@ -755,7 +779,11 @@ func (s *Authentication) PostUsersSignInData(ctx context.Context, request operat
req.Header.Set("User-Agent", s.sdkConfiguration.UserAgent)
req.Header.Set("Content-Type", reqContentType)
utils.PopulateHeaders(ctx, req, request, globals)
utils.PopulateHeaders(ctx, req, request, nil)
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
@@ -787,7 +815,11 @@ func (s *Authentication) PostUsersSignInData(ctx context.Context, request operat
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)

87
butler.go
View File

@@ -10,7 +10,7 @@ import (
"github.com/LukeHagar/plexgo/internal/utils"
"github.com/LukeHagar/plexgo/models/operations"
"github.com/LukeHagar/plexgo/models/sdkerrors"
"github.com/cenkalti/backoff/v4"
"github.com/LukeHagar/plexgo/retry"
"net/http"
"net/url"
)
@@ -48,7 +48,12 @@ func (s *Butler) GetButlerTasks(ctx context.Context, opts ...operations.Option)
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := url.JoinPath(baseURL, "/butler")
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -76,6 +81,10 @@ func (s *Butler) GetButlerTasks(ctx context.Context, opts ...operations.Option)
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -106,7 +115,11 @@ func (s *Butler) GetButlerTasks(ctx context.Context, opts ...operations.Option)
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)
@@ -279,7 +292,12 @@ func (s *Butler) StartAllTasks(ctx context.Context, opts ...operations.Option) (
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := url.JoinPath(baseURL, "/butler")
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -307,6 +325,10 @@ func (s *Butler) StartAllTasks(ctx context.Context, opts ...operations.Option) (
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -337,7 +359,11 @@ func (s *Butler) StartAllTasks(ctx context.Context, opts ...operations.Option) (
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)
@@ -486,7 +512,12 @@ func (s *Butler) StopAllTasks(ctx context.Context, opts ...operations.Option) (*
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := url.JoinPath(baseURL, "/butler")
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -514,6 +545,10 @@ func (s *Butler) StopAllTasks(ctx context.Context, opts ...operations.Option) (*
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -544,7 +579,11 @@ func (s *Butler) StopAllTasks(ctx context.Context, opts ...operations.Option) (*
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)
@@ -701,7 +740,12 @@ func (s *Butler) StartTask(ctx context.Context, taskName operations.TaskName, op
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := utils.GenerateURL(ctx, baseURL, "/butler/{taskName}", request, nil)
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -729,6 +773,10 @@ func (s *Butler) StartTask(ctx context.Context, taskName operations.TaskName, op
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -759,7 +807,11 @@ func (s *Butler) StartTask(ctx context.Context, taskName operations.TaskName, op
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)
@@ -914,7 +966,12 @@ func (s *Butler) StopTask(ctx context.Context, taskName operations.PathParamTask
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := utils.GenerateURL(ctx, baseURL, "/butler/{taskName}", request, nil)
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -942,6 +999,10 @@ func (s *Butler) StopTask(ctx context.Context, taskName operations.PathParamTask
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -972,7 +1033,11 @@ func (s *Butler) StopTask(ctx context.Context, taskName operations.PathParamTask
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)

2339
codeSamples.yaml
View File

File diff suppressed because it is too large Load Diff

2
docs/models/operations/getlibraryitemsmetadata.md
View File

@@ -24,7 +24,7 @@
| `SeasonCount` | **int* | :heavy_minus_sign: | N/A | 2022 |
| `Tagline` | **string* | :heavy_minus_sign: | N/A | Return to Pandora. |
| `FlattenSeasons` | [*operations.GetLibraryItemsFlattenSeasons](../../models/operations/getlibraryitemsflattenseasons.md) | :heavy_minus_sign: | N/A | 1 |
| `ShowOrdering` | [*operations.GetLibraryItemsShowOrdering](../../models/operations/getlibraryitemsshowordering.md) | :heavy_minus_sign: | Setting that indicates the episode ordering for the show <br/>None = Library default, <br/>tmdbAiring = The Movie Database (Aired), <br/>aired = TheTVDB (Aired), <br/>dvd = TheTVDB (DVD), <br/>absolute = TheTVDB (Absolute)).<br/> | dvd |
| `ShowOrdering` | [*operations.GetLibraryItemsShowOrdering](../../models/operations/getlibraryitemsshowordering.md) | :heavy_minus_sign: | Setting that indicates the episode ordering for the show<br/>None = Library default,<br/>tmdbAiring = The Movie Database (Aired),<br/>tvdbAiring = TheTVDB (Aired),<br/>tvdbDvd = TheTVDB (DVD),<br/>tvdbAbsolute = TheTVDB (Absolute)).<br/> | tvdbDvd |
| `Thumb` | **string* | :heavy_minus_sign: | N/A | /library/metadata/58683/thumb/1703239236 |
| `Art` | **string* | :heavy_minus_sign: | N/A | /library/metadata/58683/art/1703239236 |
| `Banner` | **string* | :heavy_minus_sign: | N/A | /library/metadata/58683/banner/1703239236 |

2
docs/models/operations/getlibraryitemsqueryparamtype.md
View File

@@ -18,3 +18,5 @@ E.g. A movie library will not return anything with type 3 as there are no season
| `GetLibraryItemsQueryParamTypeSeason` | 3 |
| `GetLibraryItemsQueryParamTypeEpisode` | 4 |
| `GetLibraryItemsQueryParamTypeAudio` | 8 |
| `GetLibraryItemsQueryParamTypeAlbum` | 9 |
| `GetLibraryItemsQueryParamTypeTrack` | 10 |

14
docs/models/operations/getlibraryitemsshowordering.md
View File

@@ -3,18 +3,18 @@
Setting that indicates the episode ordering for the show
None = Library default,
tmdbAiring = The Movie Database (Aired),
aired = TheTVDB (Aired),
dvd = TheTVDB (DVD),
absolute = TheTVDB (Absolute)).
tvdbAiring = TheTVDB (Aired),
tvdbDvd = TheTVDB (DVD),
tvdbAbsolute = TheTVDB (Absolute)).
## Values
| Name | Value |
| --------------------------------------- | --------------------------------------- |
| ----------------------------------------- | ----------------------------------------- |
| `GetLibraryItemsShowOrderingNone` | None |
| `GetLibraryItemsShowOrderingTmdbAiring` | tmdbAiring |
| `GetLibraryItemsShowOrderingAired` | aired |
| `GetLibraryItemsShowOrderingDvd` | dvd |
| `GetLibraryItemsShowOrderingAbsolute` | absolute |
| `GetLibraryItemsShowOrderingTvdbAiring` | tvdbAiring |
| `GetLibraryItemsShowOrderingTvdbDvd` | tvdbDvd |
| `GetLibraryItemsShowOrderingTvdbAbsolute` | tvdbAbsolute |

5
docs/models/operations/getmetadatabyratingkeymetadata.md
View File

@@ -14,6 +14,11 @@
| `LibrarySectionTitle` | **string* | :heavy_minus_sign: | N/A | Movies |
| `LibrarySectionID` | **int* | :heavy_minus_sign: | N/A | 1 |
| `LibrarySectionKey` | **string* | :heavy_minus_sign: | N/A | /library/sections/1 |
| `GrandparentTitle` | **string* | :heavy_minus_sign: | The name of the album artist for the track when audio, and the name of the TV show for the episode when video. | |
| `ParentTitle` | **string* | :heavy_minus_sign: | The name of the album for the track when audio, and the name of the season for the episode when TV show. | |
| `OriginalTitle` | **string* | :heavy_minus_sign: | The orginal untranslated name of the media item when non-english. | |
| `Index` | **int64* | :heavy_minus_sign: | The index starting from 0 of this media item in the MetaData array. | |
| `ParentIndex` | **int64* | :heavy_minus_sign: | The parent index starting from 0 of this media item in the parent MetaData array. | |
| `ContentRating` | **string* | :heavy_minus_sign: | N/A | PG-13 |
| `Summary` | **string* | :heavy_minus_sign: | N/A | Serenity continues the story of the TV series it was based upon ("Firefly"). River Tam had a secret - one in which she's not even aware - so dangerous, no one's safe, as an Alliance operative's sent to capture her, and all others are considered irrelevant to his job. |
| `Rating` | **float64* | :heavy_minus_sign: | N/A | 8.2 |

12
docs/models/operations/getpinglobals.md
View File

@@ -1,12 +0,0 @@
# GetPinGlobals
## Fields
| Field | Type | Required | Description | Example |
| ------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------ |
| `ClientID` | **string* | :heavy_minus_sign: | An opaque identifier unique to the client (UUID, serial number, or other unique device ID) | 3381b62b-9ab7-4e37-827b-203e9809eb58 |
| `ClientName` | **string* | :heavy_minus_sign: | The name of the client application. (Plex Web, Plex Media Server, etc.) | Plex for Roku |
| `DeviceNickname` | **string* | :heavy_minus_sign: | A relatively friendly name for the client device | Roku 3 |
| `ClientVersion` | **string* | :heavy_minus_sign: | The version of the client application. | 2.4.1 |
| `Platform` | **string* | :heavy_minus_sign: | The platform of the client application. | Roku |

2
docs/models/operations/getpinrequest.md
View File

@@ -6,7 +6,7 @@
| Field | Type | Required | Description | Example |
| ----------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Strong` | **bool* | :heavy_minus_sign: | Determines the kind of code returned by the API call<br/>Strong codes are used for Pin authentication flows<br/>Non-Strong codes are used for `Plex.tv/link`<br/> | |
| `ClientID` | **string* | :heavy_minus_sign: | An opaque identifier unique to the client (UUID, serial number, or other unique device ID) | 3381b62b-9ab7-4e37-827b-203e9809eb58 |
| `ClientID` | *string* | :heavy_check_mark: | An opaque identifier unique to the client (UUID, serial number, or other unique device ID) | 3381b62b-9ab7-4e37-827b-203e9809eb58 |
| `ClientName` | **string* | :heavy_minus_sign: | The name of the client application. (Plex Web, Plex Media Server, etc.) | Plex for Roku |
| `DeviceNickname` | **string* | :heavy_minus_sign: | A relatively friendly name for the client device | Roku 3 |
| `ClientVersion` | **string* | :heavy_minus_sign: | The version of the client application. | 2.4.1 |

2
docs/models/operations/getplaylistcontentsqueryparamtype.md
View File

@@ -18,3 +18,5 @@ E.g. A movie library will not return anything with type 3 as there are no season
| `GetPlaylistContentsQueryParamTypeSeason` | 3 |
| `GetPlaylistContentsQueryParamTypeEpisode` | 4 |
| `GetPlaylistContentsQueryParamTypeAudio` | 8 |
| `GetPlaylistContentsQueryParamTypeAlbum` | 9 |
| `GetPlaylistContentsQueryParamTypeTrack` | 10 |

2
docs/models/operations/getrecentlyaddedmetadata.md
View File

@@ -24,7 +24,7 @@
| `SeasonCount` | **int* | :heavy_minus_sign: | N/A | 2022 |
| `Tagline` | **string* | :heavy_minus_sign: | N/A | Return to Pandora. |
| `FlattenSeasons` | [*operations.FlattenSeasons](../../models/operations/flattenseasons.md) | :heavy_minus_sign: | N/A | 1 |
| `ShowOrdering` | [*operations.ShowOrdering](../../models/operations/showordering.md) | :heavy_minus_sign: | Setting that indicates the episode ordering for the show <br/>None = Library default, <br/>tmdbAiring = The Movie Database (Aired), <br/>aired = TheTVDB (Aired), <br/>dvd = TheTVDB (DVD), <br/>absolute = TheTVDB (Absolute)).<br/> | dvd |
| `ShowOrdering` | [*operations.ShowOrdering](../../models/operations/showordering.md) | :heavy_minus_sign: | Setting that indicates the episode ordering for the show<br/>None = Library default,<br/>tmdbAiring = The Movie Database (Aired),<br/>tvdbAiring = TheTVDB (Aired),<br/>tvdbDvd = TheTVDB (DVD),<br/>tvdbAbsolute = TheTVDB (Absolute)).<br/> | tvdbDvd |
| `Thumb` | **string* | :heavy_minus_sign: | N/A | /library/metadata/58683/thumb/1703239236 |
| `Art` | **string* | :heavy_minus_sign: | N/A | /library/metadata/58683/art/1703239236 |
| `Banner` | **string* | :heavy_minus_sign: | N/A | /library/metadata/58683/banner/1703239236 |

8
docs/models/operations/getsearchalllibrariesglobals.md
View File

@@ -1,8 +0,0 @@
# GetSearchAllLibrariesGlobals
## Fields
| Field | Type | Required | Description | Example |
| ------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------ |
| `ClientID` | **string* | :heavy_minus_sign: | An opaque identifier unique to the client (UUID, serial number, or other unique device ID) | 3381b62b-9ab7-4e37-827b-203e9809eb58 |

2
docs/models/operations/getsearchalllibrariesmetadata.md
View File

@@ -24,7 +24,7 @@
| `SeasonCount` | **int* | :heavy_minus_sign: | N/A | 2022 |
| `Tagline` | **string* | :heavy_minus_sign: | N/A | Return to Pandora. |
| `FlattenSeasons` | [*operations.GetSearchAllLibrariesFlattenSeasons](../../models/operations/getsearchalllibrariesflattenseasons.md) | :heavy_minus_sign: | N/A | 1 |
| `ShowOrdering` | [*operations.GetSearchAllLibrariesShowOrdering](../../models/operations/getsearchalllibrariesshowordering.md) | :heavy_minus_sign: | Setting that indicates the episode ordering for the show <br/>None = Library default, <br/>tmdbAiring = The Movie Database (Aired), <br/>aired = TheTVDB (Aired), <br/>dvd = TheTVDB (DVD), <br/>absolute = TheTVDB (Absolute)).<br/> | dvd |
| `ShowOrdering` | [*operations.GetSearchAllLibrariesShowOrdering](../../models/operations/getsearchalllibrariesshowordering.md) | :heavy_minus_sign: | Setting that indicates the episode ordering for the show<br/>None = Library default,<br/>tmdbAiring = The Movie Database (Aired),<br/>tvdbAiring = TheTVDB (Aired),<br/>tvdbDvd = TheTVDB (DVD),<br/>tvdbAbsolute = TheTVDB (Absolute)).<br/> | tvdbDvd |
| `Thumb` | **string* | :heavy_minus_sign: | N/A | /library/metadata/58683/thumb/1703239236 |
| `Art` | **string* | :heavy_minus_sign: | N/A | /library/metadata/58683/art/1703239236 |
| `Banner` | **string* | :heavy_minus_sign: | N/A | /library/metadata/58683/banner/1703239236 |

2
docs/models/operations/getsearchalllibrariesrequest.md
View File

@@ -6,7 +6,7 @@
| Field | Type | Required | Description | Example |
| ------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------- |
| `Query` | *string* | :heavy_check_mark: | The search query term. | |
| `ClientID` | **string* | :heavy_minus_sign: | An opaque identifier unique to the client (UUID, serial number, or other unique device ID) | 3381b62b-9ab7-4e37-827b-203e9809eb58 |
| `ClientID` | *string* | :heavy_check_mark: | An opaque identifier unique to the client (UUID, serial number, or other unique device ID) | 3381b62b-9ab7-4e37-827b-203e9809eb58 |
| `Limit` | **int64* | :heavy_minus_sign: | Limit the number of results returned. | |
| `SearchTypes` | [][operations.SearchTypes](../../models/operations/searchtypes.md) | :heavy_minus_sign: | A comma-separated list of search types to include. Valid values are: movies, music, otherVideos, people, tv.<br/> | movies,music,otherVideos,people,tv |
| `IncludeCollections` | [*operations.QueryParamIncludeCollections](../../models/operations/queryparamincludecollections.md) | :heavy_minus_sign: | Whether to include collections in the search results. | 1 |

14
docs/models/operations/getsearchalllibrariesshowordering.md
View File

@@ -3,18 +3,18 @@
Setting that indicates the episode ordering for the show
None = Library default,
tmdbAiring = The Movie Database (Aired),
aired = TheTVDB (Aired),
dvd = TheTVDB (DVD),
absolute = TheTVDB (Absolute)).
tvdbAiring = TheTVDB (Aired),
tvdbDvd = TheTVDB (DVD),
tvdbAbsolute = TheTVDB (Absolute)).
## Values
| Name | Value |
| --------------------------------------------- | --------------------------------------------- |
| ----------------------------------------------- | ----------------------------------------------- |
| `GetSearchAllLibrariesShowOrderingNone` | None |
| `GetSearchAllLibrariesShowOrderingTmdbAiring` | tmdbAiring |
| `GetSearchAllLibrariesShowOrderingAired` | aired |
| `GetSearchAllLibrariesShowOrderingDvd` | dvd |
| `GetSearchAllLibrariesShowOrderingAbsolute` | absolute |
| `GetSearchAllLibrariesShowOrderingTvdbAiring` | tvdbAiring |
| `GetSearchAllLibrariesShowOrderingTvdbDvd` | tvdbDvd |
| `GetSearchAllLibrariesShowOrderingTvdbAbsolute` | tvdbAbsolute |

2
docs/models/operations/getsearchlibraryqueryparamtype.md
View File

@@ -18,3 +18,5 @@ E.g. A movie library will not return anything with type 3 as there are no season
| `GetSearchLibraryQueryParamTypeSeason` | 3 |
| `GetSearchLibraryQueryParamTypeEpisode` | 4 |
| `GetSearchLibraryQueryParamTypeAudio` | 8 |
| `GetSearchLibraryQueryParamTypeAlbum` | 9 |
| `GetSearchLibraryQueryParamTypeTrack` | 10 |

8
docs/models/operations/getserverresourcesglobals.md
View File

@@ -1,8 +0,0 @@
# GetServerResourcesGlobals
## Fields
| Field | Type | Required | Description | Example |
| ------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------ |
| `ClientID` | **string* | :heavy_minus_sign: | An opaque identifier unique to the client (UUID, serial number, or other unique device ID) | 3381b62b-9ab7-4e37-827b-203e9809eb58 |

2
docs/models/operations/getserverresourcesrequest.md
View File

@@ -8,4 +8,4 @@
| `IncludeHTTPS` | [*operations.IncludeHTTPS](../../models/operations/includehttps.md) | :heavy_minus_sign: | Include Https entries in the results | 1 |
| `IncludeRelay` | [*operations.IncludeRelay](../../models/operations/includerelay.md) | :heavy_minus_sign: | Include Relay addresses in the results <br/>E.g: https://10-0-0-25.bbf8e10c7fa20447cacee74cd9914cde.plex.direct:32400<br/> | 1 |
| `IncludeIPv6` | [*operations.IncludeIPv6](../../models/operations/includeipv6.md) | :heavy_minus_sign: | Include IPv6 entries in the results | 1 |
| `ClientID` | **string* | :heavy_minus_sign: | An opaque identifier unique to the client (UUID, serial number, or other unique device ID) | 3381b62b-9ab7-4e37-827b-203e9809eb58 |
| `ClientID` | *string* | :heavy_check_mark: | An opaque identifier unique to the client (UUID, serial number, or other unique device ID) | 3381b62b-9ab7-4e37-827b-203e9809eb58 |

12
docs/models/operations/gettokenbypinidglobals.md
View File

@@ -1,12 +0,0 @@
# GetTokenByPinIDGlobals
## Fields
| Field | Type | Required | Description | Example |
| ------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------ |
| `ClientID` | **string* | :heavy_minus_sign: | An opaque identifier unique to the client (UUID, serial number, or other unique device ID) | 3381b62b-9ab7-4e37-827b-203e9809eb58 |
| `ClientName` | **string* | :heavy_minus_sign: | The name of the client application. (Plex Web, Plex Media Server, etc.) | Plex for Roku |
| `DeviceNickname` | **string* | :heavy_minus_sign: | A relatively friendly name for the client device | Roku 3 |
| `ClientVersion` | **string* | :heavy_minus_sign: | The version of the client application. | 2.4.1 |
| `Platform` | **string* | :heavy_minus_sign: | The platform of the client application. | Roku |

2
docs/models/operations/gettokenbypinidrequest.md
View File

@@ -6,7 +6,7 @@
| Field | Type | Required | Description | Example |
| ------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------ |
| `PinID` | *int64* | :heavy_check_mark: | The PinID to retrieve an access token for | |
| `ClientID` | **string* | :heavy_minus_sign: | An opaque identifier unique to the client (UUID, serial number, or other unique device ID) | 3381b62b-9ab7-4e37-827b-203e9809eb58 |
| `ClientID` | *string* | :heavy_check_mark: | An opaque identifier unique to the client (UUID, serial number, or other unique device ID) | 3381b62b-9ab7-4e37-827b-203e9809eb58 |
| `ClientName` | **string* | :heavy_minus_sign: | The name of the client application. (Plex Web, Plex Media Server, etc.) | Plex for Roku |
| `DeviceNickname` | **string* | :heavy_minus_sign: | A relatively friendly name for the client device | Roku 3 |
| `ClientVersion` | **string* | :heavy_minus_sign: | The version of the client application. | 2.4.1 |

2
docs/models/operations/gettopwatchedcontentqueryparamtype.md
View File

@@ -18,3 +18,5 @@ E.g. A movie library will not return anything with type 3 as there are no season
| `GetTopWatchedContentQueryParamTypeSeason` | 3 |
| `GetTopWatchedContentQueryParamTypeEpisode` | 4 |
| `GetTopWatchedContentQueryParamTypeAudio` | 8 |
| `GetTopWatchedContentQueryParamTypeAlbum` | 9 |
| `GetTopWatchedContentQueryParamTypeTrack` | 10 |

12
docs/models/operations/postuserssignindataglobals.md
View File

@@ -1,12 +0,0 @@
# PostUsersSignInDataGlobals
## Fields
| Field | Type | Required | Description | Example |
| ------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------ |
| `ClientID` | **string* | :heavy_minus_sign: | An opaque identifier unique to the client (UUID, serial number, or other unique device ID) | 3381b62b-9ab7-4e37-827b-203e9809eb58 |
| `ClientName` | **string* | :heavy_minus_sign: | The name of the client application. (Plex Web, Plex Media Server, etc.) | Plex for Roku |
| `DeviceNickname` | **string* | :heavy_minus_sign: | A relatively friendly name for the client device | Roku 3 |
| `ClientVersion` | **string* | :heavy_minus_sign: | The version of the client application. | 2.4.1 |
| `Platform` | **string* | :heavy_minus_sign: | The platform of the client application. | Roku |

2
docs/models/operations/postuserssignindatarequest.md
View File

@@ -5,7 +5,7 @@
| Field | Type | Required | Description | Example |
| ------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------- |
| `ClientID` | **string* | :heavy_minus_sign: | An opaque identifier unique to the client (UUID, serial number, or other unique device ID) | 3381b62b-9ab7-4e37-827b-203e9809eb58 |
| `ClientID` | *string* | :heavy_check_mark: | An opaque identifier unique to the client (UUID, serial number, or other unique device ID) | 3381b62b-9ab7-4e37-827b-203e9809eb58 |
| `ClientName` | **string* | :heavy_minus_sign: | The name of the client application. (Plex Web, Plex Media Server, etc.) | Plex for Roku |
| `DeviceNickname` | **string* | :heavy_minus_sign: | A relatively friendly name for the client device | Roku 3 |
| `ClientVersion` | **string* | :heavy_minus_sign: | The version of the client application. | 2.4.1 |

2
docs/models/operations/queryparamtype.md
View File

@@ -18,3 +18,5 @@ E.g. A movie library will not return anything with type 3 as there are no season
| `QueryParamTypeSeason` | 3 |
| `QueryParamTypeEpisode` | 4 |
| `QueryParamTypeAudio` | 8 |
| `QueryParamTypeAlbum` | 9 |
| `QueryParamTypeTrack` | 10 |

14
docs/models/operations/showordering.md
View File

@@ -3,18 +3,18 @@
Setting that indicates the episode ordering for the show
None = Library default,
tmdbAiring = The Movie Database (Aired),
aired = TheTVDB (Aired),
dvd = TheTVDB (DVD),
absolute = TheTVDB (Absolute)).
tvdbAiring = TheTVDB (Aired),
tvdbDvd = TheTVDB (DVD),
tvdbAbsolute = TheTVDB (Absolute)).
## Values
| Name | Value |
| ------------------------ | ------------------------ |
| -------------------------- | -------------------------- |
| `ShowOrderingNone` | None |
| `ShowOrderingTmdbAiring` | tmdbAiring |
| `ShowOrderingAired` | aired |
| `ShowOrderingDvd` | dvd |
| `ShowOrderingAbsolute` | absolute |
| `ShowOrderingTvdbAiring` | tvdbAiring |
| `ShowOrderingTvdbDvd` | tvdbDvd |
| `ShowOrderingTvdbAbsolute` | tvdbAbsolute |

1
docs/models/operations/tag.md
View File

@@ -26,3 +26,4 @@ A key representing a specific tag within the section.
| `TagResolution` | resolution |
| `TagFirstCharacter` | firstCharacter |
| `TagFolder` | folder |
| `TagAlbums` | albums |

2
docs/models/operations/type.md
View File

@@ -18,3 +18,5 @@ E.g. A movie library will not return anything with type 3 as there are no season
| `TypeSeason` | 3 |
| `TypeEpisode` | 4 |
| `TypeAudio` | 8 |
| `TypeAlbum` | 9 |
| `TypeTrack` | 10 |

20
docs/sdks/activities/README.md
View File

@@ -27,22 +27,18 @@ Get Server Activities
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Activities.GetServerActivities(ctx)
if err != nil {
log.Fatal(err)
@@ -82,22 +78,18 @@ Cancel Server Activities
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Activities.CancelServerActivities(ctx, "25b71ed5-0f9d-461c-baa7-d404e9e10d3e")
if err != nil {
log.Fatal(err)

48
docs/sdks/authentication/README.md
View File

@@ -24,23 +24,19 @@ This endpoint provides the caller with a temporary token with the same access le
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"github.com/LukeHagar/plexgo/models/operations"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Authentication.GetTransientToken(ctx, operations.GetTransientTokenQueryParamTypeDelegation, operations.ScopeAll)
if err != nil {
log.Fatal(err)
@@ -84,22 +80,18 @@ Note: requires Plex Media Server >= 1.15.4.
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Authentication.GetSourceConnectionInformation(ctx, "provider://provider-identifier")
if err != nil {
log.Fatal(err)
@@ -140,22 +132,18 @@ Get the User data from the provided X-Plex-Token
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Authentication.GetTokenDetails(ctx)
if err != nil {
log.Fatal(err)
@@ -195,23 +183,23 @@ Sign in user with username and password and return user data with Plex authentic
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"github.com/LukeHagar/plexgo/models/operations"
"log"
)
func main() {
s := plexgo.New(
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
s := plexgo.New()
res, err := s.Authentication.PostUsersSignInData(ctx, operations.PostUsersSignInDataRequest{
ClientID: "3381b62b-9ab7-4e37-827b-203e9809eb58",
ClientName: plexgo.String("Plex for Roku"),
DeviceNickname: plexgo.String("Roku 3"),
ClientVersion: plexgo.String("2.4.1"),
Platform: plexgo.String("Roku"),
RequestBody: &operations.PostUsersSignInDataRequestBody{
Login: "username@email.com",
Password: "password123",

50
docs/sdks/butler/README.md
View File

@@ -24,22 +24,18 @@ Returns a list of butler tasks
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Butler.GetButlerTasks(ctx)
if err != nil {
log.Fatal(err)
@@ -84,22 +80,18 @@ This endpoint will attempt to start all Butler tasks that are enabled in the set
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Butler.StartAllTasks(ctx)
if err != nil {
log.Fatal(err)
@@ -140,22 +132,18 @@ This endpoint will stop all currently running tasks and remove any scheduled tas
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Butler.StopAllTasks(ctx)
if err != nil {
log.Fatal(err)
@@ -200,23 +188,19 @@ This endpoint will attempt to start a single Butler task that is enabled in the
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"github.com/LukeHagar/plexgo/models/operations"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Butler.StartTask(ctx, operations.TaskNameCleanOldBundles)
if err != nil {
log.Fatal(err)
@@ -258,23 +242,19 @@ This endpoint will stop a currently running task by name, or remove it from the
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"github.com/LukeHagar/plexgo/models/operations"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Butler.StopTask(ctx, operations.PathParamTaskNameBackupDatabase)
if err != nil {
log.Fatal(err)

30
docs/sdks/hubs/README.md
View File

@@ -22,22 +22,18 @@ Get Global Hubs filtered by the parameters provided.
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Hubs.GetGlobalHubs(ctx, nil, nil)
if err != nil {
log.Fatal(err)
@@ -80,23 +76,19 @@ This endpoint will return the recently added content.
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"github.com/LukeHagar/plexgo/models/operations"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Hubs.GetRecentlyAdded(ctx, operations.GetRecentlyAddedRequest{
ContentDirectoryID: 470161,
SectionID: plexgo.Int64(2),
@@ -143,22 +135,18 @@ This endpoint will return a list of library specific hubs
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Hubs.GetLibraryHubs(ctx, 6728.76, nil, nil)
if err != nil {
log.Fatal(err)

132
docs/sdks/library/README.md
View File

@@ -32,22 +32,18 @@ This resource returns hash values for local files
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Library.GetFileHash(ctx, "file://C:\Image.png&type=13", nil)
if err != nil {
log.Fatal(err)
@@ -90,23 +86,19 @@ This endpoint will return the recently added content.
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"github.com/LukeHagar/plexgo/models/operations"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Library.GetRecentlyAddedLibrary(ctx, operations.GetRecentlyAddedLibraryRequest{
ContentDirectoryID: plexgo.Int64(2),
PinnedContentDirectoryID: []int64{
@@ -174,22 +166,18 @@ This allows a client to provide a rich interface around the media (e.g. allow so
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Library.GetAllLibraries(ctx)
if err != nil {
log.Fatal(err)
@@ -268,22 +256,18 @@ Each type in the library comes with a set of filters and sorts, aiding in buildi
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Library.GetLibraryDetails(ctx, 9518, nil)
if err != nil {
log.Fatal(err)
@@ -325,22 +309,18 @@ Delete a library using a specific section id
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Library.DeleteLibrary(ctx, 9518)
if err != nil {
log.Fatal(err)
@@ -393,6 +373,7 @@ Fetches details from a specific section of the library identified by a section k
- `resolution`: Items categorized by resolution.
- `firstCharacter`: Items categorized by the first letter.
- `folder`: Items categorized by folder.
- `albums`: Items categorized by album.
### Example Usage
@@ -401,23 +382,19 @@ Fetches details from a specific section of the library identified by a section k
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"github.com/LukeHagar/plexgo/models/operations"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Library.GetLibraryItems(ctx, operations.GetLibraryItemsRequest{
Tag: operations.TagEdition,
IncludeGuids: operations.IncludeGuidsEnable.ToPointer(),
@@ -467,23 +444,19 @@ This endpoint Refreshes all the Metadata of the library.
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"github.com/LukeHagar/plexgo/models/operations"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Library.GetRefreshLibraryMetadata(ctx, 9518, operations.ForceOne.ToPointer())
if err != nil {
log.Fatal(err)
@@ -543,23 +516,19 @@ Each type in the library comes with a set of filters and sorts, aiding in buildi
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"github.com/LukeHagar/plexgo/models/operations"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Library.GetSearchLibrary(ctx, 9518, operations.GetSearchLibraryQueryParamTypeTvShow)
if err != nil {
log.Fatal(err)
@@ -602,25 +571,22 @@ Search the provided query across all library sections, or a single section, and
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"github.com/LukeHagar/plexgo/models/operations"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Library.GetSearchAllLibraries(ctx, operations.GetSearchAllLibrariesRequest{
Query: "<value>",
ClientID: "3381b62b-9ab7-4e37-827b-203e9809eb58",
SearchTypes: []operations.SearchTypes{
operations.SearchTypesPeople,
},
@@ -667,22 +633,18 @@ This endpoint will return the metadata of a library item specified with the rati
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Library.GetMetaDataByRatingKey(ctx, 9518)
if err != nil {
log.Fatal(err)
@@ -724,22 +686,18 @@ This endpoint will return the children of of a library item specified with the r
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Library.GetMetadataChildren(ctx, 1539.14, plexgo.String("Stream"))
if err != nil {
log.Fatal(err)
@@ -782,23 +740,19 @@ This endpoint will return the top watched content from libraries of a certain ty
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"github.com/LukeHagar/plexgo/models/operations"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Library.GetTopWatchedContent(ctx, operations.GetTopWatchedContentQueryParamTypeTvShow, plexgo.Int64(1))
if err != nil {
log.Fatal(err)
@@ -841,22 +795,18 @@ This endpoint will return the on deck content.
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Library.GetOnDeck(ctx)
if err != nil {
log.Fatal(err)

30
docs/sdks/log/README.md
View File

@@ -23,23 +23,19 @@ This endpoint will write a single-line log message, including a level and source
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"github.com/LukeHagar/plexgo/models/operations"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Log.LogLine(ctx, operations.LevelThree, "Test log message", "Postman")
if err != nil {
log.Fatal(err)
@@ -103,22 +99,18 @@ Ensure each parameter is properly URL-encoded to avoid interpretation issues.
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Log.LogMultiLine(ctx, "level=4&message=Test%20message%201&source=postman\n" +
"level=3&message=Test%20message%202&source=postman\n" +
"level=1&message=Test%20message%203&source=postman")
@@ -162,22 +154,18 @@ This endpoint will enable all Plex Media Serverlogs to be sent to the Papertrail
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Log.EnablePaperTrail(ctx)
if err != nil {
log.Fatal(err)

50
docs/sdks/media/README.md
View File

@@ -24,22 +24,18 @@ This will mark the provided media key as Played.
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Media.MarkPlayed(ctx, 59398)
if err != nil {
log.Fatal(err)
@@ -80,22 +76,18 @@ This will mark the provided media key as Unplayed.
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Media.MarkUnplayed(ctx, 59398)
if err != nil {
log.Fatal(err)
@@ -137,22 +129,18 @@ This API command can be used to update the play progress of a media item.
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Media.UpdatePlayProgress(ctx, "<key>", 90000, "played")
if err != nil {
log.Fatal(err)
@@ -195,23 +183,19 @@ Gets the banner image of the media item
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"github.com/LukeHagar/plexgo/models/operations"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Media.GetBannerImage(ctx, operations.GetBannerImageRequest{
RatingKey: 9518,
Width: 396,
@@ -259,23 +243,19 @@ Gets the thumbnail image of the media item
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"github.com/LukeHagar/plexgo/models/operations"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Media.GetThumbImage(ctx, operations.GetThumbImageRequest{
RatingKey: 9518,
Width: 396,

90
docs/sdks/playlists/README.md
View File

@@ -34,23 +34,19 @@ Create a new playlist. By default the playlist is blank. To create a playlist al
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"github.com/LukeHagar/plexgo/models/operations"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Playlists.CreatePlaylist(ctx, operations.CreatePlaylistRequest{
Title: "<value>",
Type: operations.CreatePlaylistQueryParamTypePhoto,
@@ -96,22 +92,18 @@ Get All Playlists given the specified filters.
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Playlists.GetPlaylists(ctx, nil, nil)
if err != nil {
log.Fatal(err)
@@ -155,22 +147,18 @@ Smart playlist details contain the `content` attribute. This is the content URI
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Playlists.GetPlaylist(ctx, 4109.48)
if err != nil {
log.Fatal(err)
@@ -212,22 +200,18 @@ This endpoint will delete a playlist
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Playlists.DeletePlaylist(ctx, 216.22)
if err != nil {
log.Fatal(err)
@@ -269,22 +253,18 @@ From PMS version 1.9.1 clients can also edit playlist metadata using this endpoi
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Playlists.UpdatePlaylist(ctx, 3915, nil, nil)
if err != nil {
log.Fatal(err)
@@ -331,23 +311,19 @@ Note that for dumb playlists, items have a `playlistItemID` attribute which is u
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"github.com/LukeHagar/plexgo/models/operations"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Playlists.GetPlaylistContents(ctx, 5004.46, operations.GetPlaylistContentsQueryParamTypeTvShow)
if err != nil {
log.Fatal(err)
@@ -390,22 +366,18 @@ Clears a playlist, only works with dumb playlists. Returns the playlist.
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Playlists.ClearPlaylistContents(ctx, 1893.18)
if err != nil {
log.Fatal(err)
@@ -448,22 +420,18 @@ With a smart playlist, passing a new `uri` parameter replaces the rules for the
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Playlists.AddPlaylistContents(ctx, 8502.01, "server://12345/com.plexapp.plugins.library/library/metadata/1", plexgo.Float64(123))
if err != nil {
log.Fatal(err)
@@ -507,23 +475,19 @@ Imports m3u playlists by passing a path on the server to scan for m3u-formatted
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"github.com/LukeHagar/plexgo/models/operations"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Playlists.UploadPlaylist(ctx, "/home/barkley/playlist.m3u", operations.QueryParamForceZero, 1)
if err != nil {
log.Fatal(err)

96
docs/sdks/plex/README.md
View File

@@ -26,22 +26,18 @@ Get Companions Data
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Plex.GetCompanionsData(ctx)
if err != nil {
log.Fatal(err)
@@ -81,22 +77,18 @@ Get friends of provided auth token.
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Plex.GetUserFriends(ctx)
if err != nil {
log.Fatal(err)
@@ -136,21 +128,16 @@ Returns the geolocation and locale data of the caller
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"log"
)
func main() {
s := plexgo.New(
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
s := plexgo.New()
res, err := s.Plex.GetGeoData(ctx)
if err != nil {
log.Fatal(err)
@@ -190,22 +177,18 @@ Retrieves the home data for the authenticated user, including details like home
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Plex.GetHomeData(ctx)
if err != nil {
log.Fatal(err)
@@ -245,24 +228,20 @@ Get Plex server access tokens and server connections
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"github.com/LukeHagar/plexgo/models/operations"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Plex.GetServerResources(ctx, operations.IncludeHTTPSEnable.ToPointer(), operations.IncludeRelayEnable.ToPointer(), operations.IncludeIPv6Enable.ToPointer(), plexgo.String("3381b62b-9ab7-4e37-827b-203e9809eb58"))
res, err := s.Plex.GetServerResources(ctx, "3381b62b-9ab7-4e37-827b-203e9809eb58", operations.IncludeHTTPSEnable.ToPointer(), operations.IncludeRelayEnable.ToPointer(), operations.IncludeIPv6Enable.ToPointer())
if err != nil {
log.Fatal(err)
}
@@ -277,10 +256,10 @@ func main() {
| Parameter | Type | Required | Description | Example |
| ------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------ |
| `ctx` | [context.Context](https://pkg.go.dev/context#Context) | :heavy_check_mark: | The context to use for the request. | |
| `clientID` | *string* | :heavy_check_mark: | An opaque identifier unique to the client (UUID, serial number, or other unique device ID) | 3381b62b-9ab7-4e37-827b-203e9809eb58 |
| `includeHTTPS` | [*operations.IncludeHTTPS](../../models/operations/includehttps.md) | :heavy_minus_sign: | Include Https entries in the results | 1 |
| `includeRelay` | [*operations.IncludeRelay](../../models/operations/includerelay.md) | :heavy_minus_sign: | Include Relay addresses in the results <br/>E.g: https://10-0-0-25.bbf8e10c7fa20447cacee74cd9914cde.plex.direct:32400<br/> | 1 |
| `includeIPv6` | [*operations.IncludeIPv6](../../models/operations/includeipv6.md) | :heavy_minus_sign: | Include IPv6 entries in the results | 1 |
| `clientID` | **string* | :heavy_minus_sign: | An opaque identifier unique to the client (UUID, serial number, or other unique device ID) | 3381b62b-9ab7-4e37-827b-203e9809eb58 |
| `opts` | [][operations.Option](../../models/operations/option.md) | :heavy_minus_sign: | The options for this request. | |
### Response
@@ -305,23 +284,24 @@ Retrieve a Pin ID from Plex.tv to use for authentication flows
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"github.com/LukeHagar/plexgo/models/operations"
"log"
)
func main() {
s := plexgo.New(
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Plex.GetPin(ctx, operations.GetPinRequest{})
s := plexgo.New()
res, err := s.Plex.GetPin(ctx, operations.GetPinRequest{
ClientID: "3381b62b-9ab7-4e37-827b-203e9809eb58",
ClientName: plexgo.String("Plex for Roku"),
DeviceNickname: plexgo.String("Roku 3"),
ClientVersion: plexgo.String("2.4.1"),
Platform: plexgo.String("Roku"),
})
if err != nil {
log.Fatal(err)
}
@@ -360,24 +340,24 @@ Retrieve an Access Token from Plex.tv after the Pin has been authenticated
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"github.com/LukeHagar/plexgo/models/operations"
"log"
)
func main() {
s := plexgo.New(
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
s := plexgo.New()
res, err := s.Plex.GetTokenByPinID(ctx, operations.GetTokenByPinIDRequest{
PinID: 408895,
ClientID: "3381b62b-9ab7-4e37-827b-203e9809eb58",
ClientName: plexgo.String("Plex for Roku"),
DeviceNickname: plexgo.String("Roku 3"),
ClientVersion: plexgo.String("2.4.1"),
Platform: plexgo.String("Roku"),
})
if err != nil {
log.Fatal(err)

3
docs/sdks/plexapi/README.md
View File

@@ -26,3 +26,6 @@ The following SDKs are generated from the OpenAPI Specification. They are automa
| PHP | [GitHub](https://github.com/LukeHagar/plexphp) | [Releases](https://github.com/LukeHagar/plexphp/releases) | - |
| Java | [GitHub](https://github.com/LukeHagar/plexjava) | [Releases](https://github.com/LukeHagar/plexjava/releases) | - |
| C# | [GitHub](https://github.com/LukeHagar/plexcsharp) | [Releases](https://github.com/LukeHagar/plexcsharp/releases) | -
### Available Operations

30
docs/sdks/search/README.md
View File

@@ -34,22 +34,18 @@ This request is intended to be very fast, and called as the user types.
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Search.PerformSearch(ctx, "dylan", nil, plexgo.Float64(5))
if err != nil {
log.Fatal(err)
@@ -96,22 +92,18 @@ Results, as well as their containing per-type hubs, contain a `distance` attribu
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Search.PerformVoiceSearch(ctx, "dead+poop", nil, plexgo.Float64(5))
if err != nil {
log.Fatal(err)
@@ -154,22 +146,18 @@ This will search the database for the string provided.
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Search.GetSearchResults(ctx, "110")
if err != nil {
log.Fatal(err)

95
docs/sdks/server/README.md
View File

@@ -28,22 +28,18 @@ Get Server Capabilities
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Server.GetServerCapabilities(ctx)
if err != nil {
log.Fatal(err)
@@ -83,22 +79,18 @@ Get Server Preferences
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Server.GetServerPreferences(ctx)
if err != nil {
log.Fatal(err)
@@ -138,22 +130,18 @@ Get Available Clients
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Server.GetAvailableClients(ctx)
if err != nil {
log.Fatal(err)
@@ -193,22 +181,18 @@ Get Devices
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Server.GetDevices(ctx)
if err != nil {
log.Fatal(err)
@@ -248,21 +232,16 @@ This request is useful to determine if the server is online or offline
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"log"
)
func main() {
s := plexgo.New(
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
s := plexgo.New()
res, err := s.Server.GetServerIdentity(ctx)
if err != nil {
log.Fatal(err)
@@ -301,22 +280,18 @@ Returns MyPlex Account Information
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Server.GetMyPlexAccount(ctx)
if err != nil {
log.Fatal(err)
@@ -357,30 +332,26 @@ Plex's Photo transcoder is used throughout the service to serve images at specif
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"github.com/LukeHagar/plexgo/models/operations"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Server.GetResizedPhoto(ctx, operations.GetResizedPhotoRequest{
Width: 110,
Height: 165,
Opacity: 100,
Blur: 0,
MinSize: operations.MinSizeOne,
Upscale: operations.UpscaleOne,
Upscale: operations.UpscaleZero,
URL: "/library/metadata/49564/thumb/1654258204",
})
if err != nil {
@@ -422,22 +393,18 @@ Retrieves media providers and their features from the Plex server.
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Server.GetMediaProviders(ctx, "CV5xoxjTpFKUzBTShsaf")
if err != nil {
log.Fatal(err)
@@ -478,22 +445,18 @@ Get Server List
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Server.GetServerList(ctx)
if err != nil {
log.Fatal(err)

40
docs/sdks/sessions/README.md
View File

@@ -23,22 +23,18 @@ This will retrieve the "Now Playing" Information of the PMS.
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Sessions.GetSessions(ctx)
if err != nil {
log.Fatal(err)
@@ -78,23 +74,19 @@ This will Retrieve a listing of all history views.
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"github.com/LukeHagar/plexgo/models/operations"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Sessions.GetSessionHistory(ctx, plexgo.String("viewedAt:desc"), plexgo.Int64(1), &operations.QueryParamFilter{}, plexgo.Int64(12))
if err != nil {
log.Fatal(err)
@@ -138,22 +130,18 @@ Get Transcode Sessions
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Sessions.GetTranscodeSessions(ctx)
if err != nil {
log.Fatal(err)
@@ -193,22 +181,18 @@ Stop a Transcode Session
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Sessions.StopTranscodeSession(ctx, "zz7llzqlx8w9vnrsbnwhbmep")
if err != nil {
log.Fatal(err)

30
docs/sdks/statistics/README.md
View File

@@ -22,22 +22,18 @@ This will return the media statistics for the server
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Statistics.GetStatistics(ctx, plexgo.Int64(4))
if err != nil {
log.Fatal(err)
@@ -78,22 +74,18 @@ This will return the resources for the server
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Statistics.GetResourcesStatistics(ctx, plexgo.Int64(4))
if err != nil {
log.Fatal(err)
@@ -134,22 +126,18 @@ This will return the bandwidth statistics for the server
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Statistics.GetBandwidthStatistics(ctx, plexgo.Int64(4))
if err != nil {
log.Fatal(err)

30
docs/sdks/updater/README.md
View File

@@ -23,22 +23,18 @@ Querying status of updates
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Updater.GetUpdateStatus(ctx)
if err != nil {
log.Fatal(err)
@@ -78,23 +74,19 @@ Checking for updates
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"github.com/LukeHagar/plexgo/models/operations"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Updater.CheckForUpdates(ctx, operations.DownloadOne.ToPointer())
if err != nil {
log.Fatal(err)
@@ -136,23 +128,19 @@ Note that these two parameters are effectively mutually exclusive. The `tonight`
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"github.com/LukeHagar/plexgo/models/operations"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Updater.ApplyUpdates(ctx, operations.TonightOne.ToPointer(), operations.SkipOne.ToPointer())
if err != nil {
log.Fatal(err)

20
docs/sdks/video/README.md
View File

@@ -21,23 +21,19 @@ Get the timeline for a media item
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"github.com/LukeHagar/plexgo/models/operations"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Video.GetTimeline(ctx, operations.GetTimelineRequest{
RatingKey: 23409,
Key: "/library/metadata/23409",
@@ -89,23 +85,19 @@ Begin a Universal Transcode Session
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"github.com/LukeHagar/plexgo/models/operations"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Video.StartUniversalTranscode(ctx, operations.StartUniversalTranscodeRequest{
HasMDE: 1,
Path: "/library/metadata/23409",

10
docs/sdks/watchlist/README.md
View File

@@ -20,23 +20,19 @@ Get User Watchlist
package main
import(
"github.com/LukeHagar/plexgo"
"context"
"github.com/LukeHagar/plexgo"
"github.com/LukeHagar/plexgo/models/operations"
"log"
)
func main() {
ctx := context.Background()
s := plexgo.New(
plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
plexgo.WithClientID("3381b62b-9ab7-4e37-827b-203e9809eb58"),
plexgo.WithClientName("Plex for Roku"),
plexgo.WithClientVersion("2.4.1"),
plexgo.WithPlatform("Roku"),
plexgo.WithDeviceNickname("Roku 3"),
)
ctx := context.Background()
res, err := s.Watchlist.GetWatchList(ctx, operations.GetWatchListRequest{
Filter: operations.FilterAvailable,
XPlexContainerStart: plexgo.Int(0),

5
go.mod
View File

@@ -2,7 +2,4 @@ module github.com/LukeHagar/plexgo
go 1.20
require (
github.com/cenkalti/backoff/v4 v4.2.0
github.com/ericlagergren/decimal v0.0.0-20221120152707-495c53812d05
)
require github.com/ericlagergren/decimal v0.0.0-20221120152707-495c53812d05

2
go.sum
View File

@@ -1,4 +1,2 @@
github.com/cenkalti/backoff/v4 v4.2.0 h1:HN5dHm3WBOgndBH6E8V0q2jIYIR3s9yglV8k/+MN3u4=
github.com/cenkalti/backoff/v4 v4.2.0/go.mod h1:Y3VNntkOUPxTVeUxJ/G5vcM//AlwfmyYozVcomhLiZE=
github.com/ericlagergren/decimal v0.0.0-20221120152707-495c53812d05 h1:S92OBrGuLLZsyM5ybUzgc/mPjIYk2AZqufieooe98uw=
github.com/ericlagergren/decimal v0.0.0-20221120152707-495c53812d05/go.mod h1:M9R1FoZ3y//hwwnJtO51ypFGwm8ZfpxPT/ZLtO1mcgQ=

53
hubs.go
View File

@@ -10,7 +10,7 @@ import (
"github.com/LukeHagar/plexgo/internal/utils"
"github.com/LukeHagar/plexgo/models/operations"
"github.com/LukeHagar/plexgo/models/sdkerrors"
"github.com/cenkalti/backoff/v4"
"github.com/LukeHagar/plexgo/retry"
"net/http"
"net/url"
)
@@ -53,7 +53,12 @@ func (s *Hubs) GetGlobalHubs(ctx context.Context, count *float64, onlyTransient
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := url.JoinPath(baseURL, "/hubs")
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -85,6 +90,10 @@ func (s *Hubs) GetGlobalHubs(ctx context.Context, count *float64, onlyTransient
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -115,7 +124,11 @@ func (s *Hubs) GetGlobalHubs(ctx context.Context, count *float64, onlyTransient
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)
@@ -284,7 +297,12 @@ func (s *Hubs) GetRecentlyAdded(ctx context.Context, request operations.GetRecen
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := url.JoinPath(baseURL, "/hubs/home/recentlyAdded")
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -316,6 +334,10 @@ func (s *Hubs) GetRecentlyAdded(ctx context.Context, request operations.GetRecen
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -346,7 +368,11 @@ func (s *Hubs) GetRecentlyAdded(ctx context.Context, request operations.GetRecen
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)
@@ -481,7 +507,12 @@ func (s *Hubs) GetLibraryHubs(ctx context.Context, sectionID float64, count *flo
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := utils.GenerateURL(ctx, baseURL, "/hubs/sections/{sectionId}", request, nil)
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -513,6 +544,10 @@ func (s *Hubs) GetLibraryHubs(ctx context.Context, sectionID float64, count *flo
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -543,7 +578,11 @@ func (s *Hubs) GetLibraryHubs(ctx context.Context, sectionID float64, count *flo
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)

51
internal/globals/globals.go
View File

@@ -1,51 +0,0 @@
// Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
package globals
type Globals struct {
// An opaque identifier unique to the client (UUID, serial number, or other unique device ID)
ClientID *string `header:"style=simple,explode=false,name=X-Plex-Client-Identifier"`
// The name of the client application. (Plex Web, Plex Media Server, etc.)
ClientName *string `header:"style=simple,explode=false,name=X-Plex-Product"`
// The version of the client application.
ClientVersion *string `header:"style=simple,explode=false,name=X-Plex-Version"`
// The platform of the client application.
Platform *string `header:"style=simple,explode=false,name=X-Plex-Platform"`
// A relatively friendly name for the client device
DeviceNickname *string `header:"style=simple,explode=false,name=X-Plex-Device"`
}
func (o *Globals) GetClientID() *string {
if o == nil {
return nil
}
return o.ClientID
}
func (o *Globals) GetClientName() *string {
if o == nil {
return nil
}
return o.ClientName
}
func (o *Globals) GetClientVersion() *string {
if o == nil {
return nil
}
return o.ClientVersion
}
func (o *Globals) GetPlatform() *string {
if o == nil {
return nil
}
return o.Platform
}
func (o *Globals) GetDeviceNickname() *string {
if o == nil {
return nil
}
return o.DeviceNickname
}

16
internal/utils/env.go Normal file
View File

@@ -0,0 +1,16 @@
// Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
package utils
import (
"os"
)
// GetEnv returns the value of the environment variable named by the key or the defaultValue if the environment variable is not set.
func GetEnv(name, defaultValue string) string {
value := os.Getenv(name)
if value == "" {
return defaultValue
}
return value
}

13
internal/utils/queryparams.go
View File

@@ -214,7 +214,11 @@ func populateDeepObjectParamsStruct(qsValues url.Values, priorScope string, stru
continue
}
scope := priorScope + "[" + qpTag.ParamName + "]"
scope := priorScope
if !qpTag.Inline {
scope = priorScope + "[" + qpTag.ParamName + "]"
}
switch fieldValue.Kind() {
case reflect.Array, reflect.Slice:
@@ -252,6 +256,13 @@ type paramTag struct {
Explode bool
ParamName string
Serialization string
// Inline is a special case for union/oneOf. When a wrapper struct type is
// used, each union/oneOf value field should be inlined (e.g. not appended
// in deepObject style with the name) as if the value was directly on the
// parent struct field. Without this annotation, the value would not be
// encoded by downstream logic that requires the struct field tag.
Inline bool
}
func parseQueryParamTag(field reflect.StructField) *paramTag {

8
internal/utils/requestbody.go
View File

@@ -166,7 +166,7 @@ func encodeMultipartFormData(w io.Writer, data interface{}) (string, error) {
tag := parseMultipartFormTag(field)
if tag.File {
if err := encodeMultipartFormDataFile(writer, fieldType, valType); err != nil {
if err := encodeMultipartFormDataFile(writer, tag.Name, fieldType, valType); err != nil {
writer.Close()
return "", err
}
@@ -211,12 +211,11 @@ func encodeMultipartFormData(w io.Writer, data interface{}) (string, error) {
return writer.FormDataContentType(), nil
}
func encodeMultipartFormDataFile(w *multipart.Writer, fieldType reflect.Type, valType reflect.Value) error {
func encodeMultipartFormDataFile(w *multipart.Writer, fieldName string, fieldType reflect.Type, valType reflect.Value) error {
if fieldType.Kind() != reflect.Struct {
return fmt.Errorf("invalid type %s for multipart/form-data file", valType.Type())
}
var fieldName string
var fileName string
var reader io.Reader
@@ -236,12 +235,11 @@ func encodeMultipartFormDataFile(w *multipart.Writer, fieldType reflect.Type, va
reader = val.Interface().(io.Reader)
}
} else {
fieldName = tag.Name
fileName = val.String()
}
}
if fieldName == "" || fileName == "" || reader == nil {
if fileName == "" || reader == nil {
return fmt.Errorf("invalid multipart/form-data file")
}

152
internal/utils/retries.go
View File

@@ -7,7 +7,8 @@ import (
"errors"
"fmt"
"github.com/LukeHagar/plexgo/retry"
"github.com/cenkalti/backoff/v4"
"math"
"math/rand"
"net/http"
"net/url"
"strconv"
@@ -15,8 +16,6 @@ import (
"time"
)
var errRequestFailed = errors.New("request failed")
// Deprecated: Use retry.BackoffStrategy instead.
type BackoffStrategy = retry.BackoffStrategy
@@ -28,34 +27,27 @@ type Retries struct {
StatusCodes []string
}
func Retry(ctx context.Context, r Retries, action func() (*http.Response, error)) (*http.Response, error) {
func Retry(ctx context.Context, r Retries, operation func() (*http.Response, error)) (*http.Response, error) {
switch r.Config.Strategy {
case "backoff":
if r.Config.Backoff == nil {
return action()
return operation()
}
config := backoff.NewExponentialBackOff()
config.InitialInterval = time.Duration(r.Config.Backoff.InitialInterval) * time.Millisecond
config.MaxInterval = time.Duration(r.Config.Backoff.MaxInterval) * time.Millisecond
config.Multiplier = r.Config.Backoff.Exponent
config.MaxElapsedTime = time.Duration(r.Config.Backoff.MaxElapsedTime) * time.Millisecond
config.Reset()
var resp *http.Response
err := backoff.Retry(func() error {
err := retryWithBackoff(ctx, r.Config.Backoff, func() error {
if resp != nil {
resp.Body.Close()
}
select {
case <-ctx.Done():
return backoff.Permanent(ctx.Err())
return retry.Permanent(ctx.Err())
default:
}
res, err := action()
res, err := operation()
if err != nil {
urlError := new(url.Error)
if errors.As(err, &urlError) {
@@ -64,7 +56,7 @@ func Retry(ctx context.Context, r Retries, action func() (*http.Response, error)
}
}
return backoff.Permanent(err)
return retry.Permanent(err)
}
resp = res
if res == nil {
@@ -81,7 +73,7 @@ func Retry(ctx context.Context, r Retries, action func() (*http.Response, error)
s := res.StatusCode / 100
if s >= codeRange && s < codeRange+1 {
return errRequestFailed
return retry.TemporaryFromResponse("request failed", res)
}
} else {
parsedCode, err := strconv.Atoi(code)
@@ -90,7 +82,7 @@ func Retry(ctx context.Context, r Retries, action func() (*http.Response, error)
}
if res.StatusCode == parsedCode {
return errRequestFailed
return retry.TemporaryFromResponse("request failed", res)
}
}
}
@@ -98,13 +90,131 @@ func Retry(ctx context.Context, r Retries, action func() (*http.Response, error)
resp = res
return nil
}, config)
if err != nil && !errors.Is(err, errRequestFailed) {
})
var tempErr *retry.TemporaryError
if err != nil && !errors.As(err, &tempErr) {
return nil, err
}
return resp, nil
default:
return action()
return operation()
}
}
func retryWithBackoff(ctx context.Context, s *retry.BackoffStrategy, operation func() error) error {
var (
err error
next time.Duration
attempt int
start = time.Now()
maxElapsedTime = time.Duration(s.MaxElapsedTime) * time.Millisecond
)
timer := &defaultTimer{}
defer func() {
timer.Stop()
}()
for {
err = operation()
if err == nil {
return nil
}
var permanent *retry.PermanentError
if errors.As(err, &permanent) {
return permanent.Unwrap()
}
if time.Since(start) >= maxElapsedTime {
return err
}
var temporary *retry.TemporaryError
if errors.As(err, &temporary) {
next = temporary.RetryAfter()
}
if next <= 0 {
next = nextInterval(s, attempt)
}
timer.Start(next)
select {
case <-ctx.Done():
return ctx.Err()
case <-timer.C():
}
attempt += 1
}
}
type Timer interface {
Start(duration time.Duration)
Stop()
C() <-chan time.Time
}
// defaultTimer implements Timer interface using time.Timer
type defaultTimer struct {
timer *time.Timer
}
// C returns the timers channel which receives the current time when the timer fires.
func (t *defaultTimer) C() <-chan time.Time {
return t.timer.C
}
// Start starts the timer to fire after the given duration
func (t *defaultTimer) Start(duration time.Duration) {
if t.timer == nil {
t.timer = time.NewTimer(duration)
return
}
if !t.timer.Stop() {
select {
case <-t.timer.C:
default:
}
}
t.timer.Reset(duration)
}
// Stop is called when the timer is not used anymore and resources may be freed.
func (t *defaultTimer) Stop() {
if t.timer != nil {
t.timer.Stop()
}
}
func nextInterval(s *retry.BackoffStrategy, attempt int) time.Duration {
initialInterval := float64(time.Duration(s.InitialInterval) * time.Millisecond)
maxInterval := float64(time.Duration(s.MaxInterval) * time.Millisecond)
exponent := s.Exponent
jitterFactor := float64(0.25)
interval := initialInterval * math.Pow(float64(attempt+1), exponent)
jitter := rand.Float64() * jitterFactor * interval
if rand.Float64() < 0.5 {
jitter = -1 * jitter
}
interval = interval + jitter
if interval <= 0 {
interval = initialInterval
}
if interval > maxInterval {
interval = maxInterval
}
return time.Duration(interval)
}

3
internal/utils/utils.go
View File

@@ -127,6 +127,7 @@ func parseStructTag(tagKey string, field reflect.StructField) map[string]string
func parseParamTag(tagKey string, field reflect.StructField, defaultStyle string, defaultExplode bool) *paramTag {
// example `{tagKey}:"style=simple,explode=false,name=apiID"`
// example `{tagKey}:"inline"`
values := parseStructTag(tagKey, field)
if values == nil {
return nil
@@ -140,6 +141,8 @@ func parseParamTag(tagKey string, field reflect.StructField, defaultStyle string
for k, v := range values {
switch k {
case "inline":
tag.Inline = v == "true"
case "style":
tag.Style = v
case "explode":

232
library.go
View File

@@ -10,7 +10,7 @@ import (
"github.com/LukeHagar/plexgo/internal/utils"
"github.com/LukeHagar/plexgo/models/operations"
"github.com/LukeHagar/plexgo/models/sdkerrors"
"github.com/cenkalti/backoff/v4"
"github.com/LukeHagar/plexgo/retry"
"net/http"
"net/url"
)
@@ -53,7 +53,12 @@ func (s *Library) GetFileHash(ctx context.Context, url_ string, type_ *float64,
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := url.JoinPath(baseURL, "/library/hashes")
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -85,6 +90,10 @@ func (s *Library) GetFileHash(ctx context.Context, url_ string, type_ *float64,
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -115,7 +124,11 @@ func (s *Library) GetFileHash(ctx context.Context, url_ string, type_ *float64,
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)
@@ -264,7 +277,12 @@ func (s *Library) GetRecentlyAddedLibrary(ctx context.Context, request operation
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := url.JoinPath(baseURL, "/library/recentlyAdded")
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -296,6 +314,10 @@ func (s *Library) GetRecentlyAddedLibrary(ctx context.Context, request operation
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -326,7 +348,11 @@ func (s *Library) GetRecentlyAddedLibrary(ctx context.Context, request operation
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)
@@ -500,7 +526,12 @@ func (s *Library) GetAllLibraries(ctx context.Context, opts ...operations.Option
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := url.JoinPath(baseURL, "/library/sections")
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -528,6 +559,10 @@ func (s *Library) GetAllLibraries(ctx context.Context, opts ...operations.Option
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -558,7 +593,11 @@ func (s *Library) GetAllLibraries(ctx context.Context, opts ...operations.Option
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)
@@ -770,7 +809,12 @@ func (s *Library) GetLibraryDetails(ctx context.Context, sectionKey int, include
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := utils.GenerateURL(ctx, baseURL, "/library/sections/{sectionKey}", request, nil)
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -802,6 +846,10 @@ func (s *Library) GetLibraryDetails(ctx context.Context, sectionKey int, include
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -832,7 +880,11 @@ func (s *Library) GetLibraryDetails(ctx context.Context, sectionKey int, include
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)
@@ -1005,7 +1057,12 @@ func (s *Library) DeleteLibrary(ctx context.Context, sectionKey int, opts ...ope
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := utils.GenerateURL(ctx, baseURL, "/library/sections/{sectionKey}", request, nil)
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -1033,6 +1090,10 @@ func (s *Library) DeleteLibrary(ctx context.Context, sectionKey int, opts ...ope
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -1063,7 +1124,11 @@ func (s *Library) DeleteLibrary(ctx context.Context, sectionKey int, opts ...ope
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)
@@ -1211,6 +1276,7 @@ func (s *Library) DeleteLibrary(ctx context.Context, sectionKey int, opts ...ope
// - `resolution`: Items categorized by resolution.
// - `firstCharacter`: Items categorized by the first letter.
// - `folder`: Items categorized by folder.
// - `albums`: Items categorized by album.
func (s *Library) GetLibraryItems(ctx context.Context, request operations.GetLibraryItemsRequest, opts ...operations.Option) (*operations.GetLibraryItemsResponse, error) {
hookCtx := hooks.HookContext{
Context: ctx,
@@ -1231,7 +1297,12 @@ func (s *Library) GetLibraryItems(ctx context.Context, request operations.GetLib
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := utils.GenerateURL(ctx, baseURL, "/library/sections/{sectionKey}/{tag}", request, nil)
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -1263,6 +1334,10 @@ func (s *Library) GetLibraryItems(ctx context.Context, request operations.GetLib
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -1293,7 +1368,11 @@ func (s *Library) GetLibraryItems(ctx context.Context, request operations.GetLib
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)
@@ -1467,7 +1546,12 @@ func (s *Library) GetRefreshLibraryMetadata(ctx context.Context, sectionKey int,
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := utils.GenerateURL(ctx, baseURL, "/library/sections/{sectionKey}/refresh", request, nil)
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -1499,6 +1583,10 @@ func (s *Library) GetRefreshLibraryMetadata(ctx context.Context, sectionKey int,
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -1529,7 +1617,11 @@ func (s *Library) GetRefreshLibraryMetadata(ctx context.Context, sectionKey int,
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)
@@ -1700,7 +1792,12 @@ func (s *Library) GetSearchLibrary(ctx context.Context, sectionKey int, type_ op
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := utils.GenerateURL(ctx, baseURL, "/library/sections/{sectionKey}/search", request, nil)
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -1732,6 +1829,10 @@ func (s *Library) GetSearchLibrary(ctx context.Context, sectionKey int, type_ op
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -1762,7 +1863,11 @@ func (s *Library) GetSearchLibrary(ctx context.Context, sectionKey int, type_ op
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)
@@ -1919,10 +2024,6 @@ func (s *Library) GetSearchAllLibraries(ctx context.Context, request operations.
SecuritySource: s.sdkConfiguration.Security,
}
globals := operations.GetSearchAllLibrariesGlobals{
ClientID: s.sdkConfiguration.Globals.ClientID,
}
o := operations.Options{}
supportedOptions := []string{
operations.SupportedOptionRetries,
@@ -1935,7 +2036,12 @@ func (s *Library) GetSearchAllLibraries(ctx context.Context, request operations.
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := url.JoinPath(baseURL, "/library/search")
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -1959,9 +2065,9 @@ func (s *Library) GetSearchAllLibraries(ctx context.Context, request operations.
req.Header.Set("Accept", "application/json")
req.Header.Set("User-Agent", s.sdkConfiguration.UserAgent)
utils.PopulateHeaders(ctx, req, request, globals)
utils.PopulateHeaders(ctx, req, request, nil)
if err := utils.PopulateQueryParams(ctx, req, request, globals); err != nil {
if err := utils.PopulateQueryParams(ctx, req, request, nil); err != nil {
return nil, fmt.Errorf("error populating query params: %w", err)
}
@@ -1969,6 +2075,10 @@ func (s *Library) GetSearchAllLibraries(ctx context.Context, request operations.
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -1999,7 +2109,11 @@ func (s *Library) GetSearchAllLibraries(ctx context.Context, request operations.
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)
@@ -2172,7 +2286,12 @@ func (s *Library) GetMetaDataByRatingKey(ctx context.Context, ratingKey int64, o
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := utils.GenerateURL(ctx, baseURL, "/library/metadata/{ratingKey}", request, nil)
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -2200,6 +2319,10 @@ func (s *Library) GetMetaDataByRatingKey(ctx context.Context, ratingKey int64, o
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -2230,7 +2353,11 @@ func (s *Library) GetMetaDataByRatingKey(ctx context.Context, ratingKey int64, o
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)
@@ -2404,7 +2531,12 @@ func (s *Library) GetMetadataChildren(ctx context.Context, ratingKey float64, in
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := utils.GenerateURL(ctx, baseURL, "/library/metadata/{ratingKey}/children", request, nil)
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -2436,6 +2568,10 @@ func (s *Library) GetMetadataChildren(ctx context.Context, ratingKey float64, in
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -2466,7 +2602,11 @@ func (s *Library) GetMetadataChildren(ctx context.Context, ratingKey float64, in
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)
@@ -2640,7 +2780,12 @@ func (s *Library) GetTopWatchedContent(ctx context.Context, type_ operations.Get
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := url.JoinPath(baseURL, "/library/all/top")
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -2672,6 +2817,10 @@ func (s *Library) GetTopWatchedContent(ctx context.Context, type_ operations.Get
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -2702,7 +2851,11 @@ func (s *Library) GetTopWatchedContent(ctx context.Context, type_ operations.Get
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)
@@ -2871,7 +3024,12 @@ func (s *Library) GetOnDeck(ctx context.Context, opts ...operations.Option) (*op
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := url.JoinPath(baseURL, "/library/onDeck")
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -2899,6 +3057,10 @@ func (s *Library) GetOnDeck(ctx context.Context, opts ...operations.Option) (*op
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -2929,7 +3091,11 @@ func (s *Library) GetOnDeck(ctx context.Context, opts ...operations.Option) (*op
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)

53
log.go
View File

@@ -10,7 +10,7 @@ import (
"github.com/LukeHagar/plexgo/internal/utils"
"github.com/LukeHagar/plexgo/models/operations"
"github.com/LukeHagar/plexgo/models/sdkerrors"
"github.com/cenkalti/backoff/v4"
"github.com/LukeHagar/plexgo/retry"
"net/http"
"net/url"
)
@@ -54,7 +54,12 @@ func (s *Log) LogLine(ctx context.Context, level operations.Level, message strin
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := url.JoinPath(baseURL, "/log")
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -86,6 +91,10 @@ func (s *Log) LogLine(ctx context.Context, level operations.Level, message strin
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -116,7 +125,11 @@ func (s *Log) LogLine(ctx context.Context, level operations.Level, message strin
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)
@@ -285,7 +298,12 @@ func (s *Log) LogMultiLine(ctx context.Context, request string, opts ...operatio
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := url.JoinPath(baseURL, "/log")
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -319,6 +337,10 @@ func (s *Log) LogMultiLine(ctx context.Context, request string, opts ...operatio
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -349,7 +371,11 @@ func (s *Log) LogMultiLine(ctx context.Context, request string, opts ...operatio
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)
@@ -498,7 +524,12 @@ func (s *Log) EnablePaperTrail(ctx context.Context, opts ...operations.Option) (
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := url.JoinPath(baseURL, "/log/networked")
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -526,6 +557,10 @@ func (s *Log) EnablePaperTrail(ctx context.Context, opts ...operations.Option) (
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -556,7 +591,11 @@ func (s *Log) EnablePaperTrail(ctx context.Context, opts ...operations.Option) (
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)

87
media.go
View File

@@ -10,7 +10,7 @@ import (
"github.com/LukeHagar/plexgo/internal/utils"
"github.com/LukeHagar/plexgo/models/operations"
"github.com/LukeHagar/plexgo/models/sdkerrors"
"github.com/cenkalti/backoff/v4"
"github.com/LukeHagar/plexgo/retry"
"net/http"
"net/url"
)
@@ -52,7 +52,12 @@ func (s *Media) MarkPlayed(ctx context.Context, key float64, opts ...operations.
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := url.JoinPath(baseURL, "/:/scrobble")
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -84,6 +89,10 @@ func (s *Media) MarkPlayed(ctx context.Context, key float64, opts ...operations.
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -114,7 +123,11 @@ func (s *Media) MarkPlayed(ctx context.Context, key float64, opts ...operations.
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)
@@ -267,7 +280,12 @@ func (s *Media) MarkUnplayed(ctx context.Context, key float64, opts ...operation
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := url.JoinPath(baseURL, "/:/unscrobble")
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -299,6 +317,10 @@ func (s *Media) MarkUnplayed(ctx context.Context, key float64, opts ...operation
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -329,7 +351,11 @@ func (s *Media) MarkUnplayed(ctx context.Context, key float64, opts ...operation
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)
@@ -484,7 +510,12 @@ func (s *Media) UpdatePlayProgress(ctx context.Context, key string, time float64
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := url.JoinPath(baseURL, "/:/progress")
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -516,6 +547,10 @@ func (s *Media) UpdatePlayProgress(ctx context.Context, key string, time float64
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -546,7 +581,11 @@ func (s *Media) UpdatePlayProgress(ctx context.Context, key string, time float64
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)
@@ -695,7 +734,12 @@ func (s *Media) GetBannerImage(ctx context.Context, request operations.GetBanner
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := utils.GenerateURL(ctx, baseURL, "/library/metadata/{ratingKey}/banner", request, nil)
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -729,6 +773,10 @@ func (s *Media) GetBannerImage(ctx context.Context, request operations.GetBanner
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -759,7 +807,11 @@ func (s *Media) GetBannerImage(ctx context.Context, request operations.GetBanner
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)
@@ -922,7 +974,12 @@ func (s *Media) GetThumbImage(ctx context.Context, request operations.GetThumbIm
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := utils.GenerateURL(ctx, baseURL, "/library/metadata/{ratingKey}/thumb", request, nil)
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -956,6 +1013,10 @@ func (s *Media) GetThumbImage(ctx context.Context, request operations.GetThumbIm
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -986,7 +1047,11 @@ func (s *Media) GetThumbImage(ctx context.Context, request operations.GetThumbIm
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)

33
models/operations/getlibraryitems.go
View File

@@ -33,6 +33,7 @@ const (
TagResolution Tag = "resolution"
TagFirstCharacter Tag = "firstCharacter"
TagFolder Tag = "folder"
TagAlbums Tag = "albums"
)
func (e Tag) ToPointer() *Tag {
@@ -81,6 +82,8 @@ func (e *Tag) UnmarshalJSON(data []byte) error {
case "firstCharacter":
fallthrough
case "folder":
fallthrough
case "albums":
*e = Tag(v)
return nil
default:
@@ -129,6 +132,8 @@ const (
GetLibraryItemsQueryParamTypeSeason GetLibraryItemsQueryParamType = 3
GetLibraryItemsQueryParamTypeEpisode GetLibraryItemsQueryParamType = 4
GetLibraryItemsQueryParamTypeAudio GetLibraryItemsQueryParamType = 8
GetLibraryItemsQueryParamTypeAlbum GetLibraryItemsQueryParamType = 9
GetLibraryItemsQueryParamTypeTrack GetLibraryItemsQueryParamType = 10
)
func (e GetLibraryItemsQueryParamType) ToPointer() *GetLibraryItemsQueryParamType {
@@ -149,6 +154,10 @@ func (e *GetLibraryItemsQueryParamType) UnmarshalJSON(data []byte) error {
case 4:
fallthrough
case 8:
fallthrough
case 9:
fallthrough
case 10:
*e = GetLibraryItemsQueryParamType(v)
return nil
default:
@@ -649,17 +658,17 @@ func (e *GetLibraryItemsFlattenSeasons) UnmarshalJSON(data []byte) error {
// GetLibraryItemsShowOrdering - Setting that indicates the episode ordering for the show
// None = Library default,
// tmdbAiring = The Movie Database (Aired),
// aired = TheTVDB (Aired),
// dvd = TheTVDB (DVD),
// absolute = TheTVDB (Absolute)).
// tvdbAiring = TheTVDB (Aired),
// tvdbDvd = TheTVDB (DVD),
// tvdbAbsolute = TheTVDB (Absolute)).
type GetLibraryItemsShowOrdering string
const (
GetLibraryItemsShowOrderingNone GetLibraryItemsShowOrdering = "None"
GetLibraryItemsShowOrderingTmdbAiring GetLibraryItemsShowOrdering = "tmdbAiring"
GetLibraryItemsShowOrderingAired GetLibraryItemsShowOrdering = "aired"
GetLibraryItemsShowOrderingDvd GetLibraryItemsShowOrdering = "dvd"
GetLibraryItemsShowOrderingAbsolute GetLibraryItemsShowOrdering = "absolute"
GetLibraryItemsShowOrderingTvdbAiring GetLibraryItemsShowOrdering = "tvdbAiring"
GetLibraryItemsShowOrderingTvdbDvd GetLibraryItemsShowOrdering = "tvdbDvd"
GetLibraryItemsShowOrderingTvdbAbsolute GetLibraryItemsShowOrdering = "tvdbAbsolute"
)
func (e GetLibraryItemsShowOrdering) ToPointer() *GetLibraryItemsShowOrdering {
@@ -675,11 +684,11 @@ func (e *GetLibraryItemsShowOrdering) UnmarshalJSON(data []byte) error {
fallthrough
case "tmdbAiring":
fallthrough
case "aired":
case "tvdbAiring":
fallthrough
case "dvd":
case "tvdbDvd":
fallthrough
case "absolute":
case "tvdbAbsolute":
*e = GetLibraryItemsShowOrdering(v)
return nil
default:
@@ -1647,9 +1656,9 @@ type GetLibraryItemsMetadata struct {
// Setting that indicates the episode ordering for the show
// None = Library default,
// tmdbAiring = The Movie Database (Aired),
// aired = TheTVDB (Aired),
// dvd = TheTVDB (DVD),
// absolute = TheTVDB (Absolute)).
// tvdbAiring = TheTVDB (Aired),
// tvdbDvd = TheTVDB (DVD),
// tvdbAbsolute = TheTVDB (Absolute)).
//
ShowOrdering *GetLibraryItemsShowOrdering `json:"showOrdering,omitempty"`
Thumb *string `json:"thumb,omitempty"`

45
models/operations/getmetadatabyratingkey.go
View File

@@ -791,6 +791,16 @@ type GetMetaDataByRatingKeyMetadata struct {
LibrarySectionTitle *string `json:"librarySectionTitle,omitempty"`
LibrarySectionID *int `json:"librarySectionID,omitempty"`
LibrarySectionKey *string `json:"librarySectionKey,omitempty"`
// The name of the album artist for the track when audio, and the name of the TV show for the episode when video.
GrandparentTitle *string `json:"grandparentTitle,omitempty"`
// The name of the album for the track when audio, and the name of the season for the episode when TV show.
ParentTitle *string `json:"parentTitle,omitempty"`
// The orginal untranslated name of the media item when non-english.
OriginalTitle *string `json:"originalTitle,omitempty"`
// The index starting from 0 of this media item in the MetaData array.
Index *int64 `json:"index,omitempty"`
// The parent index starting from 0 of this media item in the parent MetaData array.
ParentIndex *int64 `json:"parentIndex,omitempty"`
ContentRating *string `json:"contentRating,omitempty"`
Summary *string `json:"summary,omitempty"`
Rating *float64 `json:"rating,omitempty"`
@@ -891,6 +901,41 @@ func (o *GetMetaDataByRatingKeyMetadata) GetLibrarySectionKey() *string {
return o.LibrarySectionKey
}
func (o *GetMetaDataByRatingKeyMetadata) GetGrandparentTitle() *string {
if o == nil {
return nil
}
return o.GrandparentTitle
}
func (o *GetMetaDataByRatingKeyMetadata) GetParentTitle() *string {
if o == nil {
return nil
}
return o.ParentTitle
}
func (o *GetMetaDataByRatingKeyMetadata) GetOriginalTitle() *string {
if o == nil {
return nil
}
return o.OriginalTitle
}
func (o *GetMetaDataByRatingKeyMetadata) GetIndex() *int64 {
if o == nil {
return nil
}
return o.Index
}
func (o *GetMetaDataByRatingKeyMetadata) GetParentIndex() *int64 {
if o == nil {
return nil
}
return o.ParentIndex
}
func (o *GetMetaDataByRatingKeyMetadata) GetContentRating() *string {
if o == nil {
return nil

54
models/operations/getpin.go
View File

@@ -12,54 +12,6 @@ var GetPinServerList = []string{
"https://plex.tv/api/v2",
}
type GetPinGlobals struct {
// An opaque identifier unique to the client (UUID, serial number, or other unique device ID)
ClientID *string `header:"style=simple,explode=false,name=X-Plex-Client-Identifier"`
// The name of the client application. (Plex Web, Plex Media Server, etc.)
ClientName *string `header:"style=simple,explode=false,name=X-Plex-Product"`
// A relatively friendly name for the client device
DeviceNickname *string `header:"style=simple,explode=false,name=X-Plex-Device"`
// The version of the client application.
ClientVersion *string `header:"style=simple,explode=false,name=X-Plex-Version"`
// The platform of the client application.
Platform *string `header:"style=simple,explode=false,name=X-Plex-Platform"`
}
func (o *GetPinGlobals) GetClientID() *string {
if o == nil {
return nil
}
return o.ClientID
}
func (o *GetPinGlobals) GetClientName() *string {
if o == nil {
return nil
}
return o.ClientName
}
func (o *GetPinGlobals) GetDeviceNickname() *string {
if o == nil {
return nil
}
return o.DeviceNickname
}
func (o *GetPinGlobals) GetClientVersion() *string {
if o == nil {
return nil
}
return o.ClientVersion
}
func (o *GetPinGlobals) GetPlatform() *string {
if o == nil {
return nil
}
return o.Platform
}
type GetPinRequest struct {
// Determines the kind of code returned by the API call
// Strong codes are used for Pin authentication flows
@@ -67,7 +19,7 @@ type GetPinRequest struct {
//
Strong *bool `default:"false" queryParam:"style=form,explode=true,name=strong"`
// An opaque identifier unique to the client (UUID, serial number, or other unique device ID)
ClientID *string `header:"style=simple,explode=false,name=X-Plex-Client-Identifier"`
ClientID string `header:"style=simple,explode=false,name=X-Plex-Client-Identifier"`
// The name of the client application. (Plex Web, Plex Media Server, etc.)
ClientName *string `header:"style=simple,explode=false,name=X-Plex-Product"`
// A relatively friendly name for the client device
@@ -96,9 +48,9 @@ func (o *GetPinRequest) GetStrong() *bool {
return o.Strong
}
func (o *GetPinRequest) GetClientID() *string {
func (o *GetPinRequest) GetClientID() string {
if o == nil {
return nil
return ""
}
return o.ClientID
}

6
models/operations/getplaylistcontents.go
View File

@@ -24,6 +24,8 @@ const (
GetPlaylistContentsQueryParamTypeSeason GetPlaylistContentsQueryParamType = 3
GetPlaylistContentsQueryParamTypeEpisode GetPlaylistContentsQueryParamType = 4
GetPlaylistContentsQueryParamTypeAudio GetPlaylistContentsQueryParamType = 8
GetPlaylistContentsQueryParamTypeAlbum GetPlaylistContentsQueryParamType = 9
GetPlaylistContentsQueryParamTypeTrack GetPlaylistContentsQueryParamType = 10
)
func (e GetPlaylistContentsQueryParamType) ToPointer() *GetPlaylistContentsQueryParamType {
@@ -44,6 +46,10 @@ func (e *GetPlaylistContentsQueryParamType) UnmarshalJSON(data []byte) error {
case 4:
fallthrough
case 8:
fallthrough
case 9:
fallthrough
case 10:
*e = GetPlaylistContentsQueryParamType(v)
return nil
default:

30
models/operations/getrecentlyadded.go
View File

@@ -24,6 +24,8 @@ const (
TypeSeason Type = 3
TypeEpisode Type = 4
TypeAudio Type = 8
TypeAlbum Type = 9
TypeTrack Type = 10
)
func (e Type) ToPointer() *Type {
@@ -44,6 +46,10 @@ func (e *Type) UnmarshalJSON(data []byte) error {
case 4:
fallthrough
case 8:
fallthrough
case 9:
fallthrough
case 10:
*e = Type(v)
return nil
default:
@@ -561,17 +567,17 @@ func (e *FlattenSeasons) UnmarshalJSON(data []byte) error {
// ShowOrdering - Setting that indicates the episode ordering for the show
// None = Library default,
// tmdbAiring = The Movie Database (Aired),
// aired = TheTVDB (Aired),
// dvd = TheTVDB (DVD),
// absolute = TheTVDB (Absolute)).
// tvdbAiring = TheTVDB (Aired),
// tvdbDvd = TheTVDB (DVD),
// tvdbAbsolute = TheTVDB (Absolute)).
type ShowOrdering string
const (
ShowOrderingNone ShowOrdering = "None"
ShowOrderingTmdbAiring ShowOrdering = "tmdbAiring"
ShowOrderingAired ShowOrdering = "aired"
ShowOrderingDvd ShowOrdering = "dvd"
ShowOrderingAbsolute ShowOrdering = "absolute"
ShowOrderingTvdbAiring ShowOrdering = "tvdbAiring"
ShowOrderingTvdbDvd ShowOrdering = "tvdbDvd"
ShowOrderingTvdbAbsolute ShowOrdering = "tvdbAbsolute"
)
func (e ShowOrdering) ToPointer() *ShowOrdering {
@@ -587,11 +593,11 @@ func (e *ShowOrdering) UnmarshalJSON(data []byte) error {
fallthrough
case "tmdbAiring":
fallthrough
case "aired":
case "tvdbAiring":
fallthrough
case "dvd":
case "tvdbDvd":
fallthrough
case "absolute":
case "tvdbAbsolute":
*e = ShowOrdering(v)
return nil
default:
@@ -1559,9 +1565,9 @@ type GetRecentlyAddedMetadata struct {
// Setting that indicates the episode ordering for the show
// None = Library default,
// tmdbAiring = The Movie Database (Aired),
// aired = TheTVDB (Aired),
// dvd = TheTVDB (DVD),
// absolute = TheTVDB (Absolute)).
// tvdbAiring = TheTVDB (Aired),
// tvdbDvd = TheTVDB (DVD),
// tvdbAbsolute = TheTVDB (Absolute)).
//
ShowOrdering *ShowOrdering `json:"showOrdering,omitempty"`
Thumb *string `json:"thumb,omitempty"`

6
models/operations/getrecentlyaddedlibrary.go
View File

@@ -24,6 +24,8 @@ const (
QueryParamTypeSeason QueryParamType = 3
QueryParamTypeEpisode QueryParamType = 4
QueryParamTypeAudio QueryParamType = 8
QueryParamTypeAlbum QueryParamType = 9
QueryParamTypeTrack QueryParamType = 10
)
func (e QueryParamType) ToPointer() *QueryParamType {
@@ -44,6 +46,10 @@ func (e *QueryParamType) UnmarshalJSON(data []byte) error {
case 4:
fallthrough
case 8:
fallthrough
case 9:
fallthrough
case 10:
*e = QueryParamType(v)
return nil
default:

42
models/operations/getsearchalllibraries.go
View File

@@ -10,18 +10,6 @@ import (
"net/http"
)
type GetSearchAllLibrariesGlobals struct {
// An opaque identifier unique to the client (UUID, serial number, or other unique device ID)
ClientID *string `header:"style=simple,explode=false,name=X-Plex-Client-Identifier"`
}
func (o *GetSearchAllLibrariesGlobals) GetClientID() *string {
if o == nil {
return nil
}
return o.ClientID
}
type SearchTypes string
const (
@@ -115,7 +103,7 @@ type GetSearchAllLibrariesRequest struct {
// The search query term.
Query string `queryParam:"style=form,explode=true,name=query"`
// An opaque identifier unique to the client (UUID, serial number, or other unique device ID)
ClientID *string `header:"style=simple,explode=false,name=X-Plex-Client-Identifier"`
ClientID string `header:"style=simple,explode=false,name=X-Plex-Client-Identifier"`
// Limit the number of results returned.
Limit *int64 `queryParam:"style=form,explode=true,name=limit"`
// A comma-separated list of search types to include. Valid values are: movies, music, otherVideos, people, tv.
@@ -145,9 +133,9 @@ func (o *GetSearchAllLibrariesRequest) GetQuery() string {
return o.Query
}
func (o *GetSearchAllLibrariesRequest) GetClientID() *string {
func (o *GetSearchAllLibrariesRequest) GetClientID() string {
if o == nil {
return nil
return ""
}
return o.ClientID
}
@@ -242,17 +230,17 @@ func (e *GetSearchAllLibrariesFlattenSeasons) UnmarshalJSON(data []byte) error {
// GetSearchAllLibrariesShowOrdering - Setting that indicates the episode ordering for the show
// None = Library default,
// tmdbAiring = The Movie Database (Aired),
// aired = TheTVDB (Aired),
// dvd = TheTVDB (DVD),
// absolute = TheTVDB (Absolute)).
// tvdbAiring = TheTVDB (Aired),
// tvdbDvd = TheTVDB (DVD),
// tvdbAbsolute = TheTVDB (Absolute)).
type GetSearchAllLibrariesShowOrdering string
const (
GetSearchAllLibrariesShowOrderingNone GetSearchAllLibrariesShowOrdering = "None"
GetSearchAllLibrariesShowOrderingTmdbAiring GetSearchAllLibrariesShowOrdering = "tmdbAiring"
GetSearchAllLibrariesShowOrderingAired GetSearchAllLibrariesShowOrdering = "aired"
GetSearchAllLibrariesShowOrderingDvd GetSearchAllLibrariesShowOrdering = "dvd"
GetSearchAllLibrariesShowOrderingAbsolute GetSearchAllLibrariesShowOrdering = "absolute"
GetSearchAllLibrariesShowOrderingTvdbAiring GetSearchAllLibrariesShowOrdering = "tvdbAiring"
GetSearchAllLibrariesShowOrderingTvdbDvd GetSearchAllLibrariesShowOrdering = "tvdbDvd"
GetSearchAllLibrariesShowOrderingTvdbAbsolute GetSearchAllLibrariesShowOrdering = "tvdbAbsolute"
)
func (e GetSearchAllLibrariesShowOrdering) ToPointer() *GetSearchAllLibrariesShowOrdering {
@@ -268,11 +256,11 @@ func (e *GetSearchAllLibrariesShowOrdering) UnmarshalJSON(data []byte) error {
fallthrough
case "tmdbAiring":
fallthrough
case "aired":
case "tvdbAiring":
fallthrough
case "dvd":
case "tvdbDvd":
fallthrough
case "absolute":
case "tvdbAbsolute":
*e = GetSearchAllLibrariesShowOrdering(v)
return nil
default:
@@ -1240,9 +1228,9 @@ type GetSearchAllLibrariesMetadata struct {
// Setting that indicates the episode ordering for the show
// None = Library default,
// tmdbAiring = The Movie Database (Aired),
// aired = TheTVDB (Aired),
// dvd = TheTVDB (DVD),
// absolute = TheTVDB (Absolute)).
// tvdbAiring = TheTVDB (Aired),
// tvdbDvd = TheTVDB (DVD),
// tvdbAbsolute = TheTVDB (Absolute)).
//
ShowOrdering *GetSearchAllLibrariesShowOrdering `json:"showOrdering,omitempty"`
Thumb *string `json:"thumb,omitempty"`

6
models/operations/getsearchlibrary.go
View File

@@ -22,6 +22,8 @@ const (
GetSearchLibraryQueryParamTypeSeason GetSearchLibraryQueryParamType = 3
GetSearchLibraryQueryParamTypeEpisode GetSearchLibraryQueryParamType = 4
GetSearchLibraryQueryParamTypeAudio GetSearchLibraryQueryParamType = 8
GetSearchLibraryQueryParamTypeAlbum GetSearchLibraryQueryParamType = 9
GetSearchLibraryQueryParamTypeTrack GetSearchLibraryQueryParamType = 10
)
func (e GetSearchLibraryQueryParamType) ToPointer() *GetSearchLibraryQueryParamType {
@@ -42,6 +44,10 @@ func (e *GetSearchLibraryQueryParamType) UnmarshalJSON(data []byte) error {
case 4:
fallthrough
case 8:
fallthrough
case 9:
fallthrough
case 10:
*e = GetSearchLibraryQueryParamType(v)
return nil
default:

18
models/operations/getserverresources.go
View File

@@ -14,18 +14,6 @@ var GetServerResourcesServerList = []string{
"https://plex.tv/api/v2",
}
type GetServerResourcesGlobals struct {
// An opaque identifier unique to the client (UUID, serial number, or other unique device ID)
ClientID *string `header:"style=simple,explode=false,name=X-Plex-Client-Identifier"`
}
func (o *GetServerResourcesGlobals) GetClientID() *string {
if o == nil {
return nil
}
return o.ClientID
}
// IncludeHTTPS - Include Https entries in the results
type IncludeHTTPS int
@@ -118,7 +106,7 @@ type GetServerResourcesRequest struct {
// Include IPv6 entries in the results
IncludeIPv6 *IncludeIPv6 `default:"0" queryParam:"style=form,explode=true,name=includeIPv6"`
// An opaque identifier unique to the client (UUID, serial number, or other unique device ID)
ClientID *string `header:"style=simple,explode=false,name=X-Plex-Client-Identifier"`
ClientID string `header:"style=simple,explode=false,name=X-Plex-Client-Identifier"`
}
func (g GetServerResourcesRequest) MarshalJSON() ([]byte, error) {
@@ -153,9 +141,9 @@ func (o *GetServerResourcesRequest) GetIncludeIPv6() *IncludeIPv6 {
return o.IncludeIPv6
}
func (o *GetServerResourcesRequest) GetClientID() *string {
func (o *GetServerResourcesRequest) GetClientID() string {
if o == nil {
return nil
return ""
}
return o.ClientID
}

54
models/operations/gettokenbypinid.go
View File

@@ -12,59 +12,11 @@ var GetTokenByPinIDServerList = []string{
"https://plex.tv/api/v2",
}
type GetTokenByPinIDGlobals struct {
// An opaque identifier unique to the client (UUID, serial number, or other unique device ID)
ClientID *string `header:"style=simple,explode=false,name=X-Plex-Client-Identifier"`
// The name of the client application. (Plex Web, Plex Media Server, etc.)
ClientName *string `header:"style=simple,explode=false,name=X-Plex-Product"`
// A relatively friendly name for the client device
DeviceNickname *string `header:"style=simple,explode=false,name=X-Plex-Device"`
// The version of the client application.
ClientVersion *string `header:"style=simple,explode=false,name=X-Plex-Version"`
// The platform of the client application.
Platform *string `header:"style=simple,explode=false,name=X-Plex-Platform"`
}
func (o *GetTokenByPinIDGlobals) GetClientID() *string {
if o == nil {
return nil
}
return o.ClientID
}
func (o *GetTokenByPinIDGlobals) GetClientName() *string {
if o == nil {
return nil
}
return o.ClientName
}
func (o *GetTokenByPinIDGlobals) GetDeviceNickname() *string {
if o == nil {
return nil
}
return o.DeviceNickname
}
func (o *GetTokenByPinIDGlobals) GetClientVersion() *string {
if o == nil {
return nil
}
return o.ClientVersion
}
func (o *GetTokenByPinIDGlobals) GetPlatform() *string {
if o == nil {
return nil
}
return o.Platform
}
type GetTokenByPinIDRequest struct {
// The PinID to retrieve an access token for
PinID int64 `pathParam:"style=simple,explode=false,name=pinID"`
// An opaque identifier unique to the client (UUID, serial number, or other unique device ID)
ClientID *string `header:"style=simple,explode=false,name=X-Plex-Client-Identifier"`
ClientID string `header:"style=simple,explode=false,name=X-Plex-Client-Identifier"`
// The name of the client application. (Plex Web, Plex Media Server, etc.)
ClientName *string `header:"style=simple,explode=false,name=X-Plex-Product"`
// A relatively friendly name for the client device
@@ -82,9 +34,9 @@ func (o *GetTokenByPinIDRequest) GetPinID() int64 {
return o.PinID
}
func (o *GetTokenByPinIDRequest) GetClientID() *string {
func (o *GetTokenByPinIDRequest) GetClientID() string {
if o == nil {
return nil
return ""
}
return o.ClientID
}

6
models/operations/gettopwatchedcontent.go
View File

@@ -24,6 +24,8 @@ const (
GetTopWatchedContentQueryParamTypeSeason GetTopWatchedContentQueryParamType = 3
GetTopWatchedContentQueryParamTypeEpisode GetTopWatchedContentQueryParamType = 4
GetTopWatchedContentQueryParamTypeAudio GetTopWatchedContentQueryParamType = 8
GetTopWatchedContentQueryParamTypeAlbum GetTopWatchedContentQueryParamType = 9
GetTopWatchedContentQueryParamTypeTrack GetTopWatchedContentQueryParamType = 10
)
func (e GetTopWatchedContentQueryParamType) ToPointer() *GetTopWatchedContentQueryParamType {
@@ -44,6 +46,10 @@ func (e *GetTopWatchedContentQueryParamType) UnmarshalJSON(data []byte) error {
case 4:
fallthrough
case 8:
fallthrough
case 9:
fallthrough
case 10:
*e = GetTopWatchedContentQueryParamType(v)
return nil
default:

19
models/operations/options.go
View File

@@ -12,7 +12,6 @@ import (
var ErrUnsupportedOption = errors.New("unsupported option")
const (
SupportedOptionServerURL = "serverURL"
SupportedOptionRetries = "retries"
SupportedOptionTimeout = "timeout"
SupportedOptionAcceptHeaderOverride = "acceptHeaderOverride"
@@ -36,6 +35,7 @@ type Options struct {
Timeout *time.Duration
AcceptHeaderOverride *AcceptHeaderEnum
URLOverride *string
SetHeaders map[string]string
}
type Option func(*Options, ...string) error
@@ -43,10 +43,6 @@ type Option func(*Options, ...string) error
// WithServerURL allows providing an alternative server URL.
func WithServerURL(serverURL string) Option {
return func(opts *Options, supportedOptions ...string) error {
if !utils.Contains(supportedOptions, SupportedOptionServerURL) {
return ErrUnsupportedOption
}
opts.ServerURL = &serverURL
return nil
}
@@ -55,10 +51,6 @@ func WithServerURL(serverURL string) Option {
// WithTemplatedServerURL allows providing an alternative server URL with templated parameters.
func WithTemplatedServerURL(serverURL string, params map[string]string) Option {
return func(opts *Options, supportedOptions ...string) error {
if !utils.Contains(supportedOptions, SupportedOptionServerURL) {
return ErrUnsupportedOption
}
if params != nil {
serverURL = utils.ReplaceParameters(serverURL, params)
}
@@ -114,3 +106,12 @@ func WithURLOverride(urlOverride string) Option {
return nil
}
}
// WithSetHeaders takes a map of headers that will applied to a request. If the
// request contains headers that are in the map then they will be overwritten.
func WithSetHeaders(hdrs map[string]string) Option {
return func(opts *Options, supportedOptions ...string) error {
opts.SetHeaders = hdrs
return nil
}
}

54
models/operations/postuserssignindata.go
View File

@@ -13,54 +13,6 @@ var PostUsersSignInDataServerList = []string{
"https://plex.tv/api/v2",
}
type PostUsersSignInDataGlobals struct {
// An opaque identifier unique to the client (UUID, serial number, or other unique device ID)
ClientID *string `header:"style=simple,explode=false,name=X-Plex-Client-Identifier"`
// The name of the client application. (Plex Web, Plex Media Server, etc.)
ClientName *string `header:"style=simple,explode=false,name=X-Plex-Product"`
// A relatively friendly name for the client device
DeviceNickname *string `header:"style=simple,explode=false,name=X-Plex-Device"`
// The version of the client application.
ClientVersion *string `header:"style=simple,explode=false,name=X-Plex-Version"`
// The platform of the client application.
Platform *string `header:"style=simple,explode=false,name=X-Plex-Platform"`
}
func (o *PostUsersSignInDataGlobals) GetClientID() *string {
if o == nil {
return nil
}
return o.ClientID
}
func (o *PostUsersSignInDataGlobals) GetClientName() *string {
if o == nil {
return nil
}
return o.ClientName
}
func (o *PostUsersSignInDataGlobals) GetDeviceNickname() *string {
if o == nil {
return nil
}
return o.DeviceNickname
}
func (o *PostUsersSignInDataGlobals) GetClientVersion() *string {
if o == nil {
return nil
}
return o.ClientVersion
}
func (o *PostUsersSignInDataGlobals) GetPlatform() *string {
if o == nil {
return nil
}
return o.Platform
}
// PostUsersSignInDataRequestBody - Login credentials
type PostUsersSignInDataRequestBody struct {
Login string `form:"name=login"`
@@ -110,7 +62,7 @@ func (o *PostUsersSignInDataRequestBody) GetVerificationCode() *string {
type PostUsersSignInDataRequest struct {
// An opaque identifier unique to the client (UUID, serial number, or other unique device ID)
ClientID *string `header:"style=simple,explode=false,name=X-Plex-Client-Identifier"`
ClientID string `header:"style=simple,explode=false,name=X-Plex-Client-Identifier"`
// The name of the client application. (Plex Web, Plex Media Server, etc.)
ClientName *string `header:"style=simple,explode=false,name=X-Plex-Product"`
// A relatively friendly name for the client device
@@ -123,9 +75,9 @@ type PostUsersSignInDataRequest struct {
RequestBody *PostUsersSignInDataRequestBody `request:"mediaType=application/x-www-form-urlencoded"`
}
func (o *PostUsersSignInDataRequest) GetClientID() *string {
func (o *PostUsersSignInDataRequest) GetClientID() string {
if o == nil {
return nil
return ""
}
return o.ClientID
}

155
playlists.go
View File

@@ -10,7 +10,7 @@ import (
"github.com/LukeHagar/plexgo/internal/utils"
"github.com/LukeHagar/plexgo/models/operations"
"github.com/LukeHagar/plexgo/models/sdkerrors"
"github.com/cenkalti/backoff/v4"
"github.com/LukeHagar/plexgo/retry"
"net/http"
"net/url"
)
@@ -53,7 +53,12 @@ func (s *Playlists) CreatePlaylist(ctx context.Context, request operations.Creat
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := url.JoinPath(baseURL, "/playlists")
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -85,6 +90,10 @@ func (s *Playlists) CreatePlaylist(ctx context.Context, request operations.Creat
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -115,7 +124,11 @@ func (s *Playlists) CreatePlaylist(ctx context.Context, request operations.Creat
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)
@@ -289,7 +302,12 @@ func (s *Playlists) GetPlaylists(ctx context.Context, playlistType *operations.P
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := url.JoinPath(baseURL, "/playlists")
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -321,6 +339,10 @@ func (s *Playlists) GetPlaylists(ctx context.Context, playlistType *operations.P
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -351,7 +373,11 @@ func (s *Playlists) GetPlaylists(ctx context.Context, playlistType *operations.P
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)
@@ -525,7 +551,12 @@ func (s *Playlists) GetPlaylist(ctx context.Context, playlistID float64, opts ..
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := utils.GenerateURL(ctx, baseURL, "/playlists/{playlistID}", request, nil)
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -553,6 +584,10 @@ func (s *Playlists) GetPlaylist(ctx context.Context, playlistID float64, opts ..
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -583,7 +618,11 @@ func (s *Playlists) GetPlaylist(ctx context.Context, playlistID float64, opts ..
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)
@@ -756,7 +795,12 @@ func (s *Playlists) DeletePlaylist(ctx context.Context, playlistID float64, opts
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := utils.GenerateURL(ctx, baseURL, "/playlists/{playlistID}", request, nil)
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -784,6 +828,10 @@ func (s *Playlists) DeletePlaylist(ctx context.Context, playlistID float64, opts
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -814,7 +862,11 @@ func (s *Playlists) DeletePlaylist(ctx context.Context, playlistID float64, opts
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)
@@ -969,7 +1021,12 @@ func (s *Playlists) UpdatePlaylist(ctx context.Context, playlistID float64, titl
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := utils.GenerateURL(ctx, baseURL, "/playlists/{playlistID}", request, nil)
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -1001,6 +1058,10 @@ func (s *Playlists) UpdatePlaylist(ctx context.Context, playlistID float64, titl
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -1031,7 +1092,11 @@ func (s *Playlists) UpdatePlaylist(ctx context.Context, playlistID float64, titl
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)
@@ -1188,7 +1253,12 @@ func (s *Playlists) GetPlaylistContents(ctx context.Context, playlistID float64,
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := utils.GenerateURL(ctx, baseURL, "/playlists/{playlistID}/items", request, nil)
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -1220,6 +1290,10 @@ func (s *Playlists) GetPlaylistContents(ctx context.Context, playlistID float64,
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -1250,7 +1324,11 @@ func (s *Playlists) GetPlaylistContents(ctx context.Context, playlistID float64,
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)
@@ -1423,7 +1501,12 @@ func (s *Playlists) ClearPlaylistContents(ctx context.Context, playlistID float6
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := utils.GenerateURL(ctx, baseURL, "/playlists/{playlistID}/items", request, nil)
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -1451,6 +1534,10 @@ func (s *Playlists) ClearPlaylistContents(ctx context.Context, playlistID float6
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -1481,7 +1568,11 @@ func (s *Playlists) ClearPlaylistContents(ctx context.Context, playlistID float6
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)
@@ -1637,7 +1728,12 @@ func (s *Playlists) AddPlaylistContents(ctx context.Context, playlistID float64,
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := utils.GenerateURL(ctx, baseURL, "/playlists/{playlistID}/items", request, nil)
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -1669,6 +1765,10 @@ func (s *Playlists) AddPlaylistContents(ctx context.Context, playlistID float64,
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -1699,7 +1799,11 @@ func (s *Playlists) AddPlaylistContents(ctx context.Context, playlistID float64,
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)
@@ -1874,7 +1978,12 @@ func (s *Playlists) UploadPlaylist(ctx context.Context, path string, force opera
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := url.JoinPath(baseURL, "/playlists/upload")
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -1906,6 +2015,10 @@ func (s *Playlists) UploadPlaylist(ctx context.Context, path string, force opera
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -1936,7 +2049,11 @@ func (s *Playlists) UploadPlaylist(ctx context.Context, path string, force opera
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)

119
plex.go
View File

@@ -10,7 +10,7 @@ import (
"github.com/LukeHagar/plexgo/internal/utils"
"github.com/LukeHagar/plexgo/models/operations"
"github.com/LukeHagar/plexgo/models/sdkerrors"
"github.com/cenkalti/backoff/v4"
"github.com/LukeHagar/plexgo/retry"
"net/http"
"net/url"
)
@@ -38,7 +38,6 @@ func (s *Plex) GetCompanionsData(ctx context.Context, opts ...operations.Option)
o := operations.Options{}
supportedOptions := []string{
operations.SupportedOptionServerURL,
operations.SupportedOptionRetries,
operations.SupportedOptionTimeout,
}
@@ -81,6 +80,10 @@ func (s *Plex) GetCompanionsData(ctx context.Context, opts ...operations.Option)
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -111,7 +114,11 @@ func (s *Plex) GetCompanionsData(ctx context.Context, opts ...operations.Option)
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)
@@ -270,7 +277,6 @@ func (s *Plex) GetUserFriends(ctx context.Context, opts ...operations.Option) (*
o := operations.Options{}
supportedOptions := []string{
operations.SupportedOptionServerURL,
operations.SupportedOptionRetries,
operations.SupportedOptionTimeout,
}
@@ -313,6 +319,10 @@ func (s *Plex) GetUserFriends(ctx context.Context, opts ...operations.Option) (*
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -343,7 +353,11 @@ func (s *Plex) GetUserFriends(ctx context.Context, opts ...operations.Option) (*
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)
@@ -502,7 +516,6 @@ func (s *Plex) GetGeoData(ctx context.Context, opts ...operations.Option) (*oper
o := operations.Options{}
supportedOptions := []string{
operations.SupportedOptionServerURL,
operations.SupportedOptionRetries,
operations.SupportedOptionTimeout,
}
@@ -541,6 +554,10 @@ func (s *Plex) GetGeoData(ctx context.Context, opts ...operations.Option) (*oper
req.Header.Set("Accept", "application/json")
req.Header.Set("User-Agent", s.sdkConfiguration.UserAgent)
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -571,7 +588,11 @@ func (s *Plex) GetGeoData(ctx context.Context, opts ...operations.Option) (*oper
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)
@@ -740,7 +761,12 @@ func (s *Plex) GetHomeData(ctx context.Context, opts ...operations.Option) (*ope
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := url.JoinPath(baseURL, "/home")
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -768,6 +794,10 @@ func (s *Plex) GetHomeData(ctx context.Context, opts ...operations.Option) (*ope
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -798,7 +828,11 @@ func (s *Plex) GetHomeData(ctx context.Context, opts ...operations.Option) (*ope
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)
@@ -947,7 +981,7 @@ func (s *Plex) GetHomeData(ctx context.Context, opts ...operations.Option) (*ope
// GetServerResources - Get Server Resources
// Get Plex server access tokens and server connections
func (s *Plex) GetServerResources(ctx context.Context, includeHTTPS *operations.IncludeHTTPS, includeRelay *operations.IncludeRelay, includeIPv6 *operations.IncludeIPv6, clientID *string, opts ...operations.Option) (*operations.GetServerResourcesResponse, error) {
func (s *Plex) GetServerResources(ctx context.Context, clientID string, includeHTTPS *operations.IncludeHTTPS, includeRelay *operations.IncludeRelay, includeIPv6 *operations.IncludeIPv6, opts ...operations.Option) (*operations.GetServerResourcesResponse, error) {
hookCtx := hooks.HookContext{
Context: ctx,
OperationID: "get-server-resources",
@@ -962,13 +996,8 @@ func (s *Plex) GetServerResources(ctx context.Context, includeHTTPS *operations.
ClientID: clientID,
}
globals := operations.GetServerResourcesGlobals{
ClientID: s.sdkConfiguration.Globals.ClientID,
}
o := operations.Options{}
supportedOptions := []string{
operations.SupportedOptionServerURL,
operations.SupportedOptionRetries,
operations.SupportedOptionTimeout,
}
@@ -1007,9 +1036,9 @@ func (s *Plex) GetServerResources(ctx context.Context, includeHTTPS *operations.
req.Header.Set("Accept", "application/json")
req.Header.Set("User-Agent", s.sdkConfiguration.UserAgent)
utils.PopulateHeaders(ctx, req, request, globals)
utils.PopulateHeaders(ctx, req, request, nil)
if err := utils.PopulateQueryParams(ctx, req, request, globals); err != nil {
if err := utils.PopulateQueryParams(ctx, req, request, nil); err != nil {
return nil, fmt.Errorf("error populating query params: %w", err)
}
@@ -1017,6 +1046,10 @@ func (s *Plex) GetServerResources(ctx context.Context, includeHTTPS *operations.
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -1047,7 +1080,11 @@ func (s *Plex) GetServerResources(ctx context.Context, includeHTTPS *operations.
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)
@@ -1204,17 +1241,8 @@ func (s *Plex) GetPin(ctx context.Context, request operations.GetPinRequest, opt
SecuritySource: nil,
}
globals := operations.GetPinGlobals{
ClientID: s.sdkConfiguration.Globals.ClientID,
ClientName: s.sdkConfiguration.Globals.ClientName,
DeviceNickname: s.sdkConfiguration.Globals.DeviceNickname,
ClientVersion: s.sdkConfiguration.Globals.ClientVersion,
Platform: s.sdkConfiguration.Globals.Platform,
}
o := operations.Options{}
supportedOptions := []string{
operations.SupportedOptionServerURL,
operations.SupportedOptionRetries,
operations.SupportedOptionTimeout,
}
@@ -1253,12 +1281,16 @@ func (s *Plex) GetPin(ctx context.Context, request operations.GetPinRequest, opt
req.Header.Set("Accept", "application/json")
req.Header.Set("User-Agent", s.sdkConfiguration.UserAgent)
utils.PopulateHeaders(ctx, req, request, globals)
utils.PopulateHeaders(ctx, req, request, nil)
if err := utils.PopulateQueryParams(ctx, req, request, globals); err != nil {
if err := utils.PopulateQueryParams(ctx, req, request, nil); err != nil {
return nil, fmt.Errorf("error populating query params: %w", err)
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -1289,7 +1321,11 @@ func (s *Plex) GetPin(ctx context.Context, request operations.GetPinRequest, opt
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)
@@ -1424,17 +1460,8 @@ func (s *Plex) GetTokenByPinID(ctx context.Context, request operations.GetTokenB
SecuritySource: nil,
}
globals := operations.GetTokenByPinIDGlobals{
ClientID: s.sdkConfiguration.Globals.ClientID,
ClientName: s.sdkConfiguration.Globals.ClientName,
DeviceNickname: s.sdkConfiguration.Globals.DeviceNickname,
ClientVersion: s.sdkConfiguration.Globals.ClientVersion,
Platform: s.sdkConfiguration.Globals.Platform,
}
o := operations.Options{}
supportedOptions := []string{
operations.SupportedOptionServerURL,
operations.SupportedOptionRetries,
operations.SupportedOptionTimeout,
}
@@ -1450,7 +1477,7 @@ func (s *Plex) GetTokenByPinID(ctx context.Context, request operations.GetTokenB
baseURL = *o.ServerURL
}
opURL, err := utils.GenerateURL(ctx, baseURL, "/pins/{pinID}", request, globals)
opURL, err := utils.GenerateURL(ctx, baseURL, "/pins/{pinID}", request, nil)
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
}
@@ -1473,7 +1500,11 @@ func (s *Plex) GetTokenByPinID(ctx context.Context, request operations.GetTokenB
req.Header.Set("Accept", "application/json")
req.Header.Set("User-Agent", s.sdkConfiguration.UserAgent)
utils.PopulateHeaders(ctx, req, request, globals)
utils.PopulateHeaders(ctx, req, request, nil)
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
@@ -1505,7 +1536,11 @@ func (s *Plex) GetTokenByPinID(ctx context.Context, request operations.GetTokenB
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)

44
plexapi.go
View File

@@ -6,7 +6,6 @@ import (
"context"
"encoding/json"
"fmt"
"github.com/LukeHagar/plexgo/internal/globals"
"github.com/LukeHagar/plexgo/internal/hooks"
"github.com/LukeHagar/plexgo/internal/utils"
"github.com/LukeHagar/plexgo/models/components"
@@ -58,7 +57,6 @@ type sdkConfiguration struct {
SDKVersion string
GenVersion string
UserAgent string
Globals globals.Globals
RetryConfig *retry.Config
Hooks *hooks.Hooks
Timeout *time.Duration
@@ -281,41 +279,6 @@ func WithSecuritySource(security func(context.Context) (components.Security, err
}
}
// WithClientID allows setting the ClientID parameter for all supported operations
func WithClientID(clientID string) SDKOption {
return func(sdk *PlexAPI) {
sdk.sdkConfiguration.Globals.ClientID = &clientID
}
}
// WithClientName allows setting the ClientName parameter for all supported operations
func WithClientName(clientName string) SDKOption {
return func(sdk *PlexAPI) {
sdk.sdkConfiguration.Globals.ClientName = &clientName
}
}
// WithClientVersion allows setting the ClientVersion parameter for all supported operations
func WithClientVersion(clientVersion string) SDKOption {
return func(sdk *PlexAPI) {
sdk.sdkConfiguration.Globals.ClientVersion = &clientVersion
}
}
// WithPlatform allows setting the Platform parameter for all supported operations
func WithPlatform(platform string) SDKOption {
return func(sdk *PlexAPI) {
sdk.sdkConfiguration.Globals.Platform = &platform
}
}
// WithDeviceNickname allows setting the DeviceNickname parameter for all supported operations
func WithDeviceNickname(deviceNickname string) SDKOption {
return func(sdk *PlexAPI) {
sdk.sdkConfiguration.Globals.DeviceNickname = &deviceNickname
}
}
func WithRetryConfig(retryConfig retry.Config) SDKOption {
return func(sdk *PlexAPI) {
sdk.sdkConfiguration.RetryConfig = &retryConfig
@@ -335,10 +298,9 @@ func New(opts ...SDKOption) *PlexAPI {
sdkConfiguration: sdkConfiguration{
Language: "go",
OpenAPIDocVersion: "0.0.3",
SDKVersion: "0.16.1",
GenVersion: "2.457.9",
UserAgent: "speakeasy-sdk/go 0.16.1 2.457.9 0.0.3 github.com/LukeHagar/plexgo",
Globals: globals.Globals{},
SDKVersion: "0.17.0",
GenVersion: "2.483.1",
UserAgent: "speakeasy-sdk/go 0.17.0 2.483.1 0.0.3 github.com/LukeHagar/plexgo",
ServerDefaults: []map[string]string{
{
"protocol": "https",

129
retry/config.go
View File

@@ -2,6 +2,15 @@
package retry
import (
"errors"
"net/http"
"strconv"
"time"
)
// BackoffStrategy defines the parameters for exponential backoff. This can be
// used to drive a retry loop for example.
type BackoffStrategy struct {
InitialInterval int
MaxInterval int
@@ -9,8 +18,128 @@ type BackoffStrategy struct {
MaxElapsedTime int
}
// Config configures a retry policy.
type Config struct {
Strategy string
Backoff *BackoffStrategy
RetryConnectionErrors bool
}
// PermanentError is an error that signals that some operation has terminally
// failed and should not be retried.
type PermanentError struct {
cause error
}
// Permanent creates a PermanentError that signals to a retry loop that it
// should stop retrying an operation and return the underlying error.
func Permanent(cause error) error {
if IsPermanentError(cause) {
return cause
}
return &PermanentError{
cause: cause,
}
}
func (e *PermanentError) Error() string {
return e.cause.Error()
}
func (e *PermanentError) Unwrap() error {
return e.cause
}
// TemporaryError represents a retryable error and signals to a retry loop that
// an operation may be retried with an optional wait interval.
type TemporaryError struct {
wait time.Duration
message string
}
// Temporary creates a TemporaryError that signals to a retry loop that an
// operation can be retried. The error may also carry details about how long to
// wait before retrying. This wait interval may be used to override the retry
// policy in use.
func Temporary(message string) error {
return &TemporaryError{
message: message,
}
}
// TemporaryFromResponse creates a TemporaryError similar to Temporary but
// additionally parses the Retry-After header from a response to determine the
// wait interval before the next retry attempt.
func TemporaryFromResponse(message string, res *http.Response) error {
return &TemporaryError{
wait: retryIntervalFromResponse(res),
message: message,
}
}
func (e *TemporaryError) Error() string {
return e.message
}
// RetryAfter returns the time to wait before retrying the request. The zero
// value should be interpreted by retry loops to mean they should fallback on
// their default policy whether expenonential, constant backoff or something
// else. It does not mean that an operation should be retried immediately.
func (e *TemporaryError) RetryAfter() time.Duration {
return e.wait
}
func retryIntervalFromResponse(res *http.Response) time.Duration {
if res == nil {
return 0
}
retryVal := res.Header.Get("retry-after")
if retryVal == "" {
return 0
}
parsedNumber, err := strconv.ParseInt(retryVal, 10, 64)
if err == nil {
if parsedNumber < 0 {
return 0
} else {
return time.Duration(parsedNumber) * time.Second
}
}
parsedDate, err := time.Parse(time.RFC1123, retryVal)
if err == nil {
delta := parsedDate.Sub(time.Now())
if delta < 0 {
return 0
} else {
return delta
}
}
return 0
}
// IsPermanentError returns true if an error value is or contains a
// PermanentError in its chain of errors.
func IsPermanentError(err error) bool {
if err == nil {
return false
}
var pe *PermanentError
return errors.As(err, &pe)
}
// IsTemporaryError returns true if an error value is or contains a
// TemporaryError in its chain of errors.
func IsTemporaryError(err error) bool {
if err == nil {
return false
}
var pe *TemporaryError
return errors.As(err, &pe)
}

53
search.go
View File

@@ -10,7 +10,7 @@ import (
"github.com/LukeHagar/plexgo/internal/utils"
"github.com/LukeHagar/plexgo/models/operations"
"github.com/LukeHagar/plexgo/models/sdkerrors"
"github.com/cenkalti/backoff/v4"
"github.com/LukeHagar/plexgo/retry"
"net/http"
"net/url"
)
@@ -66,7 +66,12 @@ func (s *Search) PerformSearch(ctx context.Context, query string, sectionID *flo
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := url.JoinPath(baseURL, "/hubs/search")
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -98,6 +103,10 @@ func (s *Search) PerformSearch(ctx context.Context, query string, sectionID *flo
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -128,7 +137,11 @@ func (s *Search) PerformSearch(ctx context.Context, query string, sectionID *flo
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)
@@ -286,7 +299,12 @@ func (s *Search) PerformVoiceSearch(ctx context.Context, query string, sectionID
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := url.JoinPath(baseURL, "/hubs/search/voice")
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -318,6 +336,10 @@ func (s *Search) PerformVoiceSearch(ctx context.Context, query string, sectionID
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -348,7 +370,11 @@ func (s *Search) PerformVoiceSearch(ctx context.Context, query string, sectionID
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)
@@ -501,7 +527,12 @@ func (s *Search) GetSearchResults(ctx context.Context, query string, opts ...ope
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := url.JoinPath(baseURL, "/search")
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -533,6 +564,10 @@ func (s *Search) GetSearchResults(ctx context.Context, query string, opts ...ope
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -563,7 +598,11 @@ func (s *Search) GetSearchResults(ctx context.Context, query string, opts ...ope
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)

155
server.go
View File

@@ -10,7 +10,7 @@ import (
"github.com/LukeHagar/plexgo/internal/utils"
"github.com/LukeHagar/plexgo/models/operations"
"github.com/LukeHagar/plexgo/models/sdkerrors"
"github.com/cenkalti/backoff/v4"
"github.com/LukeHagar/plexgo/retry"
"net/http"
"net/url"
)
@@ -48,7 +48,12 @@ func (s *Server) GetServerCapabilities(ctx context.Context, opts ...operations.O
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := url.JoinPath(baseURL, "/")
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -76,6 +81,10 @@ func (s *Server) GetServerCapabilities(ctx context.Context, opts ...operations.O
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -106,7 +115,11 @@ func (s *Server) GetServerCapabilities(ctx context.Context, opts ...operations.O
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)
@@ -275,7 +288,12 @@ func (s *Server) GetServerPreferences(ctx context.Context, opts ...operations.Op
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := url.JoinPath(baseURL, "/:/prefs")
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -303,6 +321,10 @@ func (s *Server) GetServerPreferences(ctx context.Context, opts ...operations.Op
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -333,7 +355,11 @@ func (s *Server) GetServerPreferences(ctx context.Context, opts ...operations.Op
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)
@@ -502,7 +528,12 @@ func (s *Server) GetAvailableClients(ctx context.Context, opts ...operations.Opt
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := url.JoinPath(baseURL, "/clients")
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -530,6 +561,10 @@ func (s *Server) GetAvailableClients(ctx context.Context, opts ...operations.Opt
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -560,7 +595,11 @@ func (s *Server) GetAvailableClients(ctx context.Context, opts ...operations.Opt
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)
@@ -729,7 +768,12 @@ func (s *Server) GetDevices(ctx context.Context, opts ...operations.Option) (*op
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := url.JoinPath(baseURL, "/devices")
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -757,6 +801,10 @@ func (s *Server) GetDevices(ctx context.Context, opts ...operations.Option) (*op
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -787,7 +835,11 @@ func (s *Server) GetDevices(ctx context.Context, opts ...operations.Option) (*op
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)
@@ -956,7 +1008,12 @@ func (s *Server) GetServerIdentity(ctx context.Context, opts ...operations.Optio
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := url.JoinPath(baseURL, "/identity")
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -980,6 +1037,10 @@ func (s *Server) GetServerIdentity(ctx context.Context, opts ...operations.Optio
req.Header.Set("Accept", "application/json")
req.Header.Set("User-Agent", s.sdkConfiguration.UserAgent)
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -1010,7 +1071,11 @@ func (s *Server) GetServerIdentity(ctx context.Context, opts ...operations.Optio
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)
@@ -1157,7 +1222,12 @@ func (s *Server) GetMyPlexAccount(ctx context.Context, opts ...operations.Option
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := url.JoinPath(baseURL, "/myplex/account")
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -1185,6 +1255,10 @@ func (s *Server) GetMyPlexAccount(ctx context.Context, opts ...operations.Option
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -1215,7 +1289,11 @@ func (s *Server) GetMyPlexAccount(ctx context.Context, opts ...operations.Option
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)
@@ -1384,7 +1462,12 @@ func (s *Server) GetResizedPhoto(ctx context.Context, request operations.GetResi
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := url.JoinPath(baseURL, "/photo/:/transcode")
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -1416,6 +1499,10 @@ func (s *Server) GetResizedPhoto(ctx context.Context, request operations.GetResi
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -1446,7 +1533,11 @@ func (s *Server) GetResizedPhoto(ctx context.Context, request operations.GetResi
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)
@@ -1599,7 +1690,12 @@ func (s *Server) GetMediaProviders(ctx context.Context, xPlexToken string, opts
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := url.JoinPath(baseURL, "/media/providers")
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -1629,6 +1725,10 @@ func (s *Server) GetMediaProviders(ctx context.Context, xPlexToken string, opts
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -1659,7 +1759,11 @@ func (s *Server) GetMediaProviders(ctx context.Context, xPlexToken string, opts
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)
@@ -1828,7 +1932,12 @@ func (s *Server) GetServerList(ctx context.Context, opts ...operations.Option) (
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := url.JoinPath(baseURL, "/servers")
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -1856,6 +1965,10 @@ func (s *Server) GetServerList(ctx context.Context, opts ...operations.Option) (
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -1886,7 +1999,11 @@ func (s *Server) GetServerList(ctx context.Context, opts ...operations.Option) (
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)

70
sessions.go
View File

@@ -10,7 +10,7 @@ import (
"github.com/LukeHagar/plexgo/internal/utils"
"github.com/LukeHagar/plexgo/models/operations"
"github.com/LukeHagar/plexgo/models/sdkerrors"
"github.com/cenkalti/backoff/v4"
"github.com/LukeHagar/plexgo/retry"
"net/http"
"net/url"
)
@@ -48,7 +48,12 @@ func (s *Sessions) GetSessions(ctx context.Context, opts ...operations.Option) (
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := url.JoinPath(baseURL, "/status/sessions")
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -76,6 +81,10 @@ func (s *Sessions) GetSessions(ctx context.Context, opts ...operations.Option) (
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -106,7 +115,11 @@ func (s *Sessions) GetSessions(ctx context.Context, opts ...operations.Option) (
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)
@@ -282,7 +295,12 @@ func (s *Sessions) GetSessionHistory(ctx context.Context, sort *string, accountI
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := url.JoinPath(baseURL, "/status/sessions/history/all")
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -314,6 +332,10 @@ func (s *Sessions) GetSessionHistory(ctx context.Context, sort *string, accountI
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -344,7 +366,11 @@ func (s *Sessions) GetSessionHistory(ctx context.Context, sort *string, accountI
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)
@@ -513,7 +539,12 @@ func (s *Sessions) GetTranscodeSessions(ctx context.Context, opts ...operations.
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := url.JoinPath(baseURL, "/transcode/sessions")
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -541,6 +572,10 @@ func (s *Sessions) GetTranscodeSessions(ctx context.Context, opts ...operations.
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -571,7 +606,11 @@ func (s *Sessions) GetTranscodeSessions(ctx context.Context, opts ...operations.
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)
@@ -744,7 +783,12 @@ func (s *Sessions) StopTranscodeSession(ctx context.Context, sessionKey string,
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := utils.GenerateURL(ctx, baseURL, "/transcode/sessions/{sessionKey}", request, nil)
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -772,6 +816,10 @@ func (s *Sessions) StopTranscodeSession(ctx context.Context, sessionKey string,
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -802,7 +850,11 @@ func (s *Sessions) StopTranscodeSession(ctx context.Context, sessionKey string,
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)

53
statistics.go
View File

@@ -10,7 +10,7 @@ import (
"github.com/LukeHagar/plexgo/internal/utils"
"github.com/LukeHagar/plexgo/models/operations"
"github.com/LukeHagar/plexgo/models/sdkerrors"
"github.com/cenkalti/backoff/v4"
"github.com/LukeHagar/plexgo/retry"
"net/http"
"net/url"
)
@@ -52,7 +52,12 @@ func (s *Statistics) GetStatistics(ctx context.Context, timespan *int64, opts ..
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := url.JoinPath(baseURL, "/statistics/media")
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -84,6 +89,10 @@ func (s *Statistics) GetStatistics(ctx context.Context, timespan *int64, opts ..
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -114,7 +123,11 @@ func (s *Statistics) GetStatistics(ctx context.Context, timespan *int64, opts ..
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)
@@ -287,7 +300,12 @@ func (s *Statistics) GetResourcesStatistics(ctx context.Context, timespan *int64
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := url.JoinPath(baseURL, "/statistics/resources")
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -319,6 +337,10 @@ func (s *Statistics) GetResourcesStatistics(ctx context.Context, timespan *int64
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -349,7 +371,11 @@ func (s *Statistics) GetResourcesStatistics(ctx context.Context, timespan *int64
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)
@@ -522,7 +548,12 @@ func (s *Statistics) GetBandwidthStatistics(ctx context.Context, timespan *int64
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := url.JoinPath(baseURL, "/statistics/bandwidth")
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -554,6 +585,10 @@ func (s *Statistics) GetBandwidthStatistics(ctx context.Context, timespan *int64
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -584,7 +619,11 @@ func (s *Statistics) GetBandwidthStatistics(ctx context.Context, timespan *int64
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)

53
updater.go
View File

@@ -10,7 +10,7 @@ import (
"github.com/LukeHagar/plexgo/internal/utils"
"github.com/LukeHagar/plexgo/models/operations"
"github.com/LukeHagar/plexgo/models/sdkerrors"
"github.com/cenkalti/backoff/v4"
"github.com/LukeHagar/plexgo/retry"
"net/http"
"net/url"
)
@@ -49,7 +49,12 @@ func (s *Updater) GetUpdateStatus(ctx context.Context, opts ...operations.Option
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := url.JoinPath(baseURL, "/updater/status")
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -77,6 +82,10 @@ func (s *Updater) GetUpdateStatus(ctx context.Context, opts ...operations.Option
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -107,7 +116,11 @@ func (s *Updater) GetUpdateStatus(ctx context.Context, opts ...operations.Option
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)
@@ -280,7 +293,12 @@ func (s *Updater) CheckForUpdates(ctx context.Context, download *operations.Down
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := url.JoinPath(baseURL, "/updater/check")
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -312,6 +330,10 @@ func (s *Updater) CheckForUpdates(ctx context.Context, download *operations.Down
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -342,7 +364,11 @@ func (s *Updater) CheckForUpdates(ctx context.Context, download *operations.Down
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)
@@ -496,7 +522,12 @@ func (s *Updater) ApplyUpdates(ctx context.Context, tonight *operations.Tonight,
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := url.JoinPath(baseURL, "/updater/apply")
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -528,6 +559,10 @@ func (s *Updater) ApplyUpdates(ctx context.Context, tonight *operations.Tonight,
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -558,7 +593,11 @@ func (s *Updater) ApplyUpdates(ctx context.Context, tonight *operations.Tonight,
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)

36
video.go
View File

@@ -10,7 +10,7 @@ import (
"github.com/LukeHagar/plexgo/internal/utils"
"github.com/LukeHagar/plexgo/models/operations"
"github.com/LukeHagar/plexgo/models/sdkerrors"
"github.com/cenkalti/backoff/v4"
"github.com/LukeHagar/plexgo/retry"
"net/http"
"net/url"
)
@@ -48,7 +48,12 @@ func (s *Video) GetTimeline(ctx context.Context, request operations.GetTimelineR
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := url.JoinPath(baseURL, "/:/timeline")
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -80,6 +85,10 @@ func (s *Video) GetTimeline(ctx context.Context, request operations.GetTimelineR
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -110,7 +119,11 @@ func (s *Video) GetTimeline(ctx context.Context, request operations.GetTimelineR
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)
@@ -259,7 +272,12 @@ func (s *Video) StartUniversalTranscode(ctx context.Context, request operations.
}
}
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
var baseURL string
if o.ServerURL == nil {
baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
} else {
baseURL = *o.ServerURL
}
opURL, err := url.JoinPath(baseURL, "/video/:/transcode/universal/start.mpd")
if err != nil {
return nil, fmt.Errorf("error generating URL: %w", err)
@@ -291,6 +309,10 @@ func (s *Video) StartUniversalTranscode(ctx context.Context, request operations.
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -321,7 +343,11 @@ func (s *Video) StartUniversalTranscode(ctx context.Context, request operations.
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)

13
watchlist.go
View File

@@ -10,7 +10,7 @@ import (
"github.com/LukeHagar/plexgo/internal/utils"
"github.com/LukeHagar/plexgo/models/operations"
"github.com/LukeHagar/plexgo/models/sdkerrors"
"github.com/cenkalti/backoff/v4"
"github.com/LukeHagar/plexgo/retry"
"net/http"
)
@@ -37,7 +37,6 @@ func (s *Watchlist) GetWatchList(ctx context.Context, request operations.GetWatc
o := operations.Options{}
supportedOptions := []string{
operations.SupportedOptionServerURL,
operations.SupportedOptionRetries,
operations.SupportedOptionTimeout,
}
@@ -86,6 +85,10 @@ func (s *Watchlist) GetWatchList(ctx context.Context, request operations.GetWatc
return nil, err
}
for k, v := range o.SetHeaders {
req.Header.Set(k, v)
}
globalRetryConfig := s.sdkConfiguration.RetryConfig
retryConfig := o.Retries
if retryConfig == nil {
@@ -116,7 +119,11 @@ func (s *Watchlist) GetWatchList(ctx context.Context, request operations.GetWatc
req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
if err != nil {
return nil, backoff.Permanent(err)
if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
return nil, err
}
return nil, retry.Permanent(err)
}
httpRes, err := s.sdkConfiguration.Client.Do(req)