conekta 0.3.3 → 0.3.5

data/lib/conekta/event.rb

@@ -1,5 +1,5 @@
 module Conekta
-  class Event < APIResource
-    include Conekta::APIOperations::List
+  class Event < Resource
+    include Conekta::Operations::Where
   end
 end

data/lib/conekta/operations/create.rb

@@ -0,0 +1,19 @@
+module Conekta
+  module Operations
+    module Create
+      module ClassMethods
+        def create(params)
+          requestor = Requestor.new
+          url = Util.types[self.class_name.downcase].url
+          response = requestor.request(:post, url, params)
+          instance = self.new
+          instance.load_from(response)
+          instance
+        end
+      end
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+    end
+  end
+end

data/lib/conekta/operations/create_member.rb

@@ -0,0 +1,30 @@
+module Conekta
+  module Operations
+    module CreateMember
+      def create_member(member, params)
+        url = self.url + "/" + member
+        member = member.to_sym
+        requestor = Requestor.new
+        response = requestor.request(:post, url, params)
+        if self.method(member).call and self.method(member).call.class.class_name == "ConektaObject"
+          arr = []
+          self.method(member).call.values.each do |(k,v)|
+            arr << v.to_hash
+          end
+          arr << response
+          self.method(member).call.load_from(arr)
+          self.load_from
+          instances = self.method(member).call
+          instance = instances.last
+        else
+          instance = Util.types[member.to_s].new()
+          instance.load_from(response)
+          self.create_attr(member.to_s, instance)
+          self.set_val(member.to_sym, instance)
+          self.load_from
+        end
+        instance
+      end
+    end
+  end
+end

data/lib/conekta/operations/custom_action.rb

@@ -0,0 +1,17 @@
+module Conekta
+  module Operations
+    module CustomAction
+      def custom_action(method, action=nil, params=nil)
+        requestor = Requestor.new
+        if action
+          url = self.url + "/" + action
+        else
+          url = self.url
+        end
+        response = requestor.request(method, url, params)
+        self.load_from(response)
+        self
+      end
+    end
+  end
+end

data/lib/conekta/operations/delete.rb

@@ -0,0 +1,43 @@
+module Conekta
+  module Operations
+    module Delete
+      def delete
+        self.custom_action(:delete, nil, nil)
+        self
+      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
+        if obj.class.class_name == "ConektaObject"
+          self.method(parent).call.method(member).call.each do |(k, v)|
+            if v.id == self.id
+              self.method(parent).call.method(member).call[k] = nil
+              # Shift hash array
+              shift = false
+              self.method(parent).call.method(member).call.each_with_index do |v,i|
+                if shift
+                  self.method(parent).call.method(member).call.set_val(i-1,v[1])
+                  self.method(parent).call.method(member).call[i-1] = v[1]
+                end
+                if v[1] == nil
+                  shift = true
+                end
+              end
+              n_members = self.method(parent).call.method(member).call.count
+              last_index = n_members - 1
+              # Remove last member because the hash array was shifted
+              self.method(parent).call.method(member).call.unset_key(last_index)
+              self.method(parent).call.method(member).call.delete(last_index)
+              break
+            end
+          end
+        else
+          self.create_attr(member.to_s, nil)
+        end
+        self
+      end
+    end
+  end
+end

data/lib/conekta/operations/find.rb

@@ -0,0 +1,28 @@
+module Conekta
+  module Operations
+    module Find
+      module ClassMethods
+        def find(id)
+          instance = self.new(id)
+          url = instance.url
+          requestor = Requestor.new
+          response = requestor.request(:get, url)
+          instance.load_from(response)
+          instance
+        end
+        # <b>DEPRECATED:</b> Please use <tt>find</tt> instead.
+        def retrieve(id)
+          instance = self.new(id)
+          url = instance.url
+          requestor = Requestor.new
+          response = requestor.request(:get, url)
+          instance.load_from(response)
+          instance
+        end
+      end
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+    end
+  end
+end

data/lib/conekta/operations/update.rb

@@ -0,0 +1,13 @@
+module Conekta
+  module Operations
+    module Update
+      def update(params)
+        requestor = Requestor.new
+        url = self.url
+        response = requestor.request(:put, url, params)
+        self.load_from(response)
+        self
+      end
+    end
+  end
+end

data/lib/conekta/operations/where.rb

@@ -0,0 +1,28 @@
+module Conekta
+  module Operations
+    module Where
+      module ClassMethods
+        def where(params=nil)
+          instance = ConektaObject.new
+          url = Util.types[self.class_name.downcase].url
+          requestor = Requestor.new
+          response = requestor.request(:get, url)
+          instance.load_from(response)
+          instance
+        end
+        # <b>DEPRECATED:</b> Please use <tt>where</tt> instead.
+        def all(params=nil)
+          instance = ConektaObject.new
+          url = Util.types[self.class_name.downcase].url
+          requestor = Requestor.new
+          response = requestor.request(:get, url)
+          instance.load_from(response)
+          instance
+        end
+      end
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+    end
+  end
+end

data/lib/conekta/payment_method.rb

@@ -0,0 +1,4 @@
+module Conekta
+  class PaymentMethod < Resource
+  end
+end

data/lib/conekta/plan.rb

@@ -1,8 +1,11 @@
 module Conekta
-  class Plan < APIResource
-    include Conekta::APIOperations::Create
-    include Conekta::APIOperations::Delete
-    include Conekta::APIOperations::List
-    include Conekta::APIOperations::Update
+  class Plan < 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
   end
 end

data/lib/conekta/requestor.rb

@@ -0,0 +1,55 @@
+require 'faraday'
+require 'base64'
+module Conekta
+  class Requestor
+    require 'sys/uname'
+    include Sys
+    attr_reader :api_key
+    def initialize()
+      @api_key = Conekta.api_key
+    end
+    def api_url(url='')
+      api_base = Conekta.api_base
+      api_base + url
+    end
+    def request(meth, url, params=nil)
+      url = self.api_url(url)
+      meth = meth.downcase
+      begin
+        conn = Faraday.new(:ssl => {
+            :ca_file      => File.dirname(__FILE__) + '/../ssl_data/ca-certificates.crt'
+          }) do |faraday|
+          faraday.adapter  Faraday.default_adapter
+        end
+        response = conn.method(meth).call do |req|
+          req.url url
+
+          req.headers['X-Conekta-Client-User-Agent'] = set_headers.to_json
+          req.headers['User-Agent'] = 'Conekta/v1 RubyBindings/' + Conekta::VERSION
+          req.headers['Accept'] = "application/vnd.conekta-v#{Conekta.api_version}+json"
+          req.headers['Authorization'] = "Basic #{ Base64.encode64("#{self.api_key}" + ':')}"
+          if params
+            req.headers['Content-Type'] = 'application/json'
+            req.body = params.to_json
+          end
+        end
+      rescue Exception => e
+        Error.error_handler(e.message, "")
+      end
+      if response.status != 200
+        Error.error_handler(JSON.parse(response.body), response.status)
+      end
+      return JSON.parse(response.body)
+    end
+    private
+    def set_headers
+      headers = {}
+      headers[:bindings_version] = Conekta::VERSION
+      headers[:lang] = 'ruby'
+      headers[:lang_version] = RUBY_VERSION
+      headers[:publisher] = 'conekta'
+      headers[:uname] = Uname.uname
+      return headers
+    end
+  end
+end

data/lib/conekta/resource.rb

@@ -0,0 +1,13 @@
+module Conekta
+  class Resource < ConektaObject
+    def self.url()
+      "/#{CGI.escape(self.class_name.downcase)}s"
+    end
+    def url
+      if id == nil || id == ""
+        raise Error.new('Could not get the id of ' + self.class.class_name + ' instance.')
+      end
+      self.class.url + "/" + id
+    end
+  end
+end

data/lib/conekta/subscription.rb

@@ -1,35 +1,21 @@
 module Conekta
-  class Subscription < APIResource
-    include Conekta::APIOperations::Update
-    include Conekta::APIOperations::ModifyMember
-
-    attr_accessor :customer
-    
-    def customer
-      @customer
-    end
-
-    def customer=(customer)
-      @customer = customer
-    end
-
-    def cancel
-      self.modify_member("subscription", "cancel")
+  class Subscription < Resource
+    include Conekta::Operations::Update
+    include Conekta::Operations::CustomAction
+    def url
+      if id == nil || id == ""
+        raise Error.new('Could not get the id of ' + self.class.class_name + ' instance.')
+      end
+      self.customer.url + "/subscription"
     end
-
     def pause
-      subscription = self.modify_member("subscription", "pause")
+      custom_action(:post, 'pause')
     end
-
     def resume
-      subscription = self.modify_member("subscription", "resume")
+      custom_action(:post, 'resume')
     end
-
-    def url
-      unless customer = self.customer
-        raise ParameterValidationError.new("Could not determine which URL to request: #{self.class} instance has invalid customer: #{customer.inspect}", 'customer')
-      end
-      "#{Conekta::Customer.url}/#{CGI.escape(customer.id)}/subscription"
+    def cancel
+      custom_action(:post, 'cancel')
     end
   end
 end

data/lib/conekta/token.rb

@@ -1,5 +1,6 @@
 module Conekta
-  class Token < APIResource
-    include Conekta::APIOperations::Create
+  class Token < Resource
+    include Conekta::Operations::Find
+    include Conekta::Operations::Create
   end
 end

data/lib/conekta/util.rb

@@ -1,103 +1,31 @@
 module Conekta
   module Util
-    def self.objects_to_ids(h)
-      case h
-      when APIResource
-        h.id
-      when Hash
-        res = {}
-        h.each { |k, v| res[k] = objects_to_ids(v) unless v.nil? }
-        res
-      when Array
-        h.map { |v| objects_to_ids(v) }
-      else
-        h
-      end
-    end
-
-    def self.object_classes
-      @object_classes ||= {
+    def self.types
+      @types ||= {
+        'bank_transfer_payment' => PaymentMethod,
+        'card_payment' => PaymentMethod,
+        'cash_payment' => PaymentMethod,
         'charge' => Charge,
-        'list' => ListObject,
+        'customer' => Customer,
         'card' => Card,
         'subscription' => Subscription,
-        'customer' => Customer,
-        'plan' => Plan
+        'plan' => Plan,
+        'token' => Token,
+        'event' => Event
       }
     end
-
-    def self.convert_to_conekta_object(resp, api_key)
-      case resp
-      when Array
-        resp.map { |i| convert_to_conekta_object(i, api_key) }
-      when Hash
-        # Try converting to a known object class.  If none available, fall back to generic ConektaObject
-        object_classes.fetch(resp[:object], ConektaObject).construct_from(resp, api_key)
-      else
-        resp
-      end
-    end
-
-    def self.file_readable(file)
-      # This is nominally equivalent to File.readable?, but that can
-      # report incorrect results on some more oddball filesystems
-      # (such as AFS)
-      begin
-        File.open(file) { |f| }
-      rescue
-        false
-      else
-        true
+    def self.convert_to_conekta_object(resp)
+      if resp.kind_of?(Hash) and resp.has_key?('object') and types[resp['object']]
+        instance = types[resp['object']].new()
+        instance.load_from(resp)
+        return instance
       end
-    end
-
-    def self.symbolize_names(object)
-      case object
-      when Hash
-        new = {}
-        object.each do |key, value|
-          key = (key.to_sym rescue key) || key
-          new[key] = symbolize_names(value)
-        end
-        new
-      when Array
-        object.map { |value| symbolize_names(value) }
-      else
-        object
-      end
-    end
-
-    def self.url_encode(key)
-      URI.escape(key.to_s, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))
-    end
-
-    def self.flatten_params(params, parent_key=nil)
-      result = []
-      params.each do |key, value|
-        calculated_key = parent_key ? "#{parent_key}[#{url_encode(key)}]" : url_encode(key)
-        if value.is_a?(Hash)
-          result += flatten_params(value, calculated_key)
-        elsif value.is_a?(Array)
-          result += flatten_params_array(value, calculated_key)
-        else
-          result << [calculated_key, value]
-        end
-      end
-      result
-    end
-
-    def self.flatten_params_array(value, calculated_key)
-      result = []
-      value.each do |elem|
-        if elem.is_a?(Hash)
-          result += flatten_params(elem, calculated_key)
-        elsif elem.is_a?(Array)
-          result += flatten_params_array(elem, calculated_key)
-        else
-          result << ["#{calculated_key}[]", elem]
-        end
+      if resp.respond_to? :each
+        instance = ConektaObject.new
+        instance.load_from(resp)
+        return instance
       end
-      result
+      return instance
     end
   end
 end