rdstation-ruby-client 1.2.0 → 2.3.0

data/lib/rdstation/error/formatter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative './format'
 
 module RDStation
@@ -15,6 +17,10 @@ module RDStation
           return from_flat_hash
         when RDStation::Error::Format::HASH_OF_ARRAYS
           return from_hash_of_arrays
+        when RDStation::Error::Format::HASH_OF_HASHES
+          return from_hash_of_hashes
+        when RDStation::Error::Format::HASH_OF_MULTIPLE_TYPES
+          return from_hash_of_multiple_types
         end
 
         errors
@@ -24,14 +30,29 @@ module RDStation
         [errors]
       end
 
-      def from_hash_of_arrays
-        errors.each_with_object([]) do |errors, array_of_errors|
-          attribute_name = errors.first
-          attribute_errors = errors.last
-          path = { 'path' => "body.#{attribute_name}" }
-          errors = attribute_errors.map { |error| error.merge(path) }
-          array_of_errors.push(*errors)
+      def from_hash_of_multiple_types
+        array_of_errors = []
+        errors.each do |attribute_name, errors|
+          if errors.is_a? Array
+            result = build_error_from_array(attribute_name, errors)
+          end
+          if errors.is_a? Hash
+            result = build_error_from_multilingual_hash(attribute_name, errors)
+          end
+          array_of_errors.push(*result)
         end
+
+        array_of_errors
+      end
+
+      def from_hash_of_hashes
+        array_of_errors = []
+        errors.each do |attribute_name, errors|
+          result = build_error_from_multilingual_hash(attribute_name, errors)
+          array_of_errors.push(*result)
+        end
+
+        array_of_errors
       end
 
       def error_format
@@ -41,6 +62,31 @@ module RDStation
       def errors
         @errors ||= @error_response['errors']
       end
+
+      private
+
+      def build_error_from_array(attribute_name, attribute_errors)
+        path = { 'path' => "body.#{attribute_name}" }
+        attribute_errors.map { |error| error.merge(path) }
+      end
+
+      def build_error_from_multilingual_hash(attribute_name, errors_by_language)
+        array_of_errors = []
+        errors_by_language.each do |language, errors|
+          result = build_error_from_array("#{attribute_name}.#{language}", errors)
+          array_of_errors.push(*result)
+        end
+        array_of_errors
+      end
+
+      def from_hash_of_arrays
+        errors.each_with_object([]) do |errors, array_of_errors|
+          attribute_name = errors.first
+          attribute_errors = errors.last
+          errors = build_error_from_array(attribute_name, attribute_errors)
+          array_of_errors.push(*errors)
+        end
+      end
     end
   end
 end

data/lib/rdstation/error_handler.rb

@@ -1,37 +1,44 @@
 require_relative 'error/formatter'
-require_relative 'error_handler/conflicting_field'
-require_relative 'error_handler/default'
-require_relative 'error_handler/expired_access_token'
-require_relative 'error_handler/expired_code_grant'
-require_relative 'error_handler/invalid_credentials'
-require_relative 'error_handler/invalid_event_type'
-require_relative 'error_handler/resource_not_found'
+require_relative 'error_handler/bad_request'
 require_relative 'error_handler/unauthorized'
 
 module RDStation
   class ErrorHandler
-    ERROR_TYPES = [
-      ErrorHandler::ConflictingField,
-      ErrorHandler::ExpiredAccessToken,
-      ErrorHandler::ExpiredCodeGrant,
-      ErrorHandler::InvalidCredentials,
-      ErrorHandler::InvalidEventType,
-      ErrorHandler::ResourceNotFound,
-      ErrorHandler::Unauthorized,
-      ErrorHandler::Default
-    ].freeze
-
     def initialize(response)
       @response = response
+      @code = response.code
     end
 
-    def raise_errors
-      error_types.each(&:raise_error)
+    def raise_error
+      raise error_class, array_of_errors.first if error_class < RDStation::Error
+
+      error_class.new(array_of_errors).raise_error
+    rescue JSON::ParserError => error
+      raise error_class, { 'error_message' => response.body }
     end
 
     private
 
-    attr_reader :response
+    attr_reader :response, :code
+
+    def error_class
+      case code
+      when 400      then RDStation::ErrorHandler::BadRequest
+      when 401      then RDStation::ErrorHandler::Unauthorized
+      when 403      then RDStation::Error::Forbidden
+      when 404      then RDStation::Error::NotFound
+      when 405      then RDStation::Error::MethodNotAllowed
+      when 406      then RDStation::Error::NotAcceptable
+      when 409      then RDStation::Error::Conflict
+      when 415      then RDStation::Error::UnsupportedMediaType
+      when 422      then RDStation::Error::UnprocessableEntity
+      when 500      then RDStation::Error::InternalServerError
+      when 501      then RDStation::Error::NotImplemented
+      when 502      then RDStation::Error::BadGateway
+      when 503      then RDStation::Error::ServiceUnavailable
+      when 500..599 then RDStation::Error::ServerError
+      end
+    end
 
     def array_of_errors
       error_formatter.to_array.map do |error|
@@ -39,10 +46,6 @@ module RDStation
       end
     end
 
-    def error_types
-      ERROR_TYPES.map { |error_type| error_type.new(array_of_errors) }
-    end
-
     def response_errors
       JSON.parse(response.body)
     end
@@ -55,7 +58,7 @@ module RDStation
       {
         'headers' => response.headers,
         'body' => JSON.parse(response.body),
-        'http_status' => response.code
+        'http_status' => response.code,
       }
     end
   end

data/lib/rdstation/error_handler/bad_request.rb

@@ -0,0 +1,30 @@
+require_relative 'conflicting_field'
+require_relative 'invalid_event_type'
+
+module RDStation
+  class ErrorHandler
+    class BadRequest
+      BAD_REQUEST_ERRORS = [
+        ErrorHandler::ConflictingField,
+        ErrorHandler::InvalidEventType,
+      ].freeze
+
+      def initialize(array_of_errors)
+        @array_of_errors = array_of_errors
+      end
+
+      def raise_error
+        error_classes.each(&:raise_error)
+        raise RDStation::Error::BadRequest, @array_of_errors.first
+      end
+
+      private
+
+      def error_classes
+        BAD_REQUEST_ERRORS.map do |error|
+          error.new(@array_of_errors)
+        end
+      end
+    end
+  end
+end

data/lib/rdstation/error_handler/unauthorized.rb

@@ -1,23 +1,31 @@
+require_relative 'expired_access_token'
+require_relative 'expired_code_grant'
+require_relative 'invalid_credentials'
+
 module RDStation
   class ErrorHandler
     class Unauthorized
-      attr_reader :errors
-
-      ERROR_CODE = 'UNAUTHORIZED'.freeze
+      UNAUTHORIZED_ERRORS = [
+        ErrorHandler::ExpiredAccessToken,
+        ErrorHandler::ExpiredCodeGrant,
+        ErrorHandler::InvalidCredentials,
+      ].freeze
 
-      def initialize(errors)
-        @errors = errors
+      def initialize(array_of_errors)
+        @array_of_errors = array_of_errors
       end
 
       def raise_error
-        return if unauthorized_errors.empty?
-        raise RDStation::Error::Unauthorized, unauthorized_errors.first
+        error_classes.each(&:raise_error)
+        raise RDStation::Error::Unauthorized, @array_of_errors.first
       end
 
       private
 
-      def unauthorized_errors
-        errors.select { |error| error['error_type'] == ERROR_CODE }
+      def error_classes
+        UNAUTHORIZED_ERRORS.map do |error|
+          error.new(@array_of_errors)
+        end
       end
     end
   end

data/lib/rdstation/events.rb

@@ -1,31 +1,19 @@
 module RDStation
   class Events
     include HTTParty
+    include ::RDStation::RetryableRequest
 
     EVENTS_ENDPOINT = 'https://api.rd.services/platform/events'.freeze
 
-    def initialize(auth_token)
-      @auth_token = auth_token
+    def initialize(authorization:)
+      @authorization = authorization
     end
 
     def create(payload)
-      response = self.class.post(EVENTS_ENDPOINT, headers: required_headers, body: payload.to_json)
-      response_body = JSON.parse(response.body)
-      return response_body unless errors?(response_body)
-      RDStation::ErrorHandler.new(response).raise_errors
-    end
-
-    private
-
-    def errors?(response_body)
-      response_body.is_a?(Array) || response_body['errors']
-    end
-
-    def required_headers
-      {
-        'Authorization' => "Bearer #{@auth_token}",
-        'Content-Type'  => 'application/json'
-      }
+      retryable_request(@authorization) do |authorization|
+        response = self.class.post(EVENTS_ENDPOINT, headers: authorization.headers, body: payload.to_json)
+        ApiResponse.build(response)
+      end
     end
   end
 end

data/lib/rdstation/fields.rb

@@ -1,24 +1,48 @@
 # encoding: utf-8
 module RDStation
-  # More info: https://developers.rdstation.com/pt-BR/reference/contacts
+  # More info: https://developers.rdstation.com/pt-BR/reference/fields
   class Fields
     include HTTParty
+    include ::RDStation::RetryableRequest
 
     BASE_URL = 'https://api.rd.services/platform/contacts/fields'.freeze
 
-    def initialize(auth_token)
-      @auth_token = auth_token
+    def initialize(authorization:)
+      @authorization = authorization
     end
 
     def all
-      response = self.class.get(BASE_URL, headers: required_headers)
-      ApiResponse.build(response)
+      retryable_request(@authorization) do |authorization|
+        response = self.class.get(BASE_URL, headers: authorization.headers)
+        ApiResponse.build(response)
+      end
+    end
+
+    def create(payload)
+      retryable_request(@authorization) do |authorization|
+        response = self.class.post(BASE_URL, headers: authorization.headers, body: payload.to_json)
+        ApiResponse.build(response)
+      end
+    end
+
+    def update(uuid, payload)
+      retryable_request(@authorization) do |authorization|
+        response = self.class.patch(base_url(uuid), headers: authorization.headers, body: payload.to_json)
+        ApiResponse.build(response)
+      end
+    end
+
+    def delete(uuid)
+      retryable_request(@authorization) do |authorization|
+        response = self.class.delete(base_url(uuid), headers: authorization.headers)
+        ApiResponse.build(response)
+      end
     end
 
     private
 
-    def required_headers
-      { "Authorization" => "Bearer #{@auth_token}", "Content-Type" => "application/json" }
+    def base_url(path = '')
+      "#{BASE_URL}/#{path}"
     end
   end
 end

data/lib/rdstation/retryable_request.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module RDStation
+  module RetryableRequest
+    MAX_RETRIES = 1
+    def retryable_request(authorization)
+      retries = 0
+      begin
+        yield authorization
+      rescue ::RDStation::Error::ExpiredAccessToken => e
+        raise if !retry_possible?(authorization) || retries >= MAX_RETRIES
+
+        retries += 1
+        refresh_access_token(authorization)
+        retry
+      end
+    end
+
+    def retry_possible?(authorization)
+      [
+        RDStation.configuration&.client_id,
+        RDStation.configuration&.client_secret,
+        authorization.refresh_token
+      ].all?
+    end
+
+    def refresh_access_token(authorization)
+      client = RDStation::Authentication.new
+      response = client.update_access_token(authorization.refresh_token)
+      authorization.access_token = response['access_token']
+      authorization.access_token_expires_in = response['expires_in']
+      RDStation.configuration&.access_token_refresh_callback&.call(authorization)
+    end
+  end
+end

data/lib/rdstation/version.rb

@@ -1,3 +1,3 @@
 module RDStation
-  VERSION = '1.2.0'.freeze
+  VERSION = '2.3.0'.freeze
 end

data/lib/rdstation/webhooks.rb

@@ -1,35 +1,47 @@
 module RDStation
   class Webhooks
     include HTTParty
+    include ::RDStation::RetryableRequest
 
-    def initialize(auth_token)
-      @auth_token = auth_token
+    def initialize(authorization:)
+      @authorization = authorization
     end
 
     def all
-      response = self.class.get(base_url, headers: required_headers)
-      ApiResponse.build(response)
+      retryable_request(@authorization) do |authorization|
+        response = self.class.get(base_url, headers: authorization.headers)
+        ApiResponse.build(response)
+      end
     end
 
     def by_uuid(uuid)
-      response = self.class.get(base_url(uuid), headers: required_headers)
-      ApiResponse.build(response)
+      retryable_request(@authorization) do |authorization|
+        response = self.class.get(base_url(uuid), headers: authorization.headers)
+        ApiResponse.build(response)
+      end
     end
 
     def create(payload)
-      response = self.class.post(base_url, headers: required_headers, body: payload.to_json)
-      ApiResponse.build(response)
+      retryable_request(@authorization) do |authorization|
+        response = self.class.post(base_url, headers: authorization.headers, body: payload.to_json)
+        ApiResponse.build(response)
+      end
     end
 
     def update(uuid, payload)
-      response = self.class.put(base_url(uuid), headers: required_headers, body: payload.to_json)
-      ApiResponse.build(response)
+      retryable_request(@authorization) do |authorization|
+        response = self.class.put(base_url(uuid), headers: authorization.headers, body: payload.to_json)
+        ApiResponse.build(response)
+      end
     end
 
     def delete(uuid)
-      response = self.class.delete(base_url(uuid), headers: required_headers)
-      return webhook_deleted_message unless response.body
-      RDStation::ErrorHandler.new(response).raise_errors
+      retryable_request(@authorization) do |authorization|
+        response = self.class.delete(base_url(uuid), headers: authorization.headers)
+        return webhook_deleted_message unless response.body
+
+        RDStation::ErrorHandler.new(response).raise_error
+      end
     end
 
     private
@@ -41,9 +53,5 @@ module RDStation
     def base_url(path = '')
       "https://api.rd.services/integrations/webhooks/#{path}"
     end
-
-    def required_headers
-      { 'Authorization' => "Bearer #{@auth_token}", 'Content-Type' => 'application/json' }
-    end
   end
 end