plex_ruby_sdk 0.9.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: caf9cf3f01c061dad369aa2458abd0de7f5ccbdca7932c0ce38afd93a68523ce
-  data.tar.gz: 253e702742d48c33f4699c2a064c4aced5d8ddc5d07ff9c211d2e375f70454ce
+  metadata.gz: a5bad48f1f904e3a98d87694956684b027a45e4b4c515d6b172cfcb8c870f0d1
+  data.tar.gz: d64332ba8c2ca8eeb440b85c647e0ea1dffb927cf72e884aa63f8bd53748d6c8
 SHA512:
-  metadata.gz: d189a8ac0478edd58606abd7c34e9ae26b339894c9596a56b6fdcb94d9bb685d0dd7ea54724d9b155960b6cb5ebd6a896b2b757f700ae225d096edae2087a028
-  data.tar.gz: 98924f266aaca5b8229908f2c955baf2bb5dfa306fc8cbc0779579a531a114d64aee5468436b4c6a7b43f27b5a97ac1a2871d3957a710cff3e1e54d6e3cdaf99
+  metadata.gz: 2d8d2cda546ae93a538f44a2ccfe86075cbb44d477d1b8b75cb593fea42c60a0a21527dc8ffdbeca79b68610fd866cc786b1f734ae0a9805d4637f255436b8a4
+  data.tar.gz: 668965cafbfb35d3ecc856e8d749b9bf45f068161d9d45390e5ce93a72f651eb5eda89619883f80d439e15edd5ab8e1b9bf299bc6ba9b0201003a8165d63152c

data/lib/crystalline/metadata_fields.rb

@@ -38,7 +38,7 @@ module Crystalline
       end
 
       def unmarshal_single(field_type, value, decoder = nil)
-        if field_type.instance_of?(Class) && field_type < ::Crystalline::FieldAugmented
+        if field_type.instance_of?(Class) && field_type.include?(::Crystalline::MetadataFields)
           unmarshalled = field_type.from_dict(value)
           return unmarshalled
         elsif field_type.to_s == 'Object'
@@ -57,7 +57,7 @@ module Crystalline
         end
       end
 
-      sig { params(json_obj: T.any(String, T::Hash[Symbol, String])).returns(::Crystalline::FieldAugmented) }
+      sig { params(json_obj: T.any(String, T::Hash[Symbol, String])).returns(Object) }
       def from_json(json_obj)
         begin
           d = JSON.parse(json_obj)
@@ -67,7 +67,7 @@ module Crystalline
         from_dict(d)
       end
 
-      sig { params(d: T::Hash[Symbol, String]).returns(::Crystalline::FieldAugmented) }
+      sig { params(d: T::Hash[Symbol, String]).returns(Object) }
       def from_dict(d)
         to_build = new
 
@@ -122,7 +122,7 @@ module Crystalline
                 break
               end
             end
-          elsif field_type.instance_of?(Class) && field_type < ::Crystalline::FieldAugmented
+          elsif field_type.instance_of?(Class) && field_type.include?(::Crystalline::MetadataFields)
             unmarshalled = Crystalline.unmarshal_json(value, field_type)
             to_build.send(key, unmarshalled)
           else
@@ -157,7 +157,7 @@ module Crystalline
     end
 
     def marshal_single(field)
-      if field.is_a? ::Crystalline::FieldAugmented
+      if field.class.include? ::Crystalline::MetadataFields
         field.to_dict
       else
         ::Crystalline.val_to_string(field, primitives: false)

data/lib/crystalline/utils.rb

@@ -8,17 +8,13 @@ require 'sorbet-runtime'
 module Crystalline
   extend T::Sig
 
-  class FieldAugmented
-    include MetadataFields
-  end
-
   sig { params(complex: Object).returns(Object) }
   def self.to_dict(complex)
     if complex.is_a? Array
       complex.map { |v| Crystalline.to_dict(v) }
     elsif complex.is_a? Hash
       complex.transform_values { |v| Crystalline.to_dict(v) }
-    elsif complex.is_a? Crystalline::FieldAugmented
+    elsif complex.respond_to?(:class) && complex.class.include?(::Crystalline::MetadataFields)
       complex.to_dict
     else
       val_to_string complex, primitives: false
@@ -34,7 +30,7 @@ module Crystalline
     if T.simplifiable? type
       type = T.simplify_type type
     end
-    if type.instance_of?(Class) && type < ::Crystalline::FieldAugmented
+    if type.instance_of?(Class) && type.include?(::Crystalline::MetadataFields)
       type.from_dict(data)
     elsif T.arr? type
       data.map { |v| Crystalline.unmarshal_json(v, T.arr_of(type)) }

data/lib/plex_ruby_sdk/activities.rb

@@ -29,7 +29,7 @@ module PlexRubySDK
     end
 
 
-    sig { params(timeout_ms: T.nilable(Integer)).returns(::PlexRubySDK::Operations::GetServerActivitiesResponse) }
+    sig { params(timeout_ms: T.nilable(Integer)).returns(Models::Operations::GetServerActivitiesResponse) }
     def get_server_activities(timeout_ms = nil)
       # get_server_activities - Get Server Activities
       # Get Server Activities
@@ -55,10 +55,11 @@ module PlexRubySDK
       )
 
       error = T.let(nil, T.nilable(StandardError))
-      r = T.let(nil, T.nilable(Faraday::Response))
+      http_response = T.let(nil, T.nilable(Faraday::Response))
+      
       
       begin
-        r = connection.get(url) do |req|
+        http_response = connection.get(url) do |req|
           req.headers.merge!(headers)
           req.options.timeout = timeout unless timeout.nil?
           Utils.configure_request_security(req, security)
@@ -73,67 +74,101 @@ module PlexRubySDK
       rescue StandardError => e
         error = e
       ensure
-        if r.nil? || Utils.error_status?(r.status)
-          r = @sdk_configuration.hooks.after_error(
+        if http_response.nil? || Utils.error_status?(http_response.status)
+          http_response = @sdk_configuration.hooks.after_error(
             error: error,
             hook_ctx: SDKHooks::AfterErrorHookContext.new(
               hook_ctx: hook_ctx
             ),
-            response: r
+            response: http_response
           )
         else
-          r = @sdk_configuration.hooks.after_success(
+          http_response = @sdk_configuration.hooks.after_success(
             hook_ctx: SDKHooks::AfterSuccessHookContext.new(
               hook_ctx: hook_ctx
             ),
-            response: r
+            response: http_response
           )
         end
         
-        if r.nil?
+        if http_response.nil?
           raise error if !error.nil?
           raise 'no response'
         end
       end
-
-      content_type = r.headers.fetch('Content-Type', 'application/octet-stream')
-
-      res = ::PlexRubySDK::Operations::GetServerActivitiesResponse.new(
-        status_code: r.status, content_type: content_type, raw_response: r
-      )
-      if r.status == 200
+      
+      content_type = http_response.headers.fetch('Content-Type', 'application/octet-stream')
+      if Utils.match_status_code(http_response.status, ['200'])
         if Utils.match_content_type(content_type, 'application/json')
-          out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetServerActivitiesResponseBody)
-          res.object = out
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Operations::GetServerActivitiesResponseBody)
+          response = Models::Operations::GetServerActivitiesResponse.new(
+            status_code: http_response.status,
+            content_type: content_type,
+            raw_response: http_response,
+            object: obj
+          )
+
+          return response
+        else
+          raise ::PlexRubySDK::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown content type received'
         end
-      elsif r.status == 400
+      elsif Utils.match_status_code(http_response.status, ['400'])
         if Utils.match_content_type(content_type, 'application/json')
-          out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetServerActivitiesBadRequest)
-          res.bad_request = out
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::GetServerActivitiesBadRequest)
+          obj.raw_response = http_response
+          throw obj
+        else
+          raise ::PlexRubySDK::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown content type received'
         end
-      elsif r.status == 401
+      elsif Utils.match_status_code(http_response.status, ['401'])
         if Utils.match_content_type(content_type, 'application/json')
-          out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetServerActivitiesUnauthorized)
-          res.unauthorized = out
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::GetServerActivitiesUnauthorized)
+          obj.raw_response = http_response
+          throw obj
+        else
+          raise ::PlexRubySDK::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown content type received'
         end
-      end
+      elsif Utils.match_status_code(http_response.status, ['4XX'])
+        raise ::PlexRubySDK::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'API error occurred'
+      elsif Utils.match_status_code(http_response.status, ['5XX'])
+        raise ::PlexRubySDK::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'API error occurred'
+      else
+        raise ::PlexRubySDK::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown status code received'
 
-      res
+      end
     end
 
 
-    sig { params(activity_uuid: ::String, timeout_ms: T.nilable(Integer)).returns(::PlexRubySDK::Operations::CancelServerActivitiesResponse) }
+    sig { params(activity_uuid: ::String, timeout_ms: T.nilable(Integer)).returns(Models::Operations::CancelServerActivitiesResponse) }
     def cancel_server_activities(activity_uuid, timeout_ms = nil)
       # cancel_server_activities - Cancel Server Activities
       # Cancel Server Activities
-      request = ::PlexRubySDK::Operations::CancelServerActivitiesRequest.new(
+      request = Models::Operations::CancelServerActivitiesRequest.new(
         
         activity_uuid: activity_uuid
       )
       url, params = @sdk_configuration.get_server_details
       base_url = Utils.template_url(url, params)
       url = Utils.generate_url(
-        ::PlexRubySDK::Operations::CancelServerActivitiesRequest,
+        Models::Operations::CancelServerActivitiesRequest,
         base_url,
         '/activities/{activityUUID}',
         request
@@ -157,10 +192,11 @@ module PlexRubySDK
       )
 
       error = T.let(nil, T.nilable(StandardError))
-      r = T.let(nil, T.nilable(Faraday::Response))
+      http_response = T.let(nil, T.nilable(Faraday::Response))
+      
       
       begin
-        r = connection.delete(url) do |req|
+        http_response = connection.delete(url) do |req|
           req.headers.merge!(headers)
           req.options.timeout = timeout unless timeout.nil?
           Utils.configure_request_security(req, security)
@@ -175,48 +211,78 @@ module PlexRubySDK
       rescue StandardError => e
         error = e
       ensure
-        if r.nil? || Utils.error_status?(r.status)
-          r = @sdk_configuration.hooks.after_error(
+        if http_response.nil? || Utils.error_status?(http_response.status)
+          http_response = @sdk_configuration.hooks.after_error(
             error: error,
             hook_ctx: SDKHooks::AfterErrorHookContext.new(
               hook_ctx: hook_ctx
             ),
-            response: r
+            response: http_response
           )
         else
-          r = @sdk_configuration.hooks.after_success(
+          http_response = @sdk_configuration.hooks.after_success(
             hook_ctx: SDKHooks::AfterSuccessHookContext.new(
               hook_ctx: hook_ctx
             ),
-            response: r
+            response: http_response
           )
         end
         
-        if r.nil?
+        if http_response.nil?
           raise error if !error.nil?
           raise 'no response'
         end
       end
-
-      content_type = r.headers.fetch('Content-Type', 'application/octet-stream')
-
-      res = ::PlexRubySDK::Operations::CancelServerActivitiesResponse.new(
-        status_code: r.status, content_type: content_type, raw_response: r
-      )
-      if r.status == 200
-      elsif r.status == 400
+      
+      content_type = http_response.headers.fetch('Content-Type', 'application/octet-stream')
+      if Utils.match_status_code(http_response.status, ['200'])
+        http_response = @sdk_configuration.hooks.after_success(
+          hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+            hook_ctx: hook_ctx
+          ),
+          response: http_response
+        )
+        return Models::Operations::CancelServerActivitiesResponse.new(
+          status_code: http_response.status,
+          content_type: content_type,
+          raw_response: http_response
+        )
+      elsif Utils.match_status_code(http_response.status, ['400'])
         if Utils.match_content_type(content_type, 'application/json')
-          out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::CancelServerActivitiesBadRequest)
-          res.bad_request = out
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::CancelServerActivitiesBadRequest)
+          obj.raw_response = http_response
+          throw obj
+        else
+          raise ::PlexRubySDK::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown content type received'
         end
-      elsif r.status == 401
+      elsif Utils.match_status_code(http_response.status, ['401'])
         if Utils.match_content_type(content_type, 'application/json')
-          out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::CancelServerActivitiesUnauthorized)
-          res.unauthorized = out
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::CancelServerActivitiesUnauthorized)
+          obj.raw_response = http_response
+          throw obj
+        else
+          raise ::PlexRubySDK::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown content type received'
         end
-      end
+      elsif Utils.match_status_code(http_response.status, ['4XX'])
+        raise ::PlexRubySDK::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'API error occurred'
+      elsif Utils.match_status_code(http_response.status, ['5XX'])
+        raise ::PlexRubySDK::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'API error occurred'
+      else
+        raise ::PlexRubySDK::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown status code received'
 
-      res
+      end
     end
   end
 end