conekta 0.3.3 → 0.3.5

data/lib/conekta/card.rb

@@ -1,40 +1,16 @@
 module Conekta
-  class Card < APIResource
-    include Conekta::APIOperations::Update
-
-    attr_accessor :customer
-    
-    def customer
-      @customer
-    end
-
-    def customer=(customer)
-      @customer = customer
-    end
-
-    def delete
-      response, api_key = Conekta.request(:delete, url, @api_key)
-      refresh_from(response, api_key)
-      deleted_card = self
-      i = 0
-      for card in self.customer.cards
-        if deleted_card.id == card.id
-          self.customer.cards.delete_at(i)
-          break
-        end
-        i = i + 1
-      end
-      deleted_card
-    end
-
+  class Card < Resource
+    include Conekta::Operations::Delete
+    include Conekta::Operations::Update
+    include Conekta::Operations::CustomAction
     def url
-      unless id = self['id']
-        raise ParameterValidationError.new("Could not determine which URL to request: #{self.class} instance has invalid ID: #{id.inspect}", 'id')
-      end
-      unless customer = self.customer
-        raise ParameterValidationError.new("Could not determine which URL to request: #{self.class} instance has invalid customer: #{customer.inspect}", 'customer')
+      if id == nil || id == ""
+        raise Error.new('Could not get the id of ' + self.class.class_name + ' instance.')
       end
-      "#{Conekta::Customer.url}/#{CGI.escape(customer.id)}/cards/#{CGI.escape(id)}"
+      self.customer.url + self.class.url + "/" + id
+    end
+    def delete
+      self.delete_member('customer','cards')
     end
   end
 end

data/lib/conekta/charge.rb

@@ -1,43 +1,19 @@
 module Conekta
-  class Charge < APIResource
-    include Conekta::APIOperations::List
-    include Conekta::APIOperations::Create
-    include Conekta::APIOperations::Update
-
-    def refund(params={})
-      response, api_key = Conekta.request(:post, refund_url, @api_key, params)
-      refresh_from(response, api_key)
-      self
+  class Charge < Resource
+    include Conekta::Operations::Find
+    include Conekta::Operations::Where
+    include Conekta::Operations::Create
+    include Conekta::Operations::CustomAction
+    def capture
+      custom_action(:post, 'capture', nil)
     end
-
-    def capture(params={})
-      response, api_key = Conekta.request(:post, capture_url, @api_key, params)
-      refresh_from(response, api_key)
-      self
-    end
-
-    def update_dispute(params)
-      response, api_key = Conekta.request(:post, dispute_url, @api_key, params)
-      refresh_from({ :dispute => response }, api_key, true)
-      dispute
-    end
-
-    private
-
-    def refund_url
-      url + '/refund'
-    end
-
-    def capture_url
-      url + '/capture'
-    end
-
-    def dispute_url
-      url + '/dispute'
-    end
-
-    def charges
-      Event.all({ :charge_id => id }, @api_key)
+    def refund(params=nil)
+      if params == nil
+        params = {"amount" => self.amount}
+      else
+        params = {"amount" => params}
+      end
+      custom_action(:post, 'refund', params)
     end
   end
 end

data/lib/conekta/conekta_object.rb

@@ -1,158 +1,86 @@
 module Conekta
-  class ConektaObject
-    include Enumerable
-
-    attr_accessor :api_key
-    @@permanent_attributes = Set.new([:api_key, :id])
-
-    # The default :id method is deprecated and isn't useful to us
-    if method_defined?(:id)
-      undef :id
+  class ConektaObject < Hash
+    attr_reader :id
+    attr_reader :values
+    def initialize(id=nil)
+      @values = Hash.new
+      @id = id.to_s
     end
-
-    def initialize(id=nil, api_key=nil)
-      # parameter overloading!
-      if id.kind_of?(Hash)
-        @retrieve_options = id.dup
-        @retrieve_options.delete(:id)
-        id = id[:id]
-      else
-        @retrieve_options = {}
-      end
-
-      @api_key = api_key
-      @values = {}
-      # This really belongs in APIResource, but not putting it there allows us
-      # to have a unified inspect method
-      @unsaved_values = Set.new
-      @transient_values = Set.new
-      self.id = id if id
+    def set_val(k,v)
+      @values[k] = v
     end
-
-    def self.construct_from(values, api_key=nil)
-      obj = self.new(values[:id], api_key)
-      obj.refresh_from(values, api_key)
-      obj
+    def unset_key(k)
+      @values.delete(k)
     end
-
-    def to_s(*args)
-      Conekta::JSON.dump(@values, :pretty => true)
+    def first
+      self[0]
     end
-
-    def inspect()
-      id_string = (self.respond_to?(:id) && !self.id.nil?) ? " id=#{self.id}" : ""
-      "#<#{self.class}:0x#{self.object_id.to_s(16)}#{id_string}> JSON: " + Conekta::JSON.dump(@values, :pretty => true)
+    def last
+      self[self.count - 1]
     end
-
-    def refresh_from(values, api_key, partial=false)
-      @api_key = api_key
-
-      removed = partial ? Set.new : Set.new(@values.keys - values.keys)
-      added = Set.new(values.keys - @values.keys)
-      # Wipe old state before setting new.  This is useful for e.g. updating a
-      # customer, where there is no persistent card parameter.  Mark those values
-      # which don't persist as transient
-
-      instance_eval do
-        remove_accessors(removed)
-        add_accessors(added)
-      end
-      removed.each do |k|
-        @values.delete(k)
-        @transient_values.add(k)
-        @unsaved_values.delete(k)
-      end
-      values.each do |k, v|
-        @values[k] = Util.convert_to_conekta_object(v, api_key)
-        @transient_values.delete(k)
-        @unsaved_values.delete(k)
+    def load_from(response)
+      if response.instance_of?(Array)
+        response.each_with_index do |v, i|
+          load_from_enumerable(i,v)
+        end
+      elsif response.kind_of?(Hash)
+        response = response.to_hash if response.class != Hash
+        response.each do |k,v|
+          load_from_enumerable(k,v)
+        end
       end
     end
-
-    def [](k)
-      @values[k.to_sym]
-    end
-
-    def []=(k, v)
-      send(:"#{k}=", v)
+    def to_s
+      @values.inspect
     end
-
-    def keys
-      @values.keys
-    end
-
-    def values
-      @values.values
-    end
-
-    def to_json(*a)
-      Conekta::JSON.dump(@values)
+    def inspect
+      if self.respond_to? :each
+        if self.class.class_name != "ConektaObject"
+          self.to_s
+        else
+          self.to_a.map{|x| x[1] }
+        end
+      else
+        super
+      end
     end
-
-    def as_json(*a)
-      @values.as_json(*a)
+    def self.class_name
+      self.name.split('::')[-1]
     end
-
-    def to_hash
-      @values
+    def class_name
+      self.class.name.split('::')[-1]
     end
-
-    def each(&blk)
-      @values.each(&blk)
+    def create_attr(k,v)
+        create_method( "#{k}=".to_sym ) { |val| 
+            instance_variable_set( "@" + k, val)
+        }
+        self.send("#{k}=".to_sym, v)
+        self.class.send(:remove_method, "#{k}=".to_sym)
+        create_method( k.to_sym ) { 
+            instance_variable_get( "@" + k ) 
+        }
     end
-
     protected
-
-    def metaclass
-      class << self; self; end
-    end
-
-    def remove_accessors(keys)
-      metaclass.instance_eval do
-        keys.each do |k|
-          next if @@permanent_attributes.include?(k)
-          k_eq = :"#{k}="
-          remove_method(k) if method_defined?(k)
-          remove_method(k_eq) if method_defined?(k_eq)
-        end
+    def to_hash
+      hash = Hash.new
+      self.values.each do |k,v|
+        hash[k] = v
       end
+      hash
     end
-
-    def add_accessors(keys)
-      metaclass.instance_eval do
-        keys.each do |k|
-          next if @@permanent_attributes.include?(k)
-          k_eq = :"#{k}="
-          define_method(k) { @values[k] }
-          define_method(k_eq) do |v|
-            @values[k] = v
-            @unsaved_values.add(k)
-          end
-        end
-      end
+    def create_method( name, &block )
+        self.class.send( :define_method, name, &block )
     end
-
-    def method_missing(name, *args)
-      # TODO: only allow setting in updateable classes.
-      if name.to_s.end_with?('=')
-        attr = name.to_s[0...-1].to_sym
-        @values[attr] = args[0]
-        @unsaved_values.add(attr)
-        add_accessors([attr])
-        return
-      else
-        return @values[name] if @values.has_key?(name)
+    def load_from_enumerable(k,v)
+      if v.respond_to? :each and !v.instance_of?(ConektaObject)
+        v = Conekta::Util.convert_to_conekta_object(v)
       end
-
-      begin
-        super
-      rescue NoMethodError => e
-        if @transient_values.include?(name)
-          raise NoMethodError.new(e.message + ".  HINT: The '#{name}' attribute was set in the past, however.  It was then wiped when refreshing the object with the result returned by Conekta's API, probably as a result of a save().  The attributes currently available on this object are: #{@values.keys.join(', ')}")
-        else
-          raise
-        end
+      if self.instance_of?(ConektaObject)
+        self[k] = v
+      else
+        self.create_attr(k,v)
       end
+      self.set_val(k,v)
     end
   end
 end

data/lib/conekta/customer.rb

@@ -1,34 +1,32 @@
 module Conekta
-  class Customer < APIResource
-    include Conekta::APIOperations::Create
-    include Conekta::APIOperations::Delete
-    include Conekta::APIOperations::Update
-    include Conekta::APIOperations::List
-    include Conekta::APIOperations::CreateMember
-
-    def refresh_from(values, api_key, partial=false)
-      super
+  class Customer < Resource
+    include Conekta::Operations::Find
+    include Conekta::Operations::Where
+    include Conekta::Operations::Create
+    include Conekta::Operations::Delete
+    include Conekta::Operations::Update
+    include Conekta::Operations::CustomAction
+    include Conekta::Operations::CreateMember
+    def load_from(response=nil)
+      if response
+        super
+      end
       customer = self
-      for i in 0..(customer.cards.count - 1)
-        customer.cards[i].customer = customer
+      self.cards.each do |k,v|
+        if !v.respond_to? :deleted or !v.deleted
+          v.create_attr('customer', customer)
+          self.cards.set_val(k,v)
+        end
       end
-      if customer.subscription
-        customer.subscription.customer = customer
+      if self.respond_to? :subscription and self.subscription
+         self.subscription.create_attr('customer', customer)
       end
     end
-
-    def create_subscription(params={})
-      subscription = create_member('subscription', params)
-      subscription.customer = self
-      self.subscription = subscription
-      subscription
+    def create_card(params)
+      self.create_member('cards', params)
     end
-
-    def create_card(params={})
-      card = create_member('cards', params)
-      card.customer = self
-      self.cards << card
-      card
+    def create_subscription(params)
+      self.create_member('subscription', params)
     end
   end
 end

data/lib/conekta/error.rb

@@ -0,0 +1,65 @@
+module Conekta
+  class Error < Exception
+    attr_reader :message
+    attr_reader :type
+    attr_reader :code
+    attr_reader :param
+
+    def initialize(message=nil, type=nil, code=nil, param=nil)
+      @message = message
+      @type = type
+      @code = code
+      @param = param
+    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')
+        @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("Could not connect to #{Conekta.api_base}", @type, @code, @param)
+      end
+      case code
+      when 400
+				raise MalformedRequestError.new(@message, @type, @code, @params)
+			when 401
+				raise AuthenticationError.new(@message, @type, @code, @params)
+			when 402
+				raise ProcessingError.new(@message, @type, @code, @params)
+			when 404
+				raise ResourceNotFoundError.new(@message, @type, @code, @params)
+			when 422
+				raise ParameterValidationError.new(@message, @type, @code, @params)
+			when 500
+				raise ApiError.new(@message, @type, @code, @params)
+			else
+				raise Error.new(@message, @type, @code, @params)
+      end
+    end
+  end
+  class ApiError < Error		
+	end
+	
+	class NoConnectionError < Error 
+	end
+
+	class AuthenticationError < Error 
+	end
+
+	class ParameterValidationError < Error 
+	end
+
+	class ProcessingError < Error 
+	end
+
+	class ResourceNotFoundError < Error 
+	end
+
+	class MalformedRequestError < Error 
+	end
+end