quaderno 1.13.2 → 1.17.0

data/lib/quaderno-ruby/behavior/block.rb

@@ -1,28 +1,29 @@
-module Quaderno
-  module Behavior
-    module Block
-      def self.included(receiver)
-        receiver.send :extend, ClassMethods
-      end
+module Quaderno::Behavior
+  module Block
+    def self.included(receiver)
+      receiver.send :extend, ClassMethods
+    end
+
+    module ClassMethods
+      include Quaderno::Helpers::Authentication
 
-      module ClassMethods
-        include Quaderno::Helpers::Authentication
+      def block(id, options = {})
+        authentication = get_authentication(options.merge(api_model: api_model))
 
-        def block(id, options = {})
-          authentication = get_authentication(options.merge(api_model: api_model))
 
+        response = put("#{authentication[:url]}#{api_model.api_path}/#{id}/block.json",
+          basic_auth: authentication[:basic_auth],
+          headers: version_header.merge(authentication[:headers])
+        )
 
-          response = put("#{authentication[:url]}#{api_model.api_path}/#{id}/block.json",
-            basic_auth: authentication[:basic_auth],
-            headers: version_header.merge(authentication[:headers])
-          )
+        check_exception_for(response, { rate_limit: true, subdomain_or_token: true, id: true })
+        doc = response.parsed_response
 
-          check_exception_for(response, { rate_limit: true, subdomain_or_token: true, id: true })
-          doc = response.parsed_response
+        object = new doc
+        object.rate_limit_info = response
 
-          new doc
-        end
+        object
       end
     end
   end
-end
+end

data/lib/quaderno-ruby/behavior/crud.rb

@@ -1,125 +1,138 @@
-module Quaderno
-  module Behavior
-    module Crud
+module Quaderno::Behavior
+  module Crud
 
-      def self.included(receiver)
-        receiver.send :extend, ClassMethods
-      end
+    def self.included(receiver)
+      receiver.send :extend, ClassMethods
+    end
 
-      module ClassMethods
-        include Quaderno::Helpers::Authentication
+    module ClassMethods
+      include Quaderno::Helpers::Authentication
 
-        def parse_nested(element)
-          if element.has_key?('payments')
-            payments_collection = Array.new
-            (element['payments'] || Array.new).each { |payment| payments_collection << Quaderno::Payment.new(payment) }
-            element['payments'] = payments_collection
-          end
+      def parse_nested(element)
+        if element.has_key?('payments')
+          payments_collection = Array.new
+          (element['payments'] || Array.new).each { |payment| payments_collection << Quaderno::Payment.new(payment) }
+          element['payments'] = payments_collection
+        end
 
-          items_collection = Array.new
-          element['items'].each { |item| items_collection << Quaderno::DocumentItem.new(item) }
-          element['items'] = items_collection
-          element['contact'] = Quaderno::Contact.new(element['contact'])
+        items_collection = Array.new
+        element['items'].each { |item| items_collection << Quaderno::DocumentItem.new(item) }
+        element['items'] = items_collection
+        element['contact'] = Quaderno::Contact.new(element['contact'])
 
-          element
-        end
+        element
+      end
 
-        def all(options = {})
-          authentication = get_authentication(options.merge(api_model: api_model))
-          filter = options.delete_if { |k,v| %w(auth_token access_token api_url mode api_model).include? k.to_s }
-
-          response = get("#{authentication[:url]}#{api_model.api_path}.json",
-            query: filter,
-            basic_auth: authentication[:basic_auth],
-            headers: version_header.merge(authentication[:headers])
-          )
-
-          check_exception_for(response, { rate_limit: true, subdomain_or_token: true })
-          array = response.parsed_response
-          collection = Quaderno::Collection.new
-
-          if is_a_document?
-            array.each do |element|
-              element[:authentication_data] = authentication
-              api_model.parse_nested(element)
-              collection << (new element)
-            end
-          else
-            array.each { |element| collection << (new element) }
+      def all(options = {})
+        authentication = get_authentication(options.merge(api_model: api_model))
+        filter = options.delete_if { |k,v| %w(auth_token access_token api_url mode api_model).include? k.to_s }
+
+        response = get("#{authentication[:url]}#{api_model.api_path}.json",
+          query: filter,
+          basic_auth: authentication[:basic_auth],
+          headers: version_header.merge(authentication[:headers])
+        )
+
+        check_exception_for(response, { rate_limit: true, subdomain_or_token: true })
+        array = response.parsed_response
+        collection = Quaderno::Collection.new
+
+        if is_a_document?
+          array.each do |element|
+            element[:authentication_data] = authentication
+            api_model.parse_nested(element)
+            collection << (new element)
           end
+        else
+          array.each { |element| collection << (new element) }
+        end
 
-          collection.current_page = response.headers['x-pages-currentpage']
-          collection.total_pages = response.headers['x-pages-totalpages']
+        collection.rate_limit_info = response
+        collection.current_page = response.headers['x-pages-currentpage']
+        collection.total_pages = response.headers['x-pages-totalpages']
 
-          collection
-        end
+        collection
+      end
 
-        def find(id, options = {})
-          authentication = get_authentication(options.merge(api_model: api_model))
+      def find(id, options = {})
+        authentication = get_authentication(options.merge(api_model: api_model))
 
-          response = get("#{authentication[:url]}#{api_model.api_path}/#{id}.json",
-            basic_auth: authentication[:basic_auth],
-            headers: version_header.merge(authentication[:headers])
-          )
+        response = get("#{authentication[:url]}#{api_model.api_path}/#{id}.json",
+          basic_auth: authentication[:basic_auth],
+          headers: version_header.merge(authentication[:headers])
+        )
 
-          check_exception_for(response, { rate_limit: true, subdomain_or_token: true, id: true })
-          hash = response.parsed_response
-          hash[:authentication_data] = authentication
+        check_exception_for(response, { rate_limit: true, subdomain_or_token: true, id: true })
+        hash = response.parsed_response
+        hash[:authentication_data] = authentication
 
-          api_model.parse_nested(hash) if is_a_document?
+        api_model.parse_nested(hash) if is_a_document?
 
-          new hash
-        end
+        object = new hash
+        object.rate_limit_info = response
 
-        def create(params = {})
-          authentication = get_authentication(params.merge(api_model: api_model))
-          params.delete_if { |k,v| %w(auth_token access_token api_url mode api_model').include? k.to_s }
+        object
+      end
 
-          response = post("#{authentication[:url]}#{api_model.api_path}.json",
-            body: params.to_json,
-            basic_auth: authentication[:basic_auth],
-            headers: version_header.merge(authentication[:headers]).merge('Content-Type' => 'application/json')
-          )
+      def create(params = {})
+        authentication = get_authentication(params.merge(api_model: api_model))
+        params.delete_if { |k,v| %w(auth_token access_token api_url mode api_model').include? k.to_s }
 
-          check_exception_for(response, { rate_limit: true, subdomain_or_token: true, required_fields: true })
-          hash = response.parsed_response
-          hash[:authentication_data] = authentication
+        response = post("#{authentication[:url]}#{api_model.api_path}.json",
+          body: params.to_json,
+          basic_auth: authentication[:basic_auth],
+          headers: version_header.merge(authentication[:headers]).merge('Content-Type' => 'application/json')
+        )
 
-          api_model.parse_nested(hash) if is_a_document?
+        check_exception_for(response, { rate_limit: true, subdomain_or_token: true, required_fields: true })
+        hash = response.parsed_response
+        hash[:authentication_data] = authentication
 
-          new hash
-        end
+        api_model.parse_nested(hash) if is_a_document?
 
-        def update(id, params = {})
-          authentication = get_authentication(params.merge(api_model: api_model))
-          params = params.delete_if { |k,v| %w(auth_token access_token api_url mode api_model').include? k.to_s }
+        object = new hash
+        object.rate_limit_info = response
 
-          response = put("#{authentication[:url]}#{api_model.api_path}/#{id}.json",
-            body: params.to_json,
-            basic_auth: authentication[:basic_auth],
-            headers: version_header.merge(authentication[:headers]).merge('Content-Type' => 'application/json')
-          )
+        object
+      end
 
-          check_exception_for(response, { rate_limit: true, required_fields: true, subdomain_or_token: true, id: true })
-          hash = response.parsed_response
-          hash[:authentication_data] = authentication
+      def update(id, params = {})
+        authentication = get_authentication(params.merge(api_model: api_model))
+        params = params.delete_if { |k,v| %w(auth_token access_token api_url mode api_model').include? k.to_s }
 
-          api_model.parse_nested(hash) if is_a_document?
+        response = put("#{authentication[:url]}#{api_model.api_path}/#{id}.json",
+          body: params.to_json,
+          basic_auth: authentication[:basic_auth],
+          headers: version_header.merge(authentication[:headers]).merge('Content-Type' => 'application/json')
+        )
 
-          new hash
-        end
+        check_exception_for(response, { rate_limit: true, required_fields: true, subdomain_or_token: true, id: true })
+        hash = response.parsed_response
+        hash[:authentication_data] = authentication
 
-        def delete(id, options = {})
-          authentication = get_authentication(options.merge(api_model: api_model))
+        api_model.parse_nested(hash) if is_a_document?
 
-          response = HTTParty.delete("#{authentication[:url]}#{ api_model.api_path }/#{ id }.json",
-            basic_auth: authentication[:basic_auth],
-            headers: version_header.merge(authentication[:headers])
-          )
-          check_exception_for(response, { rate_limit: true, subdomain_or_token: true, id: true, has_documents: true })
+        object = new hash
+        object.rate_limit_info = response
 
-          true
-        end
+        object
+      end
+
+      def delete(id, options = {})
+        authentication = get_authentication(options.merge(api_model: api_model))
+
+        response = HTTParty.delete("#{authentication[:url]}#{ api_model.api_path }/#{ id }.json",
+          basic_auth: authentication[:basic_auth],
+          headers: version_header.merge(authentication[:headers])
+        )
+        check_exception_for(response, { rate_limit: true, subdomain_or_token: true, id: true, has_documents: true })
+
+        hash = { deleted: true, id: id }
+
+        object = new hash
+        object.rate_limit_info = response
+
+        object
       end
     end
   end

data/lib/quaderno-ruby/behavior/deliver.rb

@@ -1,26 +1,28 @@
-module Quaderno
-  module Behavior
-    module Deliver
+module Quaderno::Behavior
+  module Deliver
 
-      def self.included(base)
-        base.send :include, InstanceMethods
-      end
+    def self.included(base)
+      base.send :include, InstanceMethods
+    end
+
+    module InstanceMethods
+      include Quaderno::Helpers::Authentication
+
+      def deliver(options = nil)
+        self.authentication_data = get_authentication(options.merge(api_model: api_model)) if options.is_a?(Hash)
 
-      module InstanceMethods
-        include Quaderno::Helpers::Authentication
+        party_response = api_model.get("#{authentication_data[:url]}#{api_model.api_path}/#{id}/deliver.json",
+          basic_auth: authentication_data[:basic_auth],
+          headers: self.class.version_header.merge(authentication_data[:headers])
+        )
 
-        def deliver(options = nil)
-          self.authentication_data = get_authentication(options.merge(api_model: api_model)) if options.is_a?(Hash)
+        api_model.check_exception_for(party_response, { rate_limit: true, subdomain_or_token: true, id: true, required_fields: true })
 
-          party_response = api_model.get("#{authentication_data[:url]}#{api_model.api_path}/#{id}/deliver.json",
-            basic_auth: authentication_data[:basic_auth],
-            headers: self.class.version_header.merge(authentication_data[:headers])
-          )
+        data = Quaderno::Base.new(success: true)
+        data.rate_limit_info = party_response
 
-          api_model.check_exception_for(party_response, { rate_limit: true, subdomain_or_token: true, id: true, required_fields: true })
-          { limit: party_response.headers["x-ratelimit-limit"].to_i, remaining: party_response.headers["x-ratelimit-remaining"].to_i }
-        end
+        data
       end
     end
   end
-end
+end

data/lib/quaderno-ruby/behavior/payment.rb

@@ -1,50 +1,54 @@
-module Quaderno
-  module Behavior
-    module Payment
+module Quaderno::Behavior
+  module Payment
 
-      def self.included(base)
-        base.send :include, InstanceMethods
-      end
+    def self.included(base)
+      base.send :include, InstanceMethods
+    end
 
-      module InstanceMethods
-        include Quaderno::Helpers::Authentication
+    module InstanceMethods
+      include Quaderno::Helpers::Authentication
 
-        def add_payment(params = {})
-          if (params.keys.map(&:to_s) & %w(auth_token access_token api_url mode api_model)).any?
-            self.authentication_data = get_authentication(params.merge(api_model: api_model))
-            params = params.delete_if { |k, _| %w(auth_token access_token api_url mode api_model).include? k.to_s }
-          end
+      def add_payment(params = {})
+        if (params.keys.map(&:to_s) & %w(auth_token access_token api_url mode api_model)).any?
+          self.authentication_data = get_authentication(params.merge(api_model: api_model))
+          params = params.delete_if { |k, _| %w(auth_token access_token api_url mode api_model).include? k.to_s }
+        end
 
-          response = api_model.post("#{authentication_data[:url]}#{api_model.api_path}/#{id}/payments.json",
-            body: params,
-            basic_auth: authentication_data[:basic_auth],
-            headers: self.class.version_header.merge(authentication_data[:headers])
-          )
+        response = api_model.post("#{authentication_data[:url]}#{api_model.api_path}/#{id}/payments.json",
+          body: params,
+          basic_auth: authentication_data[:basic_auth],
+          headers: self.class.version_header.merge(authentication_data[:headers])
+        )
 
-          api_model.check_exception_for(response, { rate_limit: true, subdomain_or_token: true, required_fields: true })
+        api_model.check_exception_for(response, { rate_limit: true, subdomain_or_token: true, required_fields: true })
 
-          instance = Quaderno::Payment.new(response.parsed_response)
-          self.payments << instance
+        instance = Quaderno::Payment.new(response.parsed_response)
+        self.payments << instance
 
-          Quaderno::Payment.new instance
-        end
+        instance.rate_limit_info = response
 
-        def remove_payment(payment_id, options = nil)
-          self.authentication_data = get_authentication(options.merge(api_model: api_model)) if options.is_a?(Hash)
+        instance
+      end
 
+      def remove_payment(payment_id, options = nil)
+        self.authentication_data = get_authentication(options.merge(api_model: api_model)) if options.is_a?(Hash)
 
-          response = HTTParty.delete("#{authentication_data[:url]}#{api_model.api_path}/#{id}/payments/#{payment_id}.json",
-            basic_auth: authentication_data[:basic_auth],
-            headers: self.class.version_header.merge(authentication_data[:headers])
-          )
+        response = HTTParty.delete("#{authentication_data[:url]}#{api_model.api_path}/#{id}/payments/#{payment_id}.json",
+          basic_auth: authentication_data[:basic_auth],
+          headers: self.class.version_header.merge(authentication_data[:headers])
+        )
 
-          api_model.check_exception_for(response, { rate_limit: true, subdomain_or_token: true, id: true })
+        api_model.check_exception_for(response, { rate_limit: true, subdomain_or_token: true, id: true })
 
-          self.payments.delete_if { |payment| payment.id == payment_id }
+        self.payments.delete_if { |payment| payment.id == payment_id }
 
-          true
-        end
+        hash = { deleted: true, id: payment_id}
+
+        object = Quaderno::Payment.new(hash)
+        object.rate_limit_info = response
+
+        object
       end
     end
   end
-end
+end

data/lib/quaderno-ruby/behavior/retrieve.rb

@@ -1,35 +1,36 @@
-module Quaderno
-  module Behavior
-    module Retrieve
+module Quaderno::Behavior
+  module Retrieve
 
-      def self.included(receiver)
-        receiver.send :extend, ClassMethods
-      end
+    def self.included(receiver)
+      receiver.send :extend, ClassMethods
+    end
 
-      module ClassMethods
-        include Quaderno::Helpers::Authentication
+    module ClassMethods
+      include Quaderno::Helpers::Authentication
 
-        def retrieve(gateway_id, gateway = 'stripe', options = {})
-          authentication = get_authentication(options.merge(api_model: api_model))
+      def retrieve(gateway_id, gateway = 'stripe', options = {})
+        authentication = get_authentication(options.merge(api_model: api_model))
 
-          response = get("#{authentication[:url]}#{gateway}/#{@_retrieve_path}/#{gateway_id}.json",
-            basic_auth: authentication[:basic_auth],
-            headers: version_header.merge(authentication[:headers])
-          )
+        response = get("#{authentication[:url]}#{gateway}/#{@_retrieve_path}/#{gateway_id}.json",
+          basic_auth: authentication[:basic_auth],
+          headers: version_header.merge(authentication[:headers])
+        )
 
-          check_exception_for(response, { rate_limit: true, subdomain_or_token: true, id: true })
-          hash = response.parsed_response
-          hash[:authentication_data] = authentication
+        check_exception_for(response, { rate_limit: true, subdomain_or_token: true, id: true })
+        hash = response.parsed_response
+        hash[:authentication_data] = authentication
 
-          new hash
-        end
-        alias_method :retrieve_customer, :retrieve
+        object = new hash
+        object.rate_limit_info = response
+
+        object
+      end
+      alias_method :retrieve_customer, :retrieve
 
-        private
-        def retrieve_path(path)
-          @_retrieve_path = path
-        end
+      private
+      def retrieve_path(path)
+        @_retrieve_path = path
       end
     end
   end
-end
+end