conekta 1.0.0 → 1.1.0

data/lib/conekta/destination.rb

@@ -0,0 +1,29 @@
+module Conekta
+  class Destination < Resource
+    include Conekta::Operations::Delete
+    include Conekta::Operations::Update
+    include Conekta::Operations::CustomAction
+
+    attr_accessor :payee_id, :created_at, :type, :currency,
+                  :last4, :account_holder_name, :bank
+
+    def _url
+      if (id.nil? || id.to_s.empty?)
+        exception = Error.new({
+          "message" => I18n.t('error.resource.id',  { resource: self.class.class_name, locale: :en }),
+          "message_to_purchaser" => I18n.t('error.resource.id_purchaser',  { locale: Conekta.locale.to_sym })
+        })
+        if Conekta.api_version == "2.0.0"
+          error_list = Conekta::ErrorList.new
+          error_list.details << exception
+          exception = error_list
+        end
+        raise exception
+      end
+      self.payee._url + self.class._url + "/" + id
+    end
+    def delete
+      self.delete_member('payee','destinations')
+    end
+  end
+end

data/lib/conekta/discount_line.rb

@@ -0,0 +1,32 @@
+module Conekta
+  class DiscountLine < Resource
+    include Conekta::Operations::Delete
+    include Conekta::Operations::Update
+    include Conekta::Operations::CustomAction
+
+    attr_accessor :code, :amount, :type, :parent_id
+
+    def _url
+      if (id.nil? || id.to_s.empty?)
+        exception = Error.new({
+          "message" => I18n.t('error.resource.id',  { resource: self.class.class_name, locale: :en }),
+          "message_to_purchaser" => I18n.t('error.resource.id_purchaser',  { locale: Conekta.locale.to_sym })
+        })
+
+        if Conekta.api_version == "2.0.0"
+          error_list = Conekta::ErrorList.new
+          error_list.details << exception
+          exception = error_list
+        end
+
+        raise exception
+      end
+
+      "#{self.order._url}#{self.class._url}/#{id}"
+    end
+
+    def delete
+      self.delete_member('order', 'discount_lines')
+    end
+  end
+end

data/lib/conekta/error.rb

@@ -1,49 +1,47 @@
 module Conekta
   class Error < Exception
-    attr_reader :message
-    attr_reader :message_to_purchaser
+    attr_reader :message, :message_to_purchaser, :param, :code
+    # NEW FIELDS
+    attr_reader :validation_error, :custom_message
+    # <b>DEPRECATED</b>.
     attr_reader :type
-    attr_reader :code
-    attr_reader :param
+    
 
-    def initialize(message=nil, message_to_purchaser=nil, type=nil, code=nil, param=nil)
-      @message = message
-      @message_to_purchaser = message_to_purchaser
-      @type = type
-      @code = code
-      @param = param
+    def initialize(options={})
+      @message = options["message"]
+      @message_to_purchaser = options["message_to_purchaser"]
+      @param = options["param"]
+      @code = options["code"]
+      @validation_error = options["validation_error"]
+      @validation_error = options["custom_message"]
+      @type = options["type"]
     end
     def class_name
       self.class.name.split('::')[-1]
     end
-    def self.error_handler(resp, code)
-      if resp.instance_of?(Hash)
-        @message = resp["message"] if resp.has_key?('message')
-        @message_to_purchaser = resp["message_to_purchaser"] if resp.has_key?('message_to_purchaser')
-        @type = resp["type"] if resp.has_key?('type')
-        @code = resp["code"] if resp.has_key?('code')
-        @param = resp["param"] if resp.has_key?('param')
-      end
-      if code == nil or code == 0 or code == nil or code == ""
-        raise NoConnectionError.new(
-          I18n.t('error.requestor.connection',  { base: Conekta.api_base, locale: :en }),
-          I18n.t('error.requestor.connection_purchaser',  { locale: Conekta.locale.to_sym }))
-      end
-      case code
-      when 400
-        raise MalformedRequestError.new(@message, @message_to_purchaser, @type, @code, @params)
-      when 401
-        raise AuthenticationError.new(@message, @message_to_purchaser, @type, @code, @params)
-      when 402
-        raise ProcessingError.new(@message, @message_to_purchaser, @type, @code, @params)
-      when 404
-        raise ResourceNotFoundError.new(@message, @message_to_purchaser, @type, @code, @params)
-      when 422
-        raise ParameterValidationError.new(@message, @message_to_purchaser, @type, @code, @params)
-      when 500
-        raise ApiError.new(@message, @message_to_purchaser, @type, @code, @params)
+    def self.error_handler(response, http_status)
+      if http_status.to_s.empty? || http_status == 0
+        NoConnectionError.new({
+          "message" => I18n.t('error.requestor.connection',  { base: Conekta.api_base, locale: :en }),
+          "message_to_purchaser" => I18n.t('error.requestor.connection_purchaser',  { locale: Conekta.locale.to_sym })
+          })
       else
-        raise Error.new(@message, @message_to_purchaser, @type, @code, @params)
+        case http_status
+        when 400
+          MalformedRequestError.new(response)
+        when 401
+          AuthenticationError.new(response)
+        when 402
+          ProcessingError.new(response)
+        when 404
+          ResourceNotFoundError.new(response)
+        when 422
+          ParameterValidationError.new(response)
+        when 500
+          ApiError.new(response)
+        else
+          Error.new(response)
+        end
       end
     end
   end

data/lib/conekta/error_list.rb

@@ -0,0 +1,33 @@
+module Conekta
+  class ErrorList < Exception
+    attr_accessor :details
+
+    def initialize
+      @details = []
+    end
+
+    def self.error_handler(response, http_status)
+      exception = nil
+      if response.instance_of?(Hash)
+        if response.has_key?("details")
+          error_list = ErrorList.new
+          response["details"].each do |error|
+            error_list.details << self.build_error(error, http_status)
+          end
+          error_list.details << self.build_error(nil, nil) if error_list.details.empty?
+          exception = error_list
+        end
+      end
+
+      exception ||= self.build_error(response, http_status)
+
+      raise exception
+    end
+
+    private
+
+    def self.build_error(response, http_status)
+      Error.error_handler(response, http_status)
+    end
+  end
+end

data/lib/conekta/event.rb

@@ -2,5 +2,8 @@ module Conekta
   class Event < Resource
     include Conekta::Operations::Where
     include Conekta::Operations::Find
+
+    attr_accessor :data, :livemode, :webhook_status, :created_at, :type
+
   end
-end
+end

data/lib/conekta/fiscal_entity.rb

@@ -0,0 +1,37 @@
+module Conekta
+  class FiscalEntity < Resource
+    include Conekta::Operations::Delete
+    include Conekta::Operations::Update
+    include Conekta::Operations::CustomAction
+
+    attr_accessor :tax_id, :company_name, :phone, :email, :created_at,
+                  :parent_id, :default
+
+    def _url
+      if (id.nil? || id.to_s.empty?)
+        exception = Error.new({
+                                "message" => I18n.t('error.resource.id',  { resource: self.class.class_name, locale: :en }),
+                                "message_to_purchaser" => I18n.t('error.resource.id_purchaser',  { locale: Conekta.locale.to_sym })
+                              })
+
+        if Conekta.api_version == "2.0.0"
+          error_list = Conekta::ErrorList.new
+          error_list.details << exception
+          exception = error_list
+        end
+
+        raise exception
+      end
+
+      self.send(parent)._url + "/fiscal_entities/" + id
+    end
+
+    def parent
+      self.respond_to?(:order) ? "order" : "customer"
+    end
+
+    def delete
+      self.delete_member(parent,'fiscal_entities')
+    end
+  end
+end

data/lib/conekta/line_item.rb

@@ -1,4 +1,34 @@
 module Conekta
   class LineItem < Resource
+    include Conekta::Operations::Delete
+    include Conekta::Operations::Update
+    include Conekta::Operations::CustomAction
+
+    attr_accessor :name, :description, :unit_price, :quantity,
+                  :sku, :shippable, :tags, :brand, :type,
+                  :parent_id
+
+    def _url
+      if (id.nil? || id.to_s.empty?)
+        exception = Error.new({
+          "message" => I18n.t('error.resource.id',  { resource: self.class.class_name, locale: :en }),
+          "message_to_purchaser" => I18n.t('error.resource.id_purchaser',  { locale: Conekta.locale.to_sym })
+        })
+
+        if Conekta.api_version == "2.0.0"
+          error_list = Conekta::ErrorList.new
+          error_list.details << exception
+          exception = error_list
+        end
+
+        raise exception
+      end
+
+      "#{self.order._url}#{self.class._url}/#{id}"
+    end
+
+    def delete
+      self.delete_member('order','line_items')
+    end
   end
 end

data/lib/conekta/list.rb

@@ -0,0 +1,59 @@
+module Conekta
+  class List < ConektaObject
+    attr_reader :elements_type, :params, :has_more, :total
+
+    def initialize(elements_type, params)
+      super()
+      @elements_type = elements_type
+      @params        = (params || {})
+      @total         = 0
+    end
+
+    def add_element(element)
+      element =
+        Conekta::Util.convert_to_conekta_object(element['object'], element)
+
+      self[@total]        = element
+      self.values[@total] = element
+      @total              = @total + 1
+
+      self
+    end
+
+    def next(options={})
+      if self.size > 0
+        @params["next"] = self.last.id
+      end
+
+      @params["previous"] = nil
+
+      move_cursor(options[:limit])
+    end
+
+    def previous(options={})
+      if self.size > 0
+        @params["previous"] = self.first.id
+      end
+
+      @params["next"] = nil
+
+      move_cursor(options[:limit])
+    end
+
+    def load_from(response)
+      @has_more       = response["has_more"]
+      @total          = response["total"]
+      self.map{|key, _| self.unset_key(key) }
+      super(response["data"])
+    end
+
+    private
+
+    def move_cursor(limit)
+      @params["limit"] = limit if !limit.nil? && !limit.to_s.empty?
+      _url = Util.types[@elements_type.downcase]._url
+      response = Requestor.new.request(:get, _url, @params)
+      self.load_from(response)
+    end
+  end
+end

data/lib/conekta/log.rb

@@ -2,5 +2,9 @@ module Conekta
   class Log < Resource
     include Conekta::Operations::Where
     include Conekta::Operations::Find
+
+    attr_accessor :method, :url, :status, :version, :ip_address, :related,
+                  :request_body, :response_body, :request_headers,
+                  :response_headers, :created_at, :query_string
   end
 end

data/lib/conekta/operations/create_member.rb

@@ -2,19 +2,28 @@ module Conekta
   module Operations
     module CreateMember
       def create_member(member, params)
-        _url = [self._url, member].join('/')
-        member = member.to_sym
+        _url     = [self._url, member].join('/')
+        member   = member.to_sym
         response = Requestor.new.request(:post, _url, params)
 
-        if self.method(member).call and self.method(member).call.class.class_name == "ConektaObject"
+        if self.send(member) &&
+           (self.send(member).class.class_name == "ConektaObject" ||
+            self.send(member).class.class_name == "List")
           arr = []
-          self.method(member).call.values.each do |_,v|
-            arr << v.to_hash
+
+          if self.send(member).class.class_name == "List"
+            self.send(member).add_element(response)
+          else
+            self.method(member).call.values.each do |_,v|
+              arr << v.to_hash
+            end
+
+            arr << response
+            self.send(member).load_from(arr)
+            self.load_from
           end
-          arr << response
-          self.method(member).call.load_from(arr)
-          self.load_from
-          instances = self.method(member).call
+
+          instances = self.send(member)
           instance = instances.last
         else
           instance = Util.types[member.to_s].new()
@@ -23,8 +32,9 @@ module Conekta
           self.set_val(member.to_sym, instance)
           self.load_from
         end
+
         instance
       end
     end
   end
-end
+end

data/lib/conekta/operations/custom_action.rb

@@ -2,7 +2,7 @@ module Conekta
   module Operations
     module CustomAction
       def custom_action(method, action=nil, params=nil)
-        _url = action ? [self._url, action].join('/') : self._url
+        _url     = action ? [self._url, action].join('/') : self._url
         response = Requestor.new.request(method, _url, params)
 
         self.load_from(response)

data/lib/conekta/operations/delete.rb

@@ -7,9 +7,11 @@ module Conekta
       end
       def delete_member(parent, member)
         self.custom_action(:delete, nil, nil)
+
         parent = parent.to_sym
         member = member.to_sym
-        obj = self.method(parent).call.method(member).call
+        obj    = self.method(parent).call.method(member).call
+
         if obj.class.class_name == "ConektaObject"
           self.method(parent).call.method(member).call.each do |(k, v)|
             if v.id == self.id

data/lib/conekta/operations/where.rb

@@ -1,11 +1,20 @@
 module Conekta
   module Operations
     module Where
+
+      def self.handle_type_of_paging(response, class_name, params)
+        if response.kind_of?(Hash) && response["object"] == "list"
+          List.new(class_name, params)
+        else
+          ConektaObject.new
+        end
+      end
+
       module ClassMethods
         def where(params=nil)
-          instance = ConektaObject.new
           _url = Util.types[self.class_name.downcase]._url
           response = Requestor.new.request(:get, _url, params)
+          instance = ::Conekta::Operations::Where.handle_type_of_paging(response, self.class_name, params)
           instance.load_from(response)
           instance
         end
@@ -18,4 +27,4 @@ module Conekta
       end
     end
   end
-end
+end

data/lib/conekta/order.rb

@@ -0,0 +1,90 @@
+module Conekta
+  class Order < Resource
+    include Conekta::Operations::Find
+    include Conekta::Operations::Where
+    include Conekta::Operations::Create
+    include Conekta::Operations::Update
+    include Conekta::Operations::CreateMember
+    include Conekta::Operations::CustomAction
+
+    attr_accessor :livemode, :amount, :status, :customer_id, :currency, :capture,
+                  :metadata, :created_at, :updated_at, :tax_lines, :line_items,
+                  :shipping_lines, :discount_lines, :shipping_contact, :fiscal_entity,
+                  :charges, :returns
+
+    def initialize(id=nil)
+      @id = id
+      @line_items ||= List.new("LineItem", {})
+      @tax_lines ||= List.new("TaxLine", {})
+      @shipping_lines ||= List.new("ShippingLine", {})
+      @discount_lines ||= List.new("DiscountLine", {})
+      @charges ||= List.new("Charge", {})
+      @returns ||= List.new("Return", {})
+      super(id)
+    end
+
+    def load_from(response = nil)
+      if response
+        super
+      end
+
+      order     = self
+      submodels = [:line_items, :tax_lines, :shipping_lines, :discount_lines,
+                   :charges, :returns]
+      create_submodels_lists(order, submodels)
+
+      if self.respond_to?(:fiscal_entity) && self.fiscal_entity
+        self.fiscal_entity.create_attr('order', order)
+      end
+    end
+
+    def create_line_item(params)
+      self.create_member('line_items', params)
+    end
+
+    def create_tax_line(params)
+      self.create_member('tax_lines', params)
+    end
+
+    def create_shipping_line(params)
+      self.create_member('shipping_lines', params)
+    end
+
+    def create_discount_line(params)
+      self.create_member('discount_lines', params)
+    end
+
+    def create_charge(params)
+      self.create_member('charges', params)
+    end
+
+    def create_return(params)
+      self.create_member('returns', params)
+    end
+
+    def create_fiscal_entity(params)
+      self.update(fiscal_entity: params).fiscal_entity
+    end
+
+    def create_shipping_contact(params)
+      self.update(shipping_contact: params).shipping_contact
+    end
+
+    def capture_order
+      custom_action(:put, 'capture')
+    end
+
+    private
+
+    def create_submodels_lists(order, submodels)
+      submodels.each do |submodel|
+        self.send(submodel).each do |k, v|
+          v.create_attr('order', order)
+
+          self.send(submodel).set_val(k,v)
+        end if self.respond_to?(submodel) && !self.send(submodel).nil?
+      end
+    end
+
+  end
+end