rdstation-ruby-client 2.0.0 → 2.4.0

data/lib/rdstation/api_response.rb

@@ -1,8 +1,7 @@
 module RDStation
   module ApiResponse
     def self.build(response)
-      response_body = JSON.parse(response.body)
-      return response_body if response.code.between?(200, 299)
+      return JSON.parse(response.body) if response.code.between?(200, 299)
 
       RDStation::ErrorHandler.new(response).raise_error
     end

data/lib/rdstation/authentication.rb

@@ -5,10 +5,12 @@ module RDStation
 
     AUTH_TOKEN_URL = 'https://api.rd.services/auth/token'.freeze
     DEFAULT_HEADERS = { 'Content-Type' => 'application/json' }.freeze
+    REVOKE_URL = 'https://api.rd.services/auth/revoke'.freeze
 
-    def initialize(client_id, client_secret)
-      @client_id = client_id
-      @client_secret = client_secret
+    def initialize(client_id = nil, client_secret = nil)
+      warn_deprecation if client_id || client_secret
+      @client_id = client_id || RDStation.configuration&.client_id
+      @client_secret = client_secret || RDStation.configuration&.client_secret
     end
 
     #
@@ -47,8 +49,31 @@ module RDStation
       ApiResponse.build(response)
     end
 
+    def self.revoke(access_token:)
+      response = self.post(
+        REVOKE_URL,
+        body: revoke_body(access_token),
+        headers: revoke_headers(access_token)
+      )
+      ApiResponse.build(response)
+    end
+
     private
 
+    def self.revoke_body(access_token)
+      URI.encode_www_form({
+        token: access_token,
+        token_type_hint: 'access_token'
+      })
+    end
+
+    def self.revoke_headers(access_token)
+      {
+        "Authorization" => "Bearer #{access_token}",
+        "Content-Type" => "application/x-www-form-urlencoded"
+      }
+    end
+
     def post_to_auth_endpoint(params)
       default_body = { client_id: @client_id, client_secret: @client_secret }
       body = default_body.merge(params)
@@ -59,5 +84,9 @@ module RDStation
         headers: DEFAULT_HEADERS
       )
     end
+
+    def warn_deprecation
+      warn "DEPRECATION WARNING: Providing client_id and client_secret directly to RDStation::Authentication.new is deprecated and will be removed in future versions. Use RDStation.configure instead."
+    end
   end
 end

data/lib/rdstation/{authorization_header.rb → authorization.rb}

@@ -1,21 +1,24 @@
 module RDStation
-  class AuthorizationHeader
-    
-    def initialize(access_token:)
+  class Authorization
+    attr_reader :refresh_token
+    attr_accessor :access_token, :access_token_expires_in
+    def initialize(access_token:, refresh_token: nil, access_token_expires_in: nil)
       @access_token = access_token
+      @refresh_token = refresh_token
+      @access_token_expires_in = access_token_expires_in
       validate_access_token access_token
     end
-    
-    def to_h
+
+    def headers
       { "Authorization" => "Bearer #{@access_token}", "Content-Type" => "application/json" }
     end
-    
+
     private
-    
+
     def validate_access_token(access_token)
       access_token_msg = ':access_token is required'
       raise ArgumentError, access_token_msg unless access_token
     end
-    
+
   end
 end

data/lib/rdstation/builder/field.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module RDStation
+  class Builder
+    # More info: https://developers.rdstation.com/pt-BR/reference/fields#methodPostDetails
+    class Field
+      DATA_TYPES = %w(STRING INTEGER BOOLEAN STRING[]).freeze
+      PRESENTATION_TYPES = %w[TEXT_INPUT TEXT_AREA URL_INPUT PHONE_INPUT
+                              EMAIL_INPUT CHECK_BOX NUMBER_INPUT COMBO_BOX
+                              RADIO_BUTTON MULTIPLE_CHOICE].freeze
+
+      REQUIRED_FIELDS = %w[api_identifier data_type presentation_type label name].freeze
+
+      def initialize(api_identifier)
+        raise 'api_identifier required' unless api_identifier
+        unless valid_identifier(api_identifier)
+          raise 'api_identifier is not in a valid format, need start with "cf_"'
+        end
+
+        @values = {}
+        @values['api_identifier'] = api_identifier
+      end
+
+      def data_type(data_type)
+        raise "Not valid data_type - #{DATA_TYPES}" unless DATA_TYPES.include? data_type
+
+        @values['data_type'] = data_type
+      end
+
+      def presentation_type(presentation_type)
+        unless PRESENTATION_TYPES.include? presentation_type
+          raise "Not valid presentation_type - #{PRESENTATION_TYPES}"
+        end
+
+        @values['presentation_type'] = presentation_type
+      end
+
+      def label(language, label)
+        @values['label'] = { language.to_s => label }
+      end
+
+      def name(language, name)
+        @values['name'] = { language.to_s => name }
+      end
+
+      def validation_rules(validation_rules)
+        @values['validation_rules'] = validation_rules
+      end
+
+      def valid_options(valid_options)
+        @values['valid_options'] = valid_options
+      end
+
+      def build
+        empty_fields = REQUIRED_FIELDS.select { |field| @values[field].nil? }
+        unless empty_fields.empty?
+          raise "Required fields are missing - #{empty_fields}"
+        end
+
+        @values
+      end
+
+      private
+
+      def valid_identifier(api_identifier)
+        api_identifier.start_with? 'cf_'
+      end
+    end
+  end
+end

data/lib/rdstation/client.rb

@@ -1,23 +1,33 @@
 module RDStation
   class Client
-    def initialize(access_token:)
-      @authorization_header = AuthorizationHeader.new(access_token: access_token)
+    def initialize(access_token:, refresh_token: nil)
+      warn_deprecation unless refresh_token
+      @authorization = Authorization.new(
+        access_token: access_token,
+        refresh_token: refresh_token
+      )
     end
-    
+
     def contacts
-      @contacts ||= RDStation::Contacts.new(authorization_header: @authorization_header)
+      @contacts ||= RDStation::Contacts.new(authorization: @authorization)
     end
 
     def events
-      @events ||= RDStation::Events.new(authorization_header: @authorization_header)
+      @events ||= RDStation::Events.new(authorization: @authorization)
     end
 
     def fields
-      @fields ||= RDStation::Fields.new(authorization_header: @authorization_header)
+      @fields ||= RDStation::Fields.new(authorization: @authorization)
     end
 
     def webhooks
-      @webhooks ||= RDStation::Webhooks.new(authorization_header: @authorization_header)
+      @webhooks ||= RDStation::Webhooks.new(authorization: @authorization)
+    end
+
+    private
+
+    def warn_deprecation
+      warn "DEPRECATION WARNING: Specifying refresh_token in RDStation::Client.new(access_token: 'at', refresh_token: 'rt') is optional right now, but will be mandatory in future versions. "
     end
   end
 end

data/lib/rdstation/contacts.rb

@@ -3,9 +3,10 @@ module RDStation
   # More info: https://developers.rdstation.com/pt-BR/reference/contacts
   class Contacts
     include HTTParty
-    
-    def initialize(authorization_header:)
-      @authorization_header = authorization_header
+    include ::RDStation::RetryableRequest
+
+    def initialize(authorization:)
+      @authorization = authorization
     end
 
     #
@@ -13,13 +14,17 @@ module RDStation
     #   The unique uuid associated to each RD Station Contact.
     #
     def by_uuid(uuid)
-      response = self.class.get(base_url(uuid), headers: @authorization_header.to_h)
-      ApiResponse.build(response)
+      retryable_request(@authorization) do |authorization|
+        response = self.class.get(base_url(uuid), headers: authorization.headers)
+        ApiResponse.build(response)
+      end
     end
 
     def by_email(email)
-      response = self.class.get(base_url("email:#{email}"), headers: @authorization_header.to_h)
-      ApiResponse.build(response)
+      retryable_request(@authorization) do |authorization|
+        response = self.class.get(base_url("email:#{email}"), headers: authorization.headers)
+        ApiResponse.build(response)
+      end
     end
 
     # The Contact hash may contain the following parameters:
@@ -34,8 +39,10 @@ module RDStation
     # :website
     # :tags
     def update(uuid, contact_hash)
-      response = self.class.patch(base_url(uuid), :body => contact_hash.to_json, :headers => @authorization_header.to_h)
-      ApiResponse.build(response)
+      retryable_request(@authorization) do |authorization|
+        response = self.class.patch(base_url(uuid), :body => contact_hash.to_json, :headers => authorization.headers)
+        ApiResponse.build(response)
+      end
     end
 
     #
@@ -47,14 +54,16 @@ module RDStation
     #   Contact data
     #
     def upsert(identifier, identifier_value, contact_hash)
-      path = "#{identifier}:#{identifier_value}"
-      response = self.class.patch(base_url(path), body: contact_hash.to_json, headers: @authorization_header.to_h)
-      ApiResponse.build(response)
+      retryable_request(@authorization) do |authorization|
+        path = "#{identifier}:#{identifier_value}"
+        response = self.class.patch(base_url(path), body: contact_hash.to_json, headers: authorization.headers)
+        ApiResponse.build(response)
+      end
     end
 
     private
 
-    def base_url(path = "")
+    def base_url(path = '')
       "https://api.rd.services/platform/contacts/#{path}"
     end
   end

data/lib/rdstation/error.rb

@@ -19,11 +19,13 @@ module RDStation
     class Conflict < Error; end
     class UnsupportedMediaType < Error; end
     class UnprocessableEntity < Error; end
+    class TooManyRequests < Error; end
     class InternalServerError < Error; end
     class NotImplemented < Error; end
     class BadGateway < Error; end
     class ServiceUnavailable < Error; end
     class ServerError < Error; end
+    class UnknownError < Error; end
 
     # 400 - Bad Request
     class ConflictingField < BadRequest; end

data/lib/rdstation/error/format.rb

@@ -1,9 +1,14 @@
+# frozen_string_literal: true
+
 module RDStation
   class Error
     class Format
-      FLAT_HASH = 'FLAT_HASH'.freeze
-      HASH_OF_ARRAYS = 'HASH_OF_ARRAYS'.freeze
-      ARRAY_OF_HASHES = 'ARRAY_OF_HASHES'.freeze
+      FLAT_HASH = 'FLAT_HASH'
+      HASH_OF_ARRAYS = 'HASH_OF_ARRAYS'
+      ARRAY_OF_HASHES = 'ARRAY_OF_HASHES'
+      HASH_OF_MULTIPLE_TYPES = 'HASH_OF_MULTIPLE_TYPES'
+      HASH_OF_HASHES = 'HASH_OF_HASHES'
+      SINGLE_HASH = 'SINGLE_HASH'
 
       def initialize(errors)
         @errors = errors
@@ -11,20 +16,41 @@ module RDStation
 
       def format
         return FLAT_HASH if flat_hash?
+        return SINGLE_HASH if single_hash?
         return HASH_OF_ARRAYS if hash_of_arrays?
+        return HASH_OF_HASHES if hash_of_hashes?
+        return HASH_OF_MULTIPLE_TYPES if hash_of_multiple_types?
+
         ARRAY_OF_HASHES
       end
 
       private
 
+      def single_hash?
+        return unless @errors.is_a?(Hash)
+
+        @errors.key?('error')
+      end
+
       def flat_hash?
         return unless @errors.is_a?(Hash)
+
         @errors.key?('error_type')
       end
 
       def hash_of_arrays?
         @errors.is_a?(Hash) && @errors.values.all? { |error| error.is_a? Array }
       end
+
+      def hash_of_hashes?
+        @errors.is_a?(Hash) && @errors.values.all? { |error| error.is_a? Hash }
+      end
+
+      def hash_of_multiple_types?
+        @errors.is_a?(Hash) &&
+          @errors.values.any? { |error| error.is_a? Hash } &&
+          @errors.values.any? { |error| error.is_a? Array }
+      end
     end
   end
 end

data/lib/rdstation/error/formatter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative './format'
 
 module RDStation
@@ -11,27 +13,61 @@ module RDStation
         return @error_response unless @error_response.is_a?(Hash)
 
         case error_format.format
+        when RDStation::Error::Format::SINGLE_HASH
+          return from_single_hash
         when RDStation::Error::Format::FLAT_HASH
           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
       end
 
+      def from_single_hash
+        error_hash = @error_response.dup
+        error_message = error_hash.delete('error')
+
+        [
+          {
+            'error_type' => 'TOO_MANY_REQUESTS',
+            'error_message' => error_message,
+            'details' => error_hash
+          }
+        ]
+      end
+
       def from_flat_hash
         [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
@@ -39,7 +75,32 @@ module RDStation
       end
 
       def errors
-        @errors ||= @error_response['errors']
+        @errors ||= @error_response.fetch('errors', @error_response)
+      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