mirror of
https://github.com/LukeHagar/plexruby.git
synced 2025-12-06 04:20:52 +00:00
2127 lines
76 KiB
Ruby
2127 lines
76 KiB
Ruby
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
|
|
|
# typed: true
|
|
# frozen_string_literal: true
|
|
|
|
require 'faraday'
|
|
require 'faraday/multipart'
|
|
require 'faraday/retry'
|
|
require 'sorbet-runtime'
|
|
require_relative 'sdk_hooks/hooks'
|
|
require_relative 'utils/retries'
|
|
|
|
module PlexRubySDK
|
|
extend T::Sig
|
|
class Library
|
|
extend T::Sig
|
|
# API Calls interacting with Plex Media Server Libraries
|
|
#
|
|
|
|
sig { params(sdk_config: SDKConfiguration).void }
|
|
def initialize(sdk_config)
|
|
@sdk_configuration = sdk_config
|
|
end
|
|
|
|
|
|
sig { params(url: ::String, type: T.nilable(::Float), timeout_ms: T.nilable(Integer)).returns(::PlexRubySDK::Operations::GetFileHashResponse) }
|
|
def get_file_hash(url, type = nil, timeout_ms = nil)
|
|
# get_file_hash - Get Hash Value
|
|
# This resource returns hash values for local files
|
|
request = ::PlexRubySDK::Operations::GetFileHashRequest.new(
|
|
|
|
url: url,
|
|
type: type
|
|
)
|
|
url, params = @sdk_configuration.get_server_details
|
|
base_url = Utils.template_url(url, params)
|
|
url = "#{base_url}/library/hashes"
|
|
headers = {}
|
|
query_params = Utils.get_query_params(::PlexRubySDK::Operations::GetFileHashRequest, request)
|
|
headers['Accept'] = 'application/json'
|
|
headers['user-agent'] = @sdk_configuration.user_agent
|
|
|
|
security = !@sdk_configuration.nil? && !@sdk_configuration.security_source.nil? ? @sdk_configuration.security_source.call : nil
|
|
|
|
timeout = (timeout_ms.to_f / 1000) unless timeout_ms.nil?
|
|
timeout ||= @sdk_configuration.timeout
|
|
|
|
connection = @sdk_configuration.client
|
|
|
|
hook_ctx = SDKHooks::HookContext.new(
|
|
base_url: base_url,
|
|
oauth2_scopes: [],
|
|
operation_id: 'getFileHash',
|
|
security_source: @sdk_configuration.security_source
|
|
)
|
|
|
|
error = T.let(nil, T.nilable(StandardError))
|
|
r = T.let(nil, T.nilable(Faraday::Response))
|
|
|
|
begin
|
|
r = connection.get(url) do |req|
|
|
req.headers.merge!(headers)
|
|
req.options.timeout = timeout unless timeout.nil?
|
|
req.params = query_params
|
|
Utils.configure_request_security(req, security)
|
|
|
|
@sdk_configuration.hooks.before_request(
|
|
hook_ctx: SDKHooks::BeforeRequestHookContext.new(
|
|
hook_ctx: hook_ctx
|
|
),
|
|
request: req
|
|
)
|
|
end
|
|
rescue StandardError => e
|
|
error = e
|
|
ensure
|
|
if r.nil? || Utils.error_status?(r.status)
|
|
r = @sdk_configuration.hooks.after_error(
|
|
error: error,
|
|
hook_ctx: SDKHooks::AfterErrorHookContext.new(
|
|
hook_ctx: hook_ctx
|
|
),
|
|
response: r
|
|
)
|
|
else
|
|
r = @sdk_configuration.hooks.after_success(
|
|
hook_ctx: SDKHooks::AfterSuccessHookContext.new(
|
|
hook_ctx: hook_ctx
|
|
),
|
|
response: r
|
|
)
|
|
end
|
|
|
|
if r.nil?
|
|
raise error if !error.nil?
|
|
raise 'no response'
|
|
end
|
|
end
|
|
|
|
content_type = r.headers.fetch('Content-Type', 'application/octet-stream')
|
|
|
|
res = ::PlexRubySDK::Operations::GetFileHashResponse.new(
|
|
status_code: r.status, content_type: content_type, raw_response: r
|
|
)
|
|
if r.status == 200
|
|
elsif r.status == 400
|
|
if Utils.match_content_type(content_type, 'application/json')
|
|
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetFileHashBadRequest)
|
|
res.bad_request = out
|
|
end
|
|
elsif r.status == 401
|
|
if Utils.match_content_type(content_type, 'application/json')
|
|
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetFileHashUnauthorized)
|
|
res.unauthorized = out
|
|
end
|
|
end
|
|
|
|
res
|
|
end
|
|
|
|
|
|
sig { params(request: T.nilable(::PlexRubySDK::Operations::GetRecentlyAddedLibraryRequest), timeout_ms: T.nilable(Integer)).returns(::PlexRubySDK::Operations::GetRecentlyAddedLibraryResponse) }
|
|
def get_recently_added_library(request, timeout_ms = nil)
|
|
# get_recently_added_library - Get Recently Added
|
|
# This endpoint will return the recently added content.
|
|
#
|
|
url, params = @sdk_configuration.get_server_details
|
|
base_url = Utils.template_url(url, params)
|
|
url = "#{base_url}/library/recentlyAdded"
|
|
headers = {}
|
|
query_params = Utils.get_query_params(::PlexRubySDK::Operations::GetRecentlyAddedLibraryRequest, request)
|
|
headers['Accept'] = 'application/json'
|
|
headers['user-agent'] = @sdk_configuration.user_agent
|
|
|
|
security = !@sdk_configuration.nil? && !@sdk_configuration.security_source.nil? ? @sdk_configuration.security_source.call : nil
|
|
|
|
timeout = (timeout_ms.to_f / 1000) unless timeout_ms.nil?
|
|
timeout ||= @sdk_configuration.timeout
|
|
|
|
connection = @sdk_configuration.client
|
|
|
|
hook_ctx = SDKHooks::HookContext.new(
|
|
base_url: base_url,
|
|
oauth2_scopes: [],
|
|
operation_id: 'get-recently-added-library',
|
|
security_source: @sdk_configuration.security_source
|
|
)
|
|
|
|
error = T.let(nil, T.nilable(StandardError))
|
|
r = T.let(nil, T.nilable(Faraday::Response))
|
|
|
|
begin
|
|
r = connection.get(url) do |req|
|
|
req.headers.merge!(headers)
|
|
req.options.timeout = timeout unless timeout.nil?
|
|
req.params = query_params
|
|
Utils.configure_request_security(req, security)
|
|
|
|
@sdk_configuration.hooks.before_request(
|
|
hook_ctx: SDKHooks::BeforeRequestHookContext.new(
|
|
hook_ctx: hook_ctx
|
|
),
|
|
request: req
|
|
)
|
|
end
|
|
rescue StandardError => e
|
|
error = e
|
|
ensure
|
|
if r.nil? || Utils.error_status?(r.status)
|
|
r = @sdk_configuration.hooks.after_error(
|
|
error: error,
|
|
hook_ctx: SDKHooks::AfterErrorHookContext.new(
|
|
hook_ctx: hook_ctx
|
|
),
|
|
response: r
|
|
)
|
|
else
|
|
r = @sdk_configuration.hooks.after_success(
|
|
hook_ctx: SDKHooks::AfterSuccessHookContext.new(
|
|
hook_ctx: hook_ctx
|
|
),
|
|
response: r
|
|
)
|
|
end
|
|
|
|
if r.nil?
|
|
raise error if !error.nil?
|
|
raise 'no response'
|
|
end
|
|
end
|
|
|
|
content_type = r.headers.fetch('Content-Type', 'application/octet-stream')
|
|
|
|
res = ::PlexRubySDK::Operations::GetRecentlyAddedLibraryResponse.new(
|
|
status_code: r.status, content_type: content_type, raw_response: r
|
|
)
|
|
if r.status == 200
|
|
if Utils.match_content_type(content_type, 'application/json')
|
|
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetRecentlyAddedLibraryResponseBody)
|
|
res.object = out
|
|
end
|
|
elsif r.status == 400
|
|
if Utils.match_content_type(content_type, 'application/json')
|
|
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetRecentlyAddedLibraryBadRequest)
|
|
res.bad_request = out
|
|
end
|
|
elsif r.status == 401
|
|
if Utils.match_content_type(content_type, 'application/json')
|
|
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetRecentlyAddedLibraryUnauthorized)
|
|
res.unauthorized = out
|
|
end
|
|
end
|
|
|
|
res
|
|
end
|
|
|
|
|
|
sig { params(timeout_ms: T.nilable(Integer)).returns(::PlexRubySDK::Operations::GetAllLibrariesResponse) }
|
|
def get_all_libraries(timeout_ms = nil)
|
|
# get_all_libraries - Get All Libraries
|
|
# A library section (commonly referred to as just a library) is a collection of media.
|
|
# Libraries are typed, and depending on their type provide either a flat or a hierarchical view of the media.
|
|
# For example, a music library has an artist > albums > tracks structure, whereas a movie library is flat.
|
|
#
|
|
# Libraries have features beyond just being a collection of media; for starters, they include information about supported types, filters and sorts.
|
|
# This allows a client to provide a rich interface around the media (e.g. allow sorting movies by release year).
|
|
#
|
|
url, params = @sdk_configuration.get_server_details
|
|
base_url = Utils.template_url(url, params)
|
|
url = "#{base_url}/library/sections"
|
|
headers = {}
|
|
headers['Accept'] = 'application/json'
|
|
headers['user-agent'] = @sdk_configuration.user_agent
|
|
|
|
security = !@sdk_configuration.nil? && !@sdk_configuration.security_source.nil? ? @sdk_configuration.security_source.call : nil
|
|
|
|
timeout = (timeout_ms.to_f / 1000) unless timeout_ms.nil?
|
|
timeout ||= @sdk_configuration.timeout
|
|
|
|
connection = @sdk_configuration.client
|
|
|
|
hook_ctx = SDKHooks::HookContext.new(
|
|
base_url: base_url,
|
|
oauth2_scopes: [],
|
|
operation_id: 'get-all-libraries',
|
|
security_source: @sdk_configuration.security_source
|
|
)
|
|
|
|
error = T.let(nil, T.nilable(StandardError))
|
|
r = T.let(nil, T.nilable(Faraday::Response))
|
|
|
|
begin
|
|
r = connection.get(url) do |req|
|
|
req.headers.merge!(headers)
|
|
req.options.timeout = timeout unless timeout.nil?
|
|
Utils.configure_request_security(req, security)
|
|
|
|
@sdk_configuration.hooks.before_request(
|
|
hook_ctx: SDKHooks::BeforeRequestHookContext.new(
|
|
hook_ctx: hook_ctx
|
|
),
|
|
request: req
|
|
)
|
|
end
|
|
rescue StandardError => e
|
|
error = e
|
|
ensure
|
|
if r.nil? || Utils.error_status?(r.status)
|
|
r = @sdk_configuration.hooks.after_error(
|
|
error: error,
|
|
hook_ctx: SDKHooks::AfterErrorHookContext.new(
|
|
hook_ctx: hook_ctx
|
|
),
|
|
response: r
|
|
)
|
|
else
|
|
r = @sdk_configuration.hooks.after_success(
|
|
hook_ctx: SDKHooks::AfterSuccessHookContext.new(
|
|
hook_ctx: hook_ctx
|
|
),
|
|
response: r
|
|
)
|
|
end
|
|
|
|
if r.nil?
|
|
raise error if !error.nil?
|
|
raise 'no response'
|
|
end
|
|
end
|
|
|
|
content_type = r.headers.fetch('Content-Type', 'application/octet-stream')
|
|
|
|
res = ::PlexRubySDK::Operations::GetAllLibrariesResponse.new(
|
|
status_code: r.status, content_type: content_type, raw_response: r
|
|
)
|
|
if r.status == 200
|
|
if Utils.match_content_type(content_type, 'application/json')
|
|
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetAllLibrariesResponseBody)
|
|
res.object = out
|
|
end
|
|
elsif r.status == 400
|
|
if Utils.match_content_type(content_type, 'application/json')
|
|
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetAllLibrariesBadRequest)
|
|
res.bad_request = out
|
|
end
|
|
elsif r.status == 401
|
|
if Utils.match_content_type(content_type, 'application/json')
|
|
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetAllLibrariesUnauthorized)
|
|
res.unauthorized = out
|
|
end
|
|
end
|
|
|
|
res
|
|
end
|
|
|
|
|
|
sig { params(section_key: ::Integer, include_details: T.nilable(::PlexRubySDK::Operations::IncludeDetails), timeout_ms: T.nilable(Integer)).returns(::PlexRubySDK::Operations::GetLibraryDetailsResponse) }
|
|
def get_library_details(section_key, include_details = nil, timeout_ms = nil)
|
|
# get_library_details - Get Library Details
|
|
# ## Library Details Endpoint
|
|
#
|
|
# This endpoint provides comprehensive details about the library, focusing on organizational aspects rather than the content itself.
|
|
#
|
|
# The details include:
|
|
#
|
|
# ### Directories
|
|
# Organized into three categories:
|
|
#
|
|
# - **Primary Directories**:
|
|
# - Used in some clients for quick access to media subsets (e.g., "All", "On Deck").
|
|
# - Most can be replicated via media queries.
|
|
# - Customizable by users.
|
|
#
|
|
# - **Secondary Directories**:
|
|
# - Marked with `secondary="1"`.
|
|
# - Used in older clients for structured navigation.
|
|
#
|
|
# - **Special Directories**:
|
|
# - Includes a "By Folder" entry for filesystem-based browsing.
|
|
# - Contains an obsolete `search="1"` entry for on-the-fly search dialog creation.
|
|
#
|
|
# ### Types
|
|
# Each type in the library comes with a set of filters and sorts, aiding in building dynamic media controls:
|
|
#
|
|
# - **Type Object Attributes**:
|
|
# - `key`: Endpoint for the media list of this type.
|
|
# - `type`: Metadata type (if standard Plex type).
|
|
# - `title`: Title for this content type (e.g., "Movies").
|
|
#
|
|
# - **Filter Objects**:
|
|
# - Subset of the media query language.
|
|
# - Attributes include `filter` (name), `filterType` (data type), `key` (endpoint for value range), and `title`.
|
|
#
|
|
# - **Sort Objects**:
|
|
# - Description of sort fields.
|
|
# - Attributes include `defaultDirection` (asc/desc), `descKey` and `key` (sort parameters), and `title`.
|
|
#
|
|
# > **Note**: Filters and sorts are optional; without them, no filtering controls are rendered.
|
|
#
|
|
request = ::PlexRubySDK::Operations::GetLibraryDetailsRequest.new(
|
|
|
|
section_key: section_key,
|
|
include_details: include_details
|
|
)
|
|
url, params = @sdk_configuration.get_server_details
|
|
base_url = Utils.template_url(url, params)
|
|
url = Utils.generate_url(
|
|
::PlexRubySDK::Operations::GetLibraryDetailsRequest,
|
|
base_url,
|
|
'/library/sections/{sectionKey}',
|
|
request
|
|
)
|
|
headers = {}
|
|
query_params = Utils.get_query_params(::PlexRubySDK::Operations::GetLibraryDetailsRequest, request)
|
|
headers['Accept'] = 'application/json'
|
|
headers['user-agent'] = @sdk_configuration.user_agent
|
|
|
|
security = !@sdk_configuration.nil? && !@sdk_configuration.security_source.nil? ? @sdk_configuration.security_source.call : nil
|
|
|
|
timeout = (timeout_ms.to_f / 1000) unless timeout_ms.nil?
|
|
timeout ||= @sdk_configuration.timeout
|
|
|
|
connection = @sdk_configuration.client
|
|
|
|
hook_ctx = SDKHooks::HookContext.new(
|
|
base_url: base_url,
|
|
oauth2_scopes: [],
|
|
operation_id: 'get-library-details',
|
|
security_source: @sdk_configuration.security_source
|
|
)
|
|
|
|
error = T.let(nil, T.nilable(StandardError))
|
|
r = T.let(nil, T.nilable(Faraday::Response))
|
|
|
|
begin
|
|
r = connection.get(url) do |req|
|
|
req.headers.merge!(headers)
|
|
req.options.timeout = timeout unless timeout.nil?
|
|
req.params = query_params
|
|
Utils.configure_request_security(req, security)
|
|
|
|
@sdk_configuration.hooks.before_request(
|
|
hook_ctx: SDKHooks::BeforeRequestHookContext.new(
|
|
hook_ctx: hook_ctx
|
|
),
|
|
request: req
|
|
)
|
|
end
|
|
rescue StandardError => e
|
|
error = e
|
|
ensure
|
|
if r.nil? || Utils.error_status?(r.status)
|
|
r = @sdk_configuration.hooks.after_error(
|
|
error: error,
|
|
hook_ctx: SDKHooks::AfterErrorHookContext.new(
|
|
hook_ctx: hook_ctx
|
|
),
|
|
response: r
|
|
)
|
|
else
|
|
r = @sdk_configuration.hooks.after_success(
|
|
hook_ctx: SDKHooks::AfterSuccessHookContext.new(
|
|
hook_ctx: hook_ctx
|
|
),
|
|
response: r
|
|
)
|
|
end
|
|
|
|
if r.nil?
|
|
raise error if !error.nil?
|
|
raise 'no response'
|
|
end
|
|
end
|
|
|
|
content_type = r.headers.fetch('Content-Type', 'application/octet-stream')
|
|
|
|
res = ::PlexRubySDK::Operations::GetLibraryDetailsResponse.new(
|
|
status_code: r.status, content_type: content_type, raw_response: r
|
|
)
|
|
if r.status == 200
|
|
if Utils.match_content_type(content_type, 'application/json')
|
|
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetLibraryDetailsResponseBody)
|
|
res.object = out
|
|
end
|
|
elsif r.status == 400
|
|
if Utils.match_content_type(content_type, 'application/json')
|
|
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetLibraryDetailsBadRequest)
|
|
res.bad_request = out
|
|
end
|
|
elsif r.status == 401
|
|
if Utils.match_content_type(content_type, 'application/json')
|
|
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetLibraryDetailsUnauthorized)
|
|
res.unauthorized = out
|
|
end
|
|
end
|
|
|
|
res
|
|
end
|
|
|
|
|
|
sig { params(section_key: ::Integer, timeout_ms: T.nilable(Integer)).returns(::PlexRubySDK::Operations::DeleteLibraryResponse) }
|
|
def delete_library(section_key, timeout_ms = nil)
|
|
# delete_library - Delete Library Section
|
|
# Delete a library using a specific section id
|
|
request = ::PlexRubySDK::Operations::DeleteLibraryRequest.new(
|
|
|
|
section_key: section_key
|
|
)
|
|
url, params = @sdk_configuration.get_server_details
|
|
base_url = Utils.template_url(url, params)
|
|
url = Utils.generate_url(
|
|
::PlexRubySDK::Operations::DeleteLibraryRequest,
|
|
base_url,
|
|
'/library/sections/{sectionKey}',
|
|
request
|
|
)
|
|
headers = {}
|
|
headers['Accept'] = 'application/json'
|
|
headers['user-agent'] = @sdk_configuration.user_agent
|
|
|
|
security = !@sdk_configuration.nil? && !@sdk_configuration.security_source.nil? ? @sdk_configuration.security_source.call : nil
|
|
|
|
timeout = (timeout_ms.to_f / 1000) unless timeout_ms.nil?
|
|
timeout ||= @sdk_configuration.timeout
|
|
|
|
connection = @sdk_configuration.client
|
|
|
|
hook_ctx = SDKHooks::HookContext.new(
|
|
base_url: base_url,
|
|
oauth2_scopes: [],
|
|
operation_id: 'deleteLibrary',
|
|
security_source: @sdk_configuration.security_source
|
|
)
|
|
|
|
error = T.let(nil, T.nilable(StandardError))
|
|
r = T.let(nil, T.nilable(Faraday::Response))
|
|
|
|
begin
|
|
r = connection.delete(url) do |req|
|
|
req.headers.merge!(headers)
|
|
req.options.timeout = timeout unless timeout.nil?
|
|
Utils.configure_request_security(req, security)
|
|
|
|
@sdk_configuration.hooks.before_request(
|
|
hook_ctx: SDKHooks::BeforeRequestHookContext.new(
|
|
hook_ctx: hook_ctx
|
|
),
|
|
request: req
|
|
)
|
|
end
|
|
rescue StandardError => e
|
|
error = e
|
|
ensure
|
|
if r.nil? || Utils.error_status?(r.status)
|
|
r = @sdk_configuration.hooks.after_error(
|
|
error: error,
|
|
hook_ctx: SDKHooks::AfterErrorHookContext.new(
|
|
hook_ctx: hook_ctx
|
|
),
|
|
response: r
|
|
)
|
|
else
|
|
r = @sdk_configuration.hooks.after_success(
|
|
hook_ctx: SDKHooks::AfterSuccessHookContext.new(
|
|
hook_ctx: hook_ctx
|
|
),
|
|
response: r
|
|
)
|
|
end
|
|
|
|
if r.nil?
|
|
raise error if !error.nil?
|
|
raise 'no response'
|
|
end
|
|
end
|
|
|
|
content_type = r.headers.fetch('Content-Type', 'application/octet-stream')
|
|
|
|
res = ::PlexRubySDK::Operations::DeleteLibraryResponse.new(
|
|
status_code: r.status, content_type: content_type, raw_response: r
|
|
)
|
|
if r.status == 200
|
|
elsif r.status == 400
|
|
if Utils.match_content_type(content_type, 'application/json')
|
|
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::DeleteLibraryBadRequest)
|
|
res.bad_request = out
|
|
end
|
|
elsif r.status == 401
|
|
if Utils.match_content_type(content_type, 'application/json')
|
|
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::DeleteLibraryUnauthorized)
|
|
res.unauthorized = out
|
|
end
|
|
end
|
|
|
|
res
|
|
end
|
|
|
|
|
|
sig { params(request: T.nilable(::PlexRubySDK::Operations::GetLibraryItemsRequest), timeout_ms: T.nilable(Integer)).returns(::PlexRubySDK::Operations::GetLibraryItemsResponse) }
|
|
def get_library_items(request, timeout_ms = nil)
|
|
# get_library_items - Get Library Items
|
|
# Fetches details from a specific section of the library identified by a section key and a tag. The tag parameter accepts the following values:
|
|
# - `all`: All items in the section.
|
|
# - `unwatched`: Items that have not been played.
|
|
# - `newest`: Items that are recently released.
|
|
# - `recentlyAdded`: Items that are recently added to the library.
|
|
# - `recentlyViewed`: Items that were recently viewed.
|
|
# - `onDeck`: Items to continue watching.
|
|
# - `collection`: Items categorized by collection.
|
|
# - `edition`: Items categorized by edition.
|
|
# - `genre`: Items categorized by genre.
|
|
# - `year`: Items categorized by year of release.
|
|
# - `decade`: Items categorized by decade.
|
|
# - `director`: Items categorized by director.
|
|
# - `actor`: Items categorized by starring actor.
|
|
# - `country`: Items categorized by country of origin.
|
|
# - `contentRating`: Items categorized by content rating.
|
|
# - `rating`: Items categorized by rating.
|
|
# - `resolution`: Items categorized by resolution.
|
|
# - `firstCharacter`: Items categorized by the first letter.
|
|
# - `folder`: Items categorized by folder.
|
|
# - `albums`: Items categorized by album.
|
|
#
|
|
url, params = @sdk_configuration.get_server_details
|
|
base_url = Utils.template_url(url, params)
|
|
url = Utils.generate_url(
|
|
::PlexRubySDK::Operations::GetLibraryItemsRequest,
|
|
base_url,
|
|
'/library/sections/{sectionKey}/{tag}',
|
|
request
|
|
)
|
|
headers = {}
|
|
query_params = Utils.get_query_params(::PlexRubySDK::Operations::GetLibraryItemsRequest, request)
|
|
headers['Accept'] = 'application/json'
|
|
headers['user-agent'] = @sdk_configuration.user_agent
|
|
|
|
security = !@sdk_configuration.nil? && !@sdk_configuration.security_source.nil? ? @sdk_configuration.security_source.call : nil
|
|
|
|
timeout = (timeout_ms.to_f / 1000) unless timeout_ms.nil?
|
|
timeout ||= @sdk_configuration.timeout
|
|
|
|
connection = @sdk_configuration.client
|
|
|
|
hook_ctx = SDKHooks::HookContext.new(
|
|
base_url: base_url,
|
|
oauth2_scopes: [],
|
|
operation_id: 'get-library-items',
|
|
security_source: @sdk_configuration.security_source
|
|
)
|
|
|
|
error = T.let(nil, T.nilable(StandardError))
|
|
r = T.let(nil, T.nilable(Faraday::Response))
|
|
|
|
begin
|
|
r = connection.get(url) do |req|
|
|
req.headers.merge!(headers)
|
|
req.options.timeout = timeout unless timeout.nil?
|
|
req.params = query_params
|
|
Utils.configure_request_security(req, security)
|
|
|
|
@sdk_configuration.hooks.before_request(
|
|
hook_ctx: SDKHooks::BeforeRequestHookContext.new(
|
|
hook_ctx: hook_ctx
|
|
),
|
|
request: req
|
|
)
|
|
end
|
|
rescue StandardError => e
|
|
error = e
|
|
ensure
|
|
if r.nil? || Utils.error_status?(r.status)
|
|
r = @sdk_configuration.hooks.after_error(
|
|
error: error,
|
|
hook_ctx: SDKHooks::AfterErrorHookContext.new(
|
|
hook_ctx: hook_ctx
|
|
),
|
|
response: r
|
|
)
|
|
else
|
|
r = @sdk_configuration.hooks.after_success(
|
|
hook_ctx: SDKHooks::AfterSuccessHookContext.new(
|
|
hook_ctx: hook_ctx
|
|
),
|
|
response: r
|
|
)
|
|
end
|
|
|
|
if r.nil?
|
|
raise error if !error.nil?
|
|
raise 'no response'
|
|
end
|
|
end
|
|
|
|
content_type = r.headers.fetch('Content-Type', 'application/octet-stream')
|
|
|
|
res = ::PlexRubySDK::Operations::GetLibraryItemsResponse.new(
|
|
status_code: r.status, content_type: content_type, raw_response: r
|
|
)
|
|
if r.status == 200
|
|
if Utils.match_content_type(content_type, 'application/json')
|
|
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetLibraryItemsResponseBody)
|
|
res.object = out
|
|
end
|
|
elsif r.status == 400
|
|
if Utils.match_content_type(content_type, 'application/json')
|
|
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetLibraryItemsBadRequest)
|
|
res.bad_request = out
|
|
end
|
|
elsif r.status == 401
|
|
if Utils.match_content_type(content_type, 'application/json')
|
|
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetLibraryItemsUnauthorized)
|
|
res.unauthorized = out
|
|
end
|
|
end
|
|
|
|
res
|
|
end
|
|
|
|
|
|
sig { params(request: T.nilable(::PlexRubySDK::Operations::GetAllMediaLibraryRequest), timeout_ms: T.nilable(Integer)).returns(::PlexRubySDK::Operations::GetAllMediaLibraryResponse) }
|
|
def get_all_media_library(request, timeout_ms = nil)
|
|
# get_all_media_library - Get all media of library
|
|
# Retrieves a list of all general media data for this library.
|
|
#
|
|
url, params = @sdk_configuration.get_server_details
|
|
base_url = Utils.template_url(url, params)
|
|
url = Utils.generate_url(
|
|
::PlexRubySDK::Operations::GetAllMediaLibraryRequest,
|
|
base_url,
|
|
'/library/sections/{sectionKey}/all',
|
|
request
|
|
)
|
|
headers = {}
|
|
query_params = Utils.get_query_params(::PlexRubySDK::Operations::GetAllMediaLibraryRequest, request)
|
|
headers['Accept'] = 'application/json'
|
|
headers['user-agent'] = @sdk_configuration.user_agent
|
|
|
|
security = !@sdk_configuration.nil? && !@sdk_configuration.security_source.nil? ? @sdk_configuration.security_source.call : nil
|
|
|
|
timeout = (timeout_ms.to_f / 1000) unless timeout_ms.nil?
|
|
timeout ||= @sdk_configuration.timeout
|
|
|
|
connection = @sdk_configuration.client
|
|
|
|
hook_ctx = SDKHooks::HookContext.new(
|
|
base_url: base_url,
|
|
oauth2_scopes: [],
|
|
operation_id: 'get-all-media-library',
|
|
security_source: @sdk_configuration.security_source
|
|
)
|
|
|
|
error = T.let(nil, T.nilable(StandardError))
|
|
r = T.let(nil, T.nilable(Faraday::Response))
|
|
|
|
begin
|
|
r = connection.get(url) do |req|
|
|
req.headers.merge!(headers)
|
|
req.options.timeout = timeout unless timeout.nil?
|
|
req.params = query_params
|
|
Utils.configure_request_security(req, security)
|
|
|
|
@sdk_configuration.hooks.before_request(
|
|
hook_ctx: SDKHooks::BeforeRequestHookContext.new(
|
|
hook_ctx: hook_ctx
|
|
),
|
|
request: req
|
|
)
|
|
end
|
|
rescue StandardError => e
|
|
error = e
|
|
ensure
|
|
if r.nil? || Utils.error_status?(r.status)
|
|
r = @sdk_configuration.hooks.after_error(
|
|
error: error,
|
|
hook_ctx: SDKHooks::AfterErrorHookContext.new(
|
|
hook_ctx: hook_ctx
|
|
),
|
|
response: r
|
|
)
|
|
else
|
|
r = @sdk_configuration.hooks.after_success(
|
|
hook_ctx: SDKHooks::AfterSuccessHookContext.new(
|
|
hook_ctx: hook_ctx
|
|
),
|
|
response: r
|
|
)
|
|
end
|
|
|
|
if r.nil?
|
|
raise error if !error.nil?
|
|
raise 'no response'
|
|
end
|
|
end
|
|
|
|
content_type = r.headers.fetch('Content-Type', 'application/octet-stream')
|
|
|
|
res = ::PlexRubySDK::Operations::GetAllMediaLibraryResponse.new(
|
|
status_code: r.status, content_type: content_type, raw_response: r
|
|
)
|
|
if r.status == 200
|
|
if Utils.match_content_type(content_type, 'application/json')
|
|
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetAllMediaLibraryResponseBody)
|
|
res.object = out
|
|
end
|
|
elsif r.status == 400
|
|
if Utils.match_content_type(content_type, 'application/json')
|
|
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetAllMediaLibraryBadRequest)
|
|
res.bad_request = out
|
|
end
|
|
elsif r.status == 401
|
|
if Utils.match_content_type(content_type, 'application/json')
|
|
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetAllMediaLibraryUnauthorized)
|
|
res.unauthorized = out
|
|
end
|
|
elsif r.status == 404
|
|
end
|
|
|
|
res
|
|
end
|
|
|
|
|
|
sig { params(section_key: ::Integer, force: T.nilable(::PlexRubySDK::Operations::Force), timeout_ms: T.nilable(Integer)).returns(::PlexRubySDK::Operations::GetRefreshLibraryMetadataResponse) }
|
|
def get_refresh_library_metadata(section_key, force = nil, timeout_ms = nil)
|
|
# get_refresh_library_metadata - Refresh Metadata Of The Library
|
|
# This endpoint Refreshes all the Metadata of the library.
|
|
#
|
|
request = ::PlexRubySDK::Operations::GetRefreshLibraryMetadataRequest.new(
|
|
|
|
section_key: section_key,
|
|
force: force
|
|
)
|
|
url, params = @sdk_configuration.get_server_details
|
|
base_url = Utils.template_url(url, params)
|
|
url = Utils.generate_url(
|
|
::PlexRubySDK::Operations::GetRefreshLibraryMetadataRequest,
|
|
base_url,
|
|
'/library/sections/{sectionKey}/refresh',
|
|
request
|
|
)
|
|
headers = {}
|
|
query_params = Utils.get_query_params(::PlexRubySDK::Operations::GetRefreshLibraryMetadataRequest, request)
|
|
headers['Accept'] = 'application/json'
|
|
headers['user-agent'] = @sdk_configuration.user_agent
|
|
|
|
security = !@sdk_configuration.nil? && !@sdk_configuration.security_source.nil? ? @sdk_configuration.security_source.call : nil
|
|
|
|
timeout = (timeout_ms.to_f / 1000) unless timeout_ms.nil?
|
|
timeout ||= @sdk_configuration.timeout
|
|
|
|
connection = @sdk_configuration.client
|
|
|
|
hook_ctx = SDKHooks::HookContext.new(
|
|
base_url: base_url,
|
|
oauth2_scopes: [],
|
|
operation_id: 'get-refresh-library-metadata',
|
|
security_source: @sdk_configuration.security_source
|
|
)
|
|
|
|
error = T.let(nil, T.nilable(StandardError))
|
|
r = T.let(nil, T.nilable(Faraday::Response))
|
|
|
|
begin
|
|
r = connection.get(url) do |req|
|
|
req.headers.merge!(headers)
|
|
req.options.timeout = timeout unless timeout.nil?
|
|
req.params = query_params
|
|
Utils.configure_request_security(req, security)
|
|
|
|
@sdk_configuration.hooks.before_request(
|
|
hook_ctx: SDKHooks::BeforeRequestHookContext.new(
|
|
hook_ctx: hook_ctx
|
|
),
|
|
request: req
|
|
)
|
|
end
|
|
rescue StandardError => e
|
|
error = e
|
|
ensure
|
|
if r.nil? || Utils.error_status?(r.status)
|
|
r = @sdk_configuration.hooks.after_error(
|
|
error: error,
|
|
hook_ctx: SDKHooks::AfterErrorHookContext.new(
|
|
hook_ctx: hook_ctx
|
|
),
|
|
response: r
|
|
)
|
|
else
|
|
r = @sdk_configuration.hooks.after_success(
|
|
hook_ctx: SDKHooks::AfterSuccessHookContext.new(
|
|
hook_ctx: hook_ctx
|
|
),
|
|
response: r
|
|
)
|
|
end
|
|
|
|
if r.nil?
|
|
raise error if !error.nil?
|
|
raise 'no response'
|
|
end
|
|
end
|
|
|
|
content_type = r.headers.fetch('Content-Type', 'application/octet-stream')
|
|
|
|
res = ::PlexRubySDK::Operations::GetRefreshLibraryMetadataResponse.new(
|
|
status_code: r.status, content_type: content_type, raw_response: r
|
|
)
|
|
if r.status == 200
|
|
elsif r.status == 400
|
|
if Utils.match_content_type(content_type, 'application/json')
|
|
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetRefreshLibraryMetadataBadRequest)
|
|
res.bad_request = out
|
|
end
|
|
elsif r.status == 401
|
|
if Utils.match_content_type(content_type, 'application/json')
|
|
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetRefreshLibraryMetadataUnauthorized)
|
|
res.unauthorized = out
|
|
end
|
|
end
|
|
|
|
res
|
|
end
|
|
|
|
|
|
sig { params(section_key: ::Integer, type: ::PlexRubySDK::Operations::GetSearchLibraryQueryParamType, timeout_ms: T.nilable(Integer)).returns(::PlexRubySDK::Operations::GetSearchLibraryResponse) }
|
|
def get_search_library(section_key, type, timeout_ms = nil)
|
|
# get_search_library - Search Library
|
|
# Search for content within a specific section of the library.
|
|
#
|
|
# ### Types
|
|
# Each type in the library comes with a set of filters and sorts, aiding in building dynamic media controls:
|
|
#
|
|
# - **Type Object Attributes**:
|
|
# - `type`: Metadata type (if standard Plex type).
|
|
# - `title`: Title for this content type (e.g., "Movies").
|
|
#
|
|
# - **Filter Objects**:
|
|
# - Subset of the media query language.
|
|
# - Attributes include `filter` (name), `filterType` (data type), `key` (endpoint for value range), and `title`.
|
|
#
|
|
# - **Sort Objects**:
|
|
# - Description of sort fields.
|
|
# - Attributes include `defaultDirection` (asc/desc), `descKey` and `key` (sort parameters), and `title`.
|
|
#
|
|
# > **Note**: Filters and sorts are optional; without them, no filtering controls are rendered.
|
|
#
|
|
request = ::PlexRubySDK::Operations::GetSearchLibraryRequest.new(
|
|
|
|
section_key: section_key,
|
|
type: type
|
|
)
|
|
url, params = @sdk_configuration.get_server_details
|
|
base_url = Utils.template_url(url, params)
|
|
url = Utils.generate_url(
|
|
::PlexRubySDK::Operations::GetSearchLibraryRequest,
|
|
base_url,
|
|
'/library/sections/{sectionKey}/search',
|
|
request
|
|
)
|
|
headers = {}
|
|
query_params = Utils.get_query_params(::PlexRubySDK::Operations::GetSearchLibraryRequest, request)
|
|
headers['Accept'] = 'application/json'
|
|
headers['user-agent'] = @sdk_configuration.user_agent
|
|
|
|
security = !@sdk_configuration.nil? && !@sdk_configuration.security_source.nil? ? @sdk_configuration.security_source.call : nil
|
|
|
|
timeout = (timeout_ms.to_f / 1000) unless timeout_ms.nil?
|
|
timeout ||= @sdk_configuration.timeout
|
|
|
|
connection = @sdk_configuration.client
|
|
|
|
hook_ctx = SDKHooks::HookContext.new(
|
|
base_url: base_url,
|
|
oauth2_scopes: [],
|
|
operation_id: 'get-search-library',
|
|
security_source: @sdk_configuration.security_source
|
|
)
|
|
|
|
error = T.let(nil, T.nilable(StandardError))
|
|
r = T.let(nil, T.nilable(Faraday::Response))
|
|
|
|
begin
|
|
r = connection.get(url) do |req|
|
|
req.headers.merge!(headers)
|
|
req.options.timeout = timeout unless timeout.nil?
|
|
req.params = query_params
|
|
Utils.configure_request_security(req, security)
|
|
|
|
@sdk_configuration.hooks.before_request(
|
|
hook_ctx: SDKHooks::BeforeRequestHookContext.new(
|
|
hook_ctx: hook_ctx
|
|
),
|
|
request: req
|
|
)
|
|
end
|
|
rescue StandardError => e
|
|
error = e
|
|
ensure
|
|
if r.nil? || Utils.error_status?(r.status)
|
|
r = @sdk_configuration.hooks.after_error(
|
|
error: error,
|
|
hook_ctx: SDKHooks::AfterErrorHookContext.new(
|
|
hook_ctx: hook_ctx
|
|
),
|
|
response: r
|
|
)
|
|
else
|
|
r = @sdk_configuration.hooks.after_success(
|
|
hook_ctx: SDKHooks::AfterSuccessHookContext.new(
|
|
hook_ctx: hook_ctx
|
|
),
|
|
response: r
|
|
)
|
|
end
|
|
|
|
if r.nil?
|
|
raise error if !error.nil?
|
|
raise 'no response'
|
|
end
|
|
end
|
|
|
|
content_type = r.headers.fetch('Content-Type', 'application/octet-stream')
|
|
|
|
res = ::PlexRubySDK::Operations::GetSearchLibraryResponse.new(
|
|
status_code: r.status, content_type: content_type, raw_response: r
|
|
)
|
|
if r.status == 200
|
|
if Utils.match_content_type(content_type, 'application/json')
|
|
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetSearchLibraryResponseBody)
|
|
res.object = out
|
|
end
|
|
elsif r.status == 400
|
|
if Utils.match_content_type(content_type, 'application/json')
|
|
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetSearchLibraryBadRequest)
|
|
res.bad_request = out
|
|
end
|
|
elsif r.status == 401
|
|
if Utils.match_content_type(content_type, 'application/json')
|
|
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetSearchLibraryUnauthorized)
|
|
res.unauthorized = out
|
|
end
|
|
end
|
|
|
|
res
|
|
end
|
|
|
|
|
|
sig { params(section_key: ::Integer, type: ::PlexRubySDK::Operations::GetGenresLibraryQueryParamType, timeout_ms: T.nilable(Integer)).returns(::PlexRubySDK::Operations::GetGenresLibraryResponse) }
|
|
def get_genres_library(section_key, type, timeout_ms = nil)
|
|
# get_genres_library - Get Genres of library media
|
|
# Retrieves a list of all the genres that are found for the media in this library.
|
|
#
|
|
request = ::PlexRubySDK::Operations::GetGenresLibraryRequest.new(
|
|
|
|
section_key: section_key,
|
|
type: type
|
|
)
|
|
url, params = @sdk_configuration.get_server_details
|
|
base_url = Utils.template_url(url, params)
|
|
url = Utils.generate_url(
|
|
::PlexRubySDK::Operations::GetGenresLibraryRequest,
|
|
base_url,
|
|
'/library/sections/{sectionKey}/genre',
|
|
request
|
|
)
|
|
headers = {}
|
|
query_params = Utils.get_query_params(::PlexRubySDK::Operations::GetGenresLibraryRequest, request)
|
|
headers['Accept'] = 'application/json'
|
|
headers['user-agent'] = @sdk_configuration.user_agent
|
|
|
|
security = !@sdk_configuration.nil? && !@sdk_configuration.security_source.nil? ? @sdk_configuration.security_source.call : nil
|
|
|
|
timeout = (timeout_ms.to_f / 1000) unless timeout_ms.nil?
|
|
timeout ||= @sdk_configuration.timeout
|
|
|
|
connection = @sdk_configuration.client
|
|
|
|
hook_ctx = SDKHooks::HookContext.new(
|
|
base_url: base_url,
|
|
oauth2_scopes: [],
|
|
operation_id: 'get-genres-library',
|
|
security_source: @sdk_configuration.security_source
|
|
)
|
|
|
|
error = T.let(nil, T.nilable(StandardError))
|
|
r = T.let(nil, T.nilable(Faraday::Response))
|
|
|
|
begin
|
|
r = connection.get(url) do |req|
|
|
req.headers.merge!(headers)
|
|
req.options.timeout = timeout unless timeout.nil?
|
|
req.params = query_params
|
|
Utils.configure_request_security(req, security)
|
|
|
|
@sdk_configuration.hooks.before_request(
|
|
hook_ctx: SDKHooks::BeforeRequestHookContext.new(
|
|
hook_ctx: hook_ctx
|
|
),
|
|
request: req
|
|
)
|
|
end
|
|
rescue StandardError => e
|
|
error = e
|
|
ensure
|
|
if r.nil? || Utils.error_status?(r.status)
|
|
r = @sdk_configuration.hooks.after_error(
|
|
error: error,
|
|
hook_ctx: SDKHooks::AfterErrorHookContext.new(
|
|
hook_ctx: hook_ctx
|
|
),
|
|
response: r
|
|
)
|
|
else
|
|
r = @sdk_configuration.hooks.after_success(
|
|
hook_ctx: SDKHooks::AfterSuccessHookContext.new(
|
|
hook_ctx: hook_ctx
|
|
),
|
|
response: r
|
|
)
|
|
end
|
|
|
|
if r.nil?
|
|
raise error if !error.nil?
|
|
raise 'no response'
|
|
end
|
|
end
|
|
|
|
content_type = r.headers.fetch('Content-Type', 'application/octet-stream')
|
|
|
|
res = ::PlexRubySDK::Operations::GetGenresLibraryResponse.new(
|
|
status_code: r.status, content_type: content_type, raw_response: r
|
|
)
|
|
if r.status == 200
|
|
if Utils.match_content_type(content_type, 'application/json')
|
|
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetGenresLibraryResponseBody)
|
|
res.object = out
|
|
end
|
|
elsif r.status == 400
|
|
if Utils.match_content_type(content_type, 'application/json')
|
|
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetGenresLibraryBadRequest)
|
|
res.bad_request = out
|
|
end
|
|
elsif r.status == 401
|
|
if Utils.match_content_type(content_type, 'application/json')
|
|
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetGenresLibraryUnauthorized)
|
|
res.unauthorized = out
|
|
end
|
|
elsif r.status == 404
|
|
end
|
|
|
|
res
|
|
end
|
|
|
|
|
|
sig { params(section_key: ::Integer, type: ::PlexRubySDK::Operations::GetCountriesLibraryQueryParamType, timeout_ms: T.nilable(Integer)).returns(::PlexRubySDK::Operations::GetCountriesLibraryResponse) }
|
|
def get_countries_library(section_key, type, timeout_ms = nil)
|
|
# get_countries_library - Get Countries of library media
|
|
# Retrieves a list of all the countries that are found for the media in this library.
|
|
#
|
|
request = ::PlexRubySDK::Operations::GetCountriesLibraryRequest.new(
|
|
|
|
section_key: section_key,
|
|
type: type
|
|
)
|
|
url, params = @sdk_configuration.get_server_details
|
|
base_url = Utils.template_url(url, params)
|
|
url = Utils.generate_url(
|
|
::PlexRubySDK::Operations::GetCountriesLibraryRequest,
|
|
base_url,
|
|
'/library/sections/{sectionKey}/country',
|
|
request
|
|
)
|
|
headers = {}
|
|
query_params = Utils.get_query_params(::PlexRubySDK::Operations::GetCountriesLibraryRequest, request)
|
|
headers['Accept'] = 'application/json'
|
|
headers['user-agent'] = @sdk_configuration.user_agent
|
|
|
|
security = !@sdk_configuration.nil? && !@sdk_configuration.security_source.nil? ? @sdk_configuration.security_source.call : nil
|
|
|
|
timeout = (timeout_ms.to_f / 1000) unless timeout_ms.nil?
|
|
timeout ||= @sdk_configuration.timeout
|
|
|
|
connection = @sdk_configuration.client
|
|
|
|
hook_ctx = SDKHooks::HookContext.new(
|
|
base_url: base_url,
|
|
oauth2_scopes: [],
|
|
operation_id: 'get-countries-library',
|
|
security_source: @sdk_configuration.security_source
|
|
)
|
|
|
|
error = T.let(nil, T.nilable(StandardError))
|
|
r = T.let(nil, T.nilable(Faraday::Response))
|
|
|
|
begin
|
|
r = connection.get(url) do |req|
|
|
req.headers.merge!(headers)
|
|
req.options.timeout = timeout unless timeout.nil?
|
|
req.params = query_params
|
|
Utils.configure_request_security(req, security)
|
|
|
|
@sdk_configuration.hooks.before_request(
|
|
hook_ctx: SDKHooks::BeforeRequestHookContext.new(
|
|
hook_ctx: hook_ctx
|
|
),
|
|
request: req
|
|
)
|
|
end
|
|
rescue StandardError => e
|
|
error = e
|
|
ensure
|
|
if r.nil? || Utils.error_status?(r.status)
|
|
r = @sdk_configuration.hooks.after_error(
|
|
error: error,
|
|
hook_ctx: SDKHooks::AfterErrorHookContext.new(
|
|
hook_ctx: hook_ctx
|
|
),
|
|
response: r
|
|
)
|
|
else
|
|
r = @sdk_configuration.hooks.after_success(
|
|
hook_ctx: SDKHooks::AfterSuccessHookContext.new(
|
|
hook_ctx: hook_ctx
|
|
),
|
|
response: r
|
|
)
|
|
end
|
|
|
|
if r.nil?
|
|
raise error if !error.nil?
|
|
raise 'no response'
|
|
end
|
|
end
|
|
|
|
content_type = r.headers.fetch('Content-Type', 'application/octet-stream')
|
|
|
|
res = ::PlexRubySDK::Operations::GetCountriesLibraryResponse.new(
|
|
status_code: r.status, content_type: content_type, raw_response: r
|
|
)
|
|
if r.status == 200
|
|
if Utils.match_content_type(content_type, 'application/json')
|
|
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetCountriesLibraryResponseBody)
|
|
res.object = out
|
|
end
|
|
elsif r.status == 400
|
|
if Utils.match_content_type(content_type, 'application/json')
|
|
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetCountriesLibraryBadRequest)
|
|
res.bad_request = out
|
|
end
|
|
elsif r.status == 401
|
|
if Utils.match_content_type(content_type, 'application/json')
|
|
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetCountriesLibraryUnauthorized)
|
|
res.unauthorized = out
|
|
end
|
|
elsif r.status == 404
|
|
end
|
|
|
|
res
|
|
end
|
|
|
|
|
|
sig { params(section_key: ::Integer, type: ::PlexRubySDK::Operations::GetActorsLibraryQueryParamType, timeout_ms: T.nilable(Integer)).returns(::PlexRubySDK::Operations::GetActorsLibraryResponse) }
|
|
def get_actors_library(section_key, type, timeout_ms = nil)
|
|
# get_actors_library - Get Actors of library media
|
|
# Retrieves a list of all the actors that are found for the media in this library.
|
|
#
|
|
request = ::PlexRubySDK::Operations::GetActorsLibraryRequest.new(
|
|
|
|
section_key: section_key,
|
|
type: type
|
|
)
|
|
url, params = @sdk_configuration.get_server_details
|
|
base_url = Utils.template_url(url, params)
|
|
url = Utils.generate_url(
|
|
::PlexRubySDK::Operations::GetActorsLibraryRequest,
|
|
base_url,
|
|
'/library/sections/{sectionKey}/actor',
|
|
request
|
|
)
|
|
headers = {}
|
|
query_params = Utils.get_query_params(::PlexRubySDK::Operations::GetActorsLibraryRequest, request)
|
|
headers['Accept'] = 'application/json'
|
|
headers['user-agent'] = @sdk_configuration.user_agent
|
|
|
|
security = !@sdk_configuration.nil? && !@sdk_configuration.security_source.nil? ? @sdk_configuration.security_source.call : nil
|
|
|
|
timeout = (timeout_ms.to_f / 1000) unless timeout_ms.nil?
|
|
timeout ||= @sdk_configuration.timeout
|
|
|
|
connection = @sdk_configuration.client
|
|
|
|
hook_ctx = SDKHooks::HookContext.new(
|
|
base_url: base_url,
|
|
oauth2_scopes: [],
|
|
operation_id: 'get-actors-library',
|
|
security_source: @sdk_configuration.security_source
|
|
)
|
|
|
|
error = T.let(nil, T.nilable(StandardError))
|
|
r = T.let(nil, T.nilable(Faraday::Response))
|
|
|
|
begin
|
|
r = connection.get(url) do |req|
|
|
req.headers.merge!(headers)
|
|
req.options.timeout = timeout unless timeout.nil?
|
|
req.params = query_params
|
|
Utils.configure_request_security(req, security)
|
|
|
|
@sdk_configuration.hooks.before_request(
|
|
hook_ctx: SDKHooks::BeforeRequestHookContext.new(
|
|
hook_ctx: hook_ctx
|
|
),
|
|
request: req
|
|
)
|
|
end
|
|
rescue StandardError => e
|
|
error = e
|
|
ensure
|
|
if r.nil? || Utils.error_status?(r.status)
|
|
r = @sdk_configuration.hooks.after_error(
|
|
error: error,
|
|
hook_ctx: SDKHooks::AfterErrorHookContext.new(
|
|
hook_ctx: hook_ctx
|
|
),
|
|
response: r
|
|
)
|
|
else
|
|
r = @sdk_configuration.hooks.after_success(
|
|
hook_ctx: SDKHooks::AfterSuccessHookContext.new(
|
|
hook_ctx: hook_ctx
|
|
),
|
|
response: r
|
|
)
|
|
end
|
|
|
|
if r.nil?
|
|
raise error if !error.nil?
|
|
raise 'no response'
|
|
end
|
|
end
|
|
|
|
content_type = r.headers.fetch('Content-Type', 'application/octet-stream')
|
|
|
|
res = ::PlexRubySDK::Operations::GetActorsLibraryResponse.new(
|
|
status_code: r.status, content_type: content_type, raw_response: r
|
|
)
|
|
if r.status == 200
|
|
if Utils.match_content_type(content_type, 'application/json')
|
|
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetActorsLibraryResponseBody)
|
|
res.object = out
|
|
end
|
|
elsif r.status == 400
|
|
if Utils.match_content_type(content_type, 'application/json')
|
|
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetActorsLibraryBadRequest)
|
|
res.bad_request = out
|
|
end
|
|
elsif r.status == 401
|
|
if Utils.match_content_type(content_type, 'application/json')
|
|
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetActorsLibraryUnauthorized)
|
|
res.unauthorized = out
|
|
end
|
|
elsif r.status == 404
|
|
end
|
|
|
|
res
|
|
end
|
|
|
|
|
|
sig { params(request: T.nilable(::PlexRubySDK::Operations::GetSearchAllLibrariesRequest), timeout_ms: T.nilable(Integer)).returns(::PlexRubySDK::Operations::GetSearchAllLibrariesResponse) }
|
|
def get_search_all_libraries(request, timeout_ms = nil)
|
|
# get_search_all_libraries - Search All Libraries
|
|
# Search the provided query across all library sections, or a single section, and return matches as hubs, split up by type.
|
|
#
|
|
url, params = @sdk_configuration.get_server_details
|
|
base_url = Utils.template_url(url, params)
|
|
url = "#{base_url}/library/search"
|
|
headers = Utils.get_headers(request)
|
|
query_params = Utils.get_query_params(::PlexRubySDK::Operations::GetSearchAllLibrariesRequest, request)
|
|
headers['Accept'] = 'application/json'
|
|
headers['user-agent'] = @sdk_configuration.user_agent
|
|
|
|
security = !@sdk_configuration.nil? && !@sdk_configuration.security_source.nil? ? @sdk_configuration.security_source.call : nil
|
|
|
|
timeout = (timeout_ms.to_f / 1000) unless timeout_ms.nil?
|
|
timeout ||= @sdk_configuration.timeout
|
|
|
|
connection = @sdk_configuration.client
|
|
|
|
hook_ctx = SDKHooks::HookContext.new(
|
|
base_url: base_url,
|
|
oauth2_scopes: [],
|
|
operation_id: 'get-search-all-libraries',
|
|
security_source: @sdk_configuration.security_source
|
|
)
|
|
|
|
error = T.let(nil, T.nilable(StandardError))
|
|
r = T.let(nil, T.nilable(Faraday::Response))
|
|
|
|
begin
|
|
r = connection.get(url) do |req|
|
|
req.headers.merge!(headers)
|
|
req.options.timeout = timeout unless timeout.nil?
|
|
req.params = query_params
|
|
Utils.configure_request_security(req, security)
|
|
|
|
@sdk_configuration.hooks.before_request(
|
|
hook_ctx: SDKHooks::BeforeRequestHookContext.new(
|
|
hook_ctx: hook_ctx
|
|
),
|
|
request: req
|
|
)
|
|
end
|
|
rescue StandardError => e
|
|
error = e
|
|
ensure
|
|
if r.nil? || Utils.error_status?(r.status)
|
|
r = @sdk_configuration.hooks.after_error(
|
|
error: error,
|
|
hook_ctx: SDKHooks::AfterErrorHookContext.new(
|
|
hook_ctx: hook_ctx
|
|
),
|
|
response: r
|
|
)
|
|
else
|
|
r = @sdk_configuration.hooks.after_success(
|
|
hook_ctx: SDKHooks::AfterSuccessHookContext.new(
|
|
hook_ctx: hook_ctx
|
|
),
|
|
response: r
|
|
)
|
|
end
|
|
|
|
if r.nil?
|
|
raise error if !error.nil?
|
|
raise 'no response'
|
|
end
|
|
end
|
|
|
|
content_type = r.headers.fetch('Content-Type', 'application/octet-stream')
|
|
|
|
res = ::PlexRubySDK::Operations::GetSearchAllLibrariesResponse.new(
|
|
status_code: r.status, content_type: content_type, raw_response: r
|
|
)
|
|
if r.status == 200
|
|
if Utils.match_content_type(content_type, 'application/json')
|
|
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetSearchAllLibrariesResponseBody)
|
|
res.object = out
|
|
end
|
|
elsif r.status == 400
|
|
if Utils.match_content_type(content_type, 'application/json')
|
|
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetSearchAllLibrariesBadRequest)
|
|
res.bad_request = out
|
|
end
|
|
elsif r.status == 401
|
|
if Utils.match_content_type(content_type, 'application/json')
|
|
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetSearchAllLibrariesUnauthorized)
|
|
res.unauthorized = out
|
|
end
|
|
end
|
|
|
|
res
|
|
end
|
|
|
|
|
|
sig { params(request: T.nilable(::PlexRubySDK::Operations::GetMediaMetaDataRequest), timeout_ms: T.nilable(Integer)).returns(::PlexRubySDK::Operations::GetMediaMetaDataResponse) }
|
|
def get_media_meta_data(request, timeout_ms = nil)
|
|
# get_media_meta_data - Get Media Metadata
|
|
# This endpoint will return all the (meta)data of a library item specified with by the ratingKey.
|
|
#
|
|
url, params = @sdk_configuration.get_server_details
|
|
base_url = Utils.template_url(url, params)
|
|
url = Utils.generate_url(
|
|
::PlexRubySDK::Operations::GetMediaMetaDataRequest,
|
|
base_url,
|
|
'/library/metadata/{ratingKey}',
|
|
request
|
|
)
|
|
headers = {}
|
|
query_params = Utils.get_query_params(::PlexRubySDK::Operations::GetMediaMetaDataRequest, request)
|
|
headers['Accept'] = 'application/json'
|
|
headers['user-agent'] = @sdk_configuration.user_agent
|
|
|
|
security = !@sdk_configuration.nil? && !@sdk_configuration.security_source.nil? ? @sdk_configuration.security_source.call : nil
|
|
|
|
timeout = (timeout_ms.to_f / 1000) unless timeout_ms.nil?
|
|
timeout ||= @sdk_configuration.timeout
|
|
|
|
connection = @sdk_configuration.client
|
|
|
|
hook_ctx = SDKHooks::HookContext.new(
|
|
base_url: base_url,
|
|
oauth2_scopes: [],
|
|
operation_id: 'get-media-meta-data',
|
|
security_source: @sdk_configuration.security_source
|
|
)
|
|
|
|
error = T.let(nil, T.nilable(StandardError))
|
|
r = T.let(nil, T.nilable(Faraday::Response))
|
|
|
|
begin
|
|
r = connection.get(url) do |req|
|
|
req.headers.merge!(headers)
|
|
req.options.timeout = timeout unless timeout.nil?
|
|
req.params = query_params
|
|
Utils.configure_request_security(req, security)
|
|
|
|
@sdk_configuration.hooks.before_request(
|
|
hook_ctx: SDKHooks::BeforeRequestHookContext.new(
|
|
hook_ctx: hook_ctx
|
|
),
|
|
request: req
|
|
)
|
|
end
|
|
rescue StandardError => e
|
|
error = e
|
|
ensure
|
|
if r.nil? || Utils.error_status?(r.status)
|
|
r = @sdk_configuration.hooks.after_error(
|
|
error: error,
|
|
hook_ctx: SDKHooks::AfterErrorHookContext.new(
|
|
hook_ctx: hook_ctx
|
|
),
|
|
response: r
|
|
)
|
|
else
|
|
r = @sdk_configuration.hooks.after_success(
|
|
hook_ctx: SDKHooks::AfterSuccessHookContext.new(
|
|
hook_ctx: hook_ctx
|
|
),
|
|
response: r
|
|
)
|
|
end
|
|
|
|
if r.nil?
|
|
raise error if !error.nil?
|
|
raise 'no response'
|
|
end
|
|
end
|
|
|
|
content_type = r.headers.fetch('Content-Type', 'application/octet-stream')
|
|
|
|
res = ::PlexRubySDK::Operations::GetMediaMetaDataResponse.new(
|
|
status_code: r.status, content_type: content_type, raw_response: r
|
|
)
|
|
if r.status == 200
|
|
if Utils.match_content_type(content_type, 'application/json')
|
|
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetMediaMetaDataResponseBody)
|
|
res.object = out
|
|
end
|
|
elsif r.status == 400
|
|
if Utils.match_content_type(content_type, 'application/json')
|
|
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetMediaMetaDataBadRequest)
|
|
res.bad_request = out
|
|
end
|
|
elsif r.status == 401
|
|
if Utils.match_content_type(content_type, 'application/json')
|
|
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetMediaMetaDataUnauthorized)
|
|
res.unauthorized = out
|
|
end
|
|
elsif r.status == 404
|
|
end
|
|
|
|
res
|
|
end
|
|
|
|
|
|
sig { params(rating_key: ::Integer, timeout_ms: T.nilable(Integer)).returns(::PlexRubySDK::Operations::GetMediaArtsResponse) }
|
|
def get_media_arts(rating_key, timeout_ms = nil)
|
|
# get_media_arts - Get Media Background Artwork
|
|
# Returns the background artwork for a library item.
|
|
request = ::PlexRubySDK::Operations::GetMediaArtsRequest.new(
|
|
|
|
rating_key: rating_key
|
|
)
|
|
url, params = @sdk_configuration.get_server_details
|
|
base_url = Utils.template_url(url, params)
|
|
url = Utils.generate_url(
|
|
::PlexRubySDK::Operations::GetMediaArtsRequest,
|
|
base_url,
|
|
'/library/metadata/{ratingKey}/arts',
|
|
request
|
|
)
|
|
headers = {}
|
|
headers['Accept'] = 'application/json'
|
|
headers['user-agent'] = @sdk_configuration.user_agent
|
|
|
|
security = !@sdk_configuration.nil? && !@sdk_configuration.security_source.nil? ? @sdk_configuration.security_source.call : nil
|
|
|
|
timeout = (timeout_ms.to_f / 1000) unless timeout_ms.nil?
|
|
timeout ||= @sdk_configuration.timeout
|
|
|
|
connection = @sdk_configuration.client
|
|
|
|
hook_ctx = SDKHooks::HookContext.new(
|
|
base_url: base_url,
|
|
oauth2_scopes: [],
|
|
operation_id: 'get-media-arts',
|
|
security_source: @sdk_configuration.security_source
|
|
)
|
|
|
|
error = T.let(nil, T.nilable(StandardError))
|
|
r = T.let(nil, T.nilable(Faraday::Response))
|
|
|
|
begin
|
|
r = connection.get(url) do |req|
|
|
req.headers.merge!(headers)
|
|
req.options.timeout = timeout unless timeout.nil?
|
|
Utils.configure_request_security(req, security)
|
|
|
|
@sdk_configuration.hooks.before_request(
|
|
hook_ctx: SDKHooks::BeforeRequestHookContext.new(
|
|
hook_ctx: hook_ctx
|
|
),
|
|
request: req
|
|
)
|
|
end
|
|
rescue StandardError => e
|
|
error = e
|
|
ensure
|
|
if r.nil? || Utils.error_status?(r.status)
|
|
r = @sdk_configuration.hooks.after_error(
|
|
error: error,
|
|
hook_ctx: SDKHooks::AfterErrorHookContext.new(
|
|
hook_ctx: hook_ctx
|
|
),
|
|
response: r
|
|
)
|
|
else
|
|
r = @sdk_configuration.hooks.after_success(
|
|
hook_ctx: SDKHooks::AfterSuccessHookContext.new(
|
|
hook_ctx: hook_ctx
|
|
),
|
|
response: r
|
|
)
|
|
end
|
|
|
|
if r.nil?
|
|
raise error if !error.nil?
|
|
raise 'no response'
|
|
end
|
|
end
|
|
|
|
content_type = r.headers.fetch('Content-Type', 'application/octet-stream')
|
|
|
|
res = ::PlexRubySDK::Operations::GetMediaArtsResponse.new(
|
|
status_code: r.status, content_type: content_type, raw_response: r
|
|
)
|
|
if r.status == 200
|
|
if Utils.match_content_type(content_type, 'application/json')
|
|
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetMediaArtsResponseBody)
|
|
res.object = out
|
|
end
|
|
elsif r.status == 404
|
|
end
|
|
|
|
res
|
|
end
|
|
|
|
|
|
sig { params(rating_key: ::Integer, url: T.nilable(::String), request_body: T.nilable(::String), timeout_ms: T.nilable(Integer)).returns(::PlexRubySDK::Operations::PostMediaArtsResponse) }
|
|
def post_media_arts(rating_key, url = nil, request_body = nil, timeout_ms = nil)
|
|
# post_media_arts - Upload Media Background Artwork
|
|
# Uploads an image to use as the background artwork for a library item, either from a local file or a remote URL
|
|
request = ::PlexRubySDK::Operations::PostMediaArtsRequest.new(
|
|
|
|
rating_key: rating_key,
|
|
url: url,
|
|
request_body: request_body
|
|
)
|
|
url, params = @sdk_configuration.get_server_details
|
|
base_url = Utils.template_url(url, params)
|
|
url = Utils.generate_url(
|
|
::PlexRubySDK::Operations::PostMediaArtsRequest,
|
|
base_url,
|
|
'/library/metadata/{ratingKey}/arts',
|
|
request
|
|
)
|
|
headers = {}
|
|
req_content_type, data, form = Utils.serialize_request_body(request, :request_body, :raw)
|
|
headers['content-type'] = req_content_type
|
|
|
|
if form
|
|
body = Utils.encode_form(form)
|
|
elsif Utils.match_content_type(req_content_type, 'application/x-www-form-urlencoded')
|
|
body = URI.encode_www_form(data)
|
|
else
|
|
body = data
|
|
end
|
|
query_params = Utils.get_query_params(::PlexRubySDK::Operations::PostMediaArtsRequest, request)
|
|
headers['Accept'] = '*/*'
|
|
headers['user-agent'] = @sdk_configuration.user_agent
|
|
|
|
security = !@sdk_configuration.nil? && !@sdk_configuration.security_source.nil? ? @sdk_configuration.security_source.call : nil
|
|
|
|
timeout = (timeout_ms.to_f / 1000) unless timeout_ms.nil?
|
|
timeout ||= @sdk_configuration.timeout
|
|
|
|
connection = @sdk_configuration.client
|
|
|
|
hook_ctx = SDKHooks::HookContext.new(
|
|
base_url: base_url,
|
|
oauth2_scopes: [],
|
|
operation_id: 'post-media-arts',
|
|
security_source: @sdk_configuration.security_source
|
|
)
|
|
|
|
error = T.let(nil, T.nilable(StandardError))
|
|
r = T.let(nil, T.nilable(Faraday::Response))
|
|
|
|
begin
|
|
r = connection.post(url) do |req|
|
|
req.body = body
|
|
req.headers.merge!(headers)
|
|
req.options.timeout = timeout unless timeout.nil?
|
|
req.params = query_params
|
|
Utils.configure_request_security(req, security)
|
|
|
|
@sdk_configuration.hooks.before_request(
|
|
hook_ctx: SDKHooks::BeforeRequestHookContext.new(
|
|
hook_ctx: hook_ctx
|
|
),
|
|
request: req
|
|
)
|
|
end
|
|
rescue StandardError => e
|
|
error = e
|
|
ensure
|
|
if r.nil? || Utils.error_status?(r.status)
|
|
r = @sdk_configuration.hooks.after_error(
|
|
error: error,
|
|
hook_ctx: SDKHooks::AfterErrorHookContext.new(
|
|
hook_ctx: hook_ctx
|
|
),
|
|
response: r
|
|
)
|
|
else
|
|
r = @sdk_configuration.hooks.after_success(
|
|
hook_ctx: SDKHooks::AfterSuccessHookContext.new(
|
|
hook_ctx: hook_ctx
|
|
),
|
|
response: r
|
|
)
|
|
end
|
|
|
|
if r.nil?
|
|
raise error if !error.nil?
|
|
raise 'no response'
|
|
end
|
|
end
|
|
|
|
content_type = r.headers.fetch('Content-Type', 'application/octet-stream')
|
|
|
|
res = ::PlexRubySDK::Operations::PostMediaArtsResponse.new(
|
|
status_code: r.status, content_type: content_type, raw_response: r
|
|
)
|
|
if r.status == 200
|
|
elsif r.status == 404
|
|
end
|
|
|
|
res
|
|
end
|
|
|
|
|
|
sig { params(rating_key: ::Integer, timeout_ms: T.nilable(Integer)).returns(::PlexRubySDK::Operations::GetMediaPostersResponse) }
|
|
def get_media_posters(rating_key, timeout_ms = nil)
|
|
# get_media_posters - Get Media Posters
|
|
# Returns the available posters for a library item.
|
|
request = ::PlexRubySDK::Operations::GetMediaPostersRequest.new(
|
|
|
|
rating_key: rating_key
|
|
)
|
|
url, params = @sdk_configuration.get_server_details
|
|
base_url = Utils.template_url(url, params)
|
|
url = Utils.generate_url(
|
|
::PlexRubySDK::Operations::GetMediaPostersRequest,
|
|
base_url,
|
|
'/library/metadata/{ratingKey}/posters',
|
|
request
|
|
)
|
|
headers = {}
|
|
headers['Accept'] = 'application/json'
|
|
headers['user-agent'] = @sdk_configuration.user_agent
|
|
|
|
security = !@sdk_configuration.nil? && !@sdk_configuration.security_source.nil? ? @sdk_configuration.security_source.call : nil
|
|
|
|
timeout = (timeout_ms.to_f / 1000) unless timeout_ms.nil?
|
|
timeout ||= @sdk_configuration.timeout
|
|
|
|
connection = @sdk_configuration.client
|
|
|
|
hook_ctx = SDKHooks::HookContext.new(
|
|
base_url: base_url,
|
|
oauth2_scopes: [],
|
|
operation_id: 'get-media-posters',
|
|
security_source: @sdk_configuration.security_source
|
|
)
|
|
|
|
error = T.let(nil, T.nilable(StandardError))
|
|
r = T.let(nil, T.nilable(Faraday::Response))
|
|
|
|
begin
|
|
r = connection.get(url) do |req|
|
|
req.headers.merge!(headers)
|
|
req.options.timeout = timeout unless timeout.nil?
|
|
Utils.configure_request_security(req, security)
|
|
|
|
@sdk_configuration.hooks.before_request(
|
|
hook_ctx: SDKHooks::BeforeRequestHookContext.new(
|
|
hook_ctx: hook_ctx
|
|
),
|
|
request: req
|
|
)
|
|
end
|
|
rescue StandardError => e
|
|
error = e
|
|
ensure
|
|
if r.nil? || Utils.error_status?(r.status)
|
|
r = @sdk_configuration.hooks.after_error(
|
|
error: error,
|
|
hook_ctx: SDKHooks::AfterErrorHookContext.new(
|
|
hook_ctx: hook_ctx
|
|
),
|
|
response: r
|
|
)
|
|
else
|
|
r = @sdk_configuration.hooks.after_success(
|
|
hook_ctx: SDKHooks::AfterSuccessHookContext.new(
|
|
hook_ctx: hook_ctx
|
|
),
|
|
response: r
|
|
)
|
|
end
|
|
|
|
if r.nil?
|
|
raise error if !error.nil?
|
|
raise 'no response'
|
|
end
|
|
end
|
|
|
|
content_type = r.headers.fetch('Content-Type', 'application/octet-stream')
|
|
|
|
res = ::PlexRubySDK::Operations::GetMediaPostersResponse.new(
|
|
status_code: r.status, content_type: content_type, raw_response: r
|
|
)
|
|
if r.status == 200
|
|
if Utils.match_content_type(content_type, 'application/json')
|
|
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetMediaPostersResponseBody)
|
|
res.object = out
|
|
end
|
|
elsif r.status == 404
|
|
end
|
|
|
|
res
|
|
end
|
|
|
|
|
|
sig { params(rating_key: ::Integer, url: T.nilable(::String), request_body: T.nilable(::String), timeout_ms: T.nilable(Integer)).returns(::PlexRubySDK::Operations::PostMediaPosterResponse) }
|
|
def post_media_poster(rating_key, url = nil, request_body = nil, timeout_ms = nil)
|
|
# post_media_poster - Upload Media Poster
|
|
# Uploads a poster to a library item, either from a local file or a remote URL
|
|
request = ::PlexRubySDK::Operations::PostMediaPosterRequest.new(
|
|
|
|
rating_key: rating_key,
|
|
url: url,
|
|
request_body: request_body
|
|
)
|
|
url, params = @sdk_configuration.get_server_details
|
|
base_url = Utils.template_url(url, params)
|
|
url = Utils.generate_url(
|
|
::PlexRubySDK::Operations::PostMediaPosterRequest,
|
|
base_url,
|
|
'/library/metadata/{ratingKey}/posters',
|
|
request
|
|
)
|
|
headers = {}
|
|
req_content_type, data, form = Utils.serialize_request_body(request, :request_body, :raw)
|
|
headers['content-type'] = req_content_type
|
|
|
|
if form
|
|
body = Utils.encode_form(form)
|
|
elsif Utils.match_content_type(req_content_type, 'application/x-www-form-urlencoded')
|
|
body = URI.encode_www_form(data)
|
|
else
|
|
body = data
|
|
end
|
|
query_params = Utils.get_query_params(::PlexRubySDK::Operations::PostMediaPosterRequest, request)
|
|
headers['Accept'] = '*/*'
|
|
headers['user-agent'] = @sdk_configuration.user_agent
|
|
|
|
security = !@sdk_configuration.nil? && !@sdk_configuration.security_source.nil? ? @sdk_configuration.security_source.call : nil
|
|
|
|
timeout = (timeout_ms.to_f / 1000) unless timeout_ms.nil?
|
|
timeout ||= @sdk_configuration.timeout
|
|
|
|
connection = @sdk_configuration.client
|
|
|
|
hook_ctx = SDKHooks::HookContext.new(
|
|
base_url: base_url,
|
|
oauth2_scopes: [],
|
|
operation_id: 'post-media-poster',
|
|
security_source: @sdk_configuration.security_source
|
|
)
|
|
|
|
error = T.let(nil, T.nilable(StandardError))
|
|
r = T.let(nil, T.nilable(Faraday::Response))
|
|
|
|
begin
|
|
r = connection.post(url) do |req|
|
|
req.body = body
|
|
req.headers.merge!(headers)
|
|
req.options.timeout = timeout unless timeout.nil?
|
|
req.params = query_params
|
|
Utils.configure_request_security(req, security)
|
|
|
|
@sdk_configuration.hooks.before_request(
|
|
hook_ctx: SDKHooks::BeforeRequestHookContext.new(
|
|
hook_ctx: hook_ctx
|
|
),
|
|
request: req
|
|
)
|
|
end
|
|
rescue StandardError => e
|
|
error = e
|
|
ensure
|
|
if r.nil? || Utils.error_status?(r.status)
|
|
r = @sdk_configuration.hooks.after_error(
|
|
error: error,
|
|
hook_ctx: SDKHooks::AfterErrorHookContext.new(
|
|
hook_ctx: hook_ctx
|
|
),
|
|
response: r
|
|
)
|
|
else
|
|
r = @sdk_configuration.hooks.after_success(
|
|
hook_ctx: SDKHooks::AfterSuccessHookContext.new(
|
|
hook_ctx: hook_ctx
|
|
),
|
|
response: r
|
|
)
|
|
end
|
|
|
|
if r.nil?
|
|
raise error if !error.nil?
|
|
raise 'no response'
|
|
end
|
|
end
|
|
|
|
content_type = r.headers.fetch('Content-Type', 'application/octet-stream')
|
|
|
|
res = ::PlexRubySDK::Operations::PostMediaPosterResponse.new(
|
|
status_code: r.status, content_type: content_type, raw_response: r
|
|
)
|
|
if r.status == 200
|
|
elsif r.status == 404
|
|
end
|
|
|
|
res
|
|
end
|
|
|
|
|
|
sig { params(rating_key: ::Float, include_elements: T.nilable(::String), timeout_ms: T.nilable(Integer)).returns(::PlexRubySDK::Operations::GetMetadataChildrenResponse) }
|
|
def get_metadata_children(rating_key, include_elements = nil, timeout_ms = nil)
|
|
# get_metadata_children - Get Items Children
|
|
# This endpoint will return the children of of a library item specified with the ratingKey.
|
|
#
|
|
request = ::PlexRubySDK::Operations::GetMetadataChildrenRequest.new(
|
|
|
|
rating_key: rating_key,
|
|
include_elements: include_elements
|
|
)
|
|
url, params = @sdk_configuration.get_server_details
|
|
base_url = Utils.template_url(url, params)
|
|
url = Utils.generate_url(
|
|
::PlexRubySDK::Operations::GetMetadataChildrenRequest,
|
|
base_url,
|
|
'/library/metadata/{ratingKey}/children',
|
|
request
|
|
)
|
|
headers = {}
|
|
query_params = Utils.get_query_params(::PlexRubySDK::Operations::GetMetadataChildrenRequest, request)
|
|
headers['Accept'] = 'application/json'
|
|
headers['user-agent'] = @sdk_configuration.user_agent
|
|
|
|
security = !@sdk_configuration.nil? && !@sdk_configuration.security_source.nil? ? @sdk_configuration.security_source.call : nil
|
|
|
|
timeout = (timeout_ms.to_f / 1000) unless timeout_ms.nil?
|
|
timeout ||= @sdk_configuration.timeout
|
|
|
|
connection = @sdk_configuration.client
|
|
|
|
hook_ctx = SDKHooks::HookContext.new(
|
|
base_url: base_url,
|
|
oauth2_scopes: [],
|
|
operation_id: 'getMetadataChildren',
|
|
security_source: @sdk_configuration.security_source
|
|
)
|
|
|
|
error = T.let(nil, T.nilable(StandardError))
|
|
r = T.let(nil, T.nilable(Faraday::Response))
|
|
|
|
begin
|
|
r = connection.get(url) do |req|
|
|
req.headers.merge!(headers)
|
|
req.options.timeout = timeout unless timeout.nil?
|
|
req.params = query_params
|
|
Utils.configure_request_security(req, security)
|
|
|
|
@sdk_configuration.hooks.before_request(
|
|
hook_ctx: SDKHooks::BeforeRequestHookContext.new(
|
|
hook_ctx: hook_ctx
|
|
),
|
|
request: req
|
|
)
|
|
end
|
|
rescue StandardError => e
|
|
error = e
|
|
ensure
|
|
if r.nil? || Utils.error_status?(r.status)
|
|
r = @sdk_configuration.hooks.after_error(
|
|
error: error,
|
|
hook_ctx: SDKHooks::AfterErrorHookContext.new(
|
|
hook_ctx: hook_ctx
|
|
),
|
|
response: r
|
|
)
|
|
else
|
|
r = @sdk_configuration.hooks.after_success(
|
|
hook_ctx: SDKHooks::AfterSuccessHookContext.new(
|
|
hook_ctx: hook_ctx
|
|
),
|
|
response: r
|
|
)
|
|
end
|
|
|
|
if r.nil?
|
|
raise error if !error.nil?
|
|
raise 'no response'
|
|
end
|
|
end
|
|
|
|
content_type = r.headers.fetch('Content-Type', 'application/octet-stream')
|
|
|
|
res = ::PlexRubySDK::Operations::GetMetadataChildrenResponse.new(
|
|
status_code: r.status, content_type: content_type, raw_response: r
|
|
)
|
|
if r.status == 200
|
|
if Utils.match_content_type(content_type, 'application/json')
|
|
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetMetadataChildrenResponseBody)
|
|
res.object = out
|
|
end
|
|
elsif r.status == 400
|
|
if Utils.match_content_type(content_type, 'application/json')
|
|
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetMetadataChildrenBadRequest)
|
|
res.bad_request = out
|
|
end
|
|
elsif r.status == 401
|
|
if Utils.match_content_type(content_type, 'application/json')
|
|
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetMetadataChildrenUnauthorized)
|
|
res.unauthorized = out
|
|
end
|
|
end
|
|
|
|
res
|
|
end
|
|
|
|
|
|
sig { params(type: ::PlexRubySDK::Operations::GetTopWatchedContentQueryParamType, include_guids: T.nilable(::Integer), timeout_ms: T.nilable(Integer)).returns(::PlexRubySDK::Operations::GetTopWatchedContentResponse) }
|
|
def get_top_watched_content(type, include_guids = nil, timeout_ms = nil)
|
|
# get_top_watched_content - Get Top Watched Content
|
|
# This endpoint will return the top watched content from libraries of a certain type
|
|
#
|
|
request = ::PlexRubySDK::Operations::GetTopWatchedContentRequest.new(
|
|
|
|
type: type,
|
|
include_guids: include_guids
|
|
)
|
|
url, params = @sdk_configuration.get_server_details
|
|
base_url = Utils.template_url(url, params)
|
|
url = "#{base_url}/library/all/top"
|
|
headers = {}
|
|
query_params = Utils.get_query_params(::PlexRubySDK::Operations::GetTopWatchedContentRequest, request)
|
|
headers['Accept'] = 'application/json'
|
|
headers['user-agent'] = @sdk_configuration.user_agent
|
|
|
|
security = !@sdk_configuration.nil? && !@sdk_configuration.security_source.nil? ? @sdk_configuration.security_source.call : nil
|
|
|
|
timeout = (timeout_ms.to_f / 1000) unless timeout_ms.nil?
|
|
timeout ||= @sdk_configuration.timeout
|
|
|
|
connection = @sdk_configuration.client
|
|
|
|
hook_ctx = SDKHooks::HookContext.new(
|
|
base_url: base_url,
|
|
oauth2_scopes: [],
|
|
operation_id: 'getTopWatchedContent',
|
|
security_source: @sdk_configuration.security_source
|
|
)
|
|
|
|
error = T.let(nil, T.nilable(StandardError))
|
|
r = T.let(nil, T.nilable(Faraday::Response))
|
|
|
|
begin
|
|
r = connection.get(url) do |req|
|
|
req.headers.merge!(headers)
|
|
req.options.timeout = timeout unless timeout.nil?
|
|
req.params = query_params
|
|
Utils.configure_request_security(req, security)
|
|
|
|
@sdk_configuration.hooks.before_request(
|
|
hook_ctx: SDKHooks::BeforeRequestHookContext.new(
|
|
hook_ctx: hook_ctx
|
|
),
|
|
request: req
|
|
)
|
|
end
|
|
rescue StandardError => e
|
|
error = e
|
|
ensure
|
|
if r.nil? || Utils.error_status?(r.status)
|
|
r = @sdk_configuration.hooks.after_error(
|
|
error: error,
|
|
hook_ctx: SDKHooks::AfterErrorHookContext.new(
|
|
hook_ctx: hook_ctx
|
|
),
|
|
response: r
|
|
)
|
|
else
|
|
r = @sdk_configuration.hooks.after_success(
|
|
hook_ctx: SDKHooks::AfterSuccessHookContext.new(
|
|
hook_ctx: hook_ctx
|
|
),
|
|
response: r
|
|
)
|
|
end
|
|
|
|
if r.nil?
|
|
raise error if !error.nil?
|
|
raise 'no response'
|
|
end
|
|
end
|
|
|
|
content_type = r.headers.fetch('Content-Type', 'application/octet-stream')
|
|
|
|
res = ::PlexRubySDK::Operations::GetTopWatchedContentResponse.new(
|
|
status_code: r.status, content_type: content_type, raw_response: r
|
|
)
|
|
if r.status == 200
|
|
if Utils.match_content_type(content_type, 'application/json')
|
|
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetTopWatchedContentResponseBody)
|
|
res.object = out
|
|
end
|
|
elsif r.status == 400
|
|
if Utils.match_content_type(content_type, 'application/json')
|
|
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetTopWatchedContentBadRequest)
|
|
res.bad_request = out
|
|
end
|
|
elsif r.status == 401
|
|
if Utils.match_content_type(content_type, 'application/json')
|
|
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetTopWatchedContentUnauthorized)
|
|
res.unauthorized = out
|
|
end
|
|
end
|
|
|
|
res
|
|
end
|
|
end
|
|
end
|