mercadopago-custom-checkout 0.1.1

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/mercadopago/core/client.rb

@@ -0,0 +1,70 @@
+module MercadoPago
+  module Core
+    class Client
+      attr_reader :public_key, :version
+      API_VERSION = "v1".freeze
+
+      # Creates an instance to make calls to the MercadoPago CustomCheckout API.
+      def initialize(public_key = nil, access_token = nil)
+        check_credentials!(public_key, access_token)
+
+        @access_token = access_token if access_token
+        @public_key = public_key if public_key
+        @gateway = MercadoPago::Core::Gateway
+        @version = API_VERSION
+      end
+
+      def call(resource, action, data = {})
+        request = request_for!(resource.to_sym, action.to_sym)
+        endpoint_path, payload = build_endpoint_path(request, data)
+
+        @gateway.send(request[:method], endpoint_path, payload)
+      end
+
+    private
+
+      def check_credentials!(public_key = nil, access_token = nil)
+        if (public_key.nil? || public_key.empty?) &&
+           (access_token.nil? || access_token.empty?)
+          raise ClientError.new('You must provide a :public_key or an :access_token')
+        end
+      end
+
+      def request_for!(resource, action)
+        unless MercadoPago::Core::ENDPOINTS.keys.include?(resource)
+          error = "There is no :#{resource} resource. The available ones are: " \
+                  "[:#{MercadoPago::Core::ENDPOINTS.keys.join(', :')}]"
+          raise ResourceError.new(error)
+        end
+        resource = MercadoPago::Core::ENDPOINTS[resource]
+
+        unless resource.keys.include?(action)
+          error = "There is no action called :#{action}. The available actions are: "\
+                  "[:#{resource.keys.join(', :')}]"
+          raise ResourceError.new(error)
+        end
+        resource[action]
+      end
+
+      def build_endpoint_path(request, data)
+        path = request[:endpoint] % data.merge(version: version)
+        ["#{path}?#{token_to_use(request)}", purged_data_keys(request[:endpoint], data)]
+      rescue KeyError
+        nil
+      end
+
+      def token_to_use(request)
+        token_name = request[:allowed_tokens].detect do |token|
+          instance_variable_get("@#{token}")
+        end
+        "#{token_name}=#{instance_variable_get("@#{token_name}")}" if token_name
+      end
+
+      def purged_data_keys(raw_endpoint, data)
+        keys = raw_endpoint.scan(/%{(\w*)}/).flatten.map(&:to_sym)
+        data.delete_if { |k,v| keys.include?(k) }
+      end
+    end
+
+  end
+end

data/lib/mercadopago/core/endpoints.rb

@@ -0,0 +1,134 @@
+module MercadoPago
+  module Core
+    ENDPOINTS = {
+      card_issuers: {
+        retrieve: {
+          endpoint: "/%{version}/payment_methods/card_issuers",
+          method: :get,
+          allowed_tokens: [:public_key]
+        }
+      },
+      card_tokens: {
+        create: {
+          endpoint: "/%{version}/card_tokens",
+          method: :post,
+          allowed_tokens: [:public_key]
+        },
+        retrieve: {
+          endpoint: "/%{version}/card_tokens/%{id}",
+          method: :get,
+          allowed_tokens: [:public_key]
+        },
+        update: {
+          endpoint: "/%{version}/card_tokens/%{id}",
+          method: :put,
+          allowed_tokens: [:public_key]
+        }
+      },
+      cards: {
+        all: {
+          endpoint: "/%{version}/customers/%{customer_id}/cards",
+          method: :get,
+          allowed_tokens: [:access_token]
+        },
+        create: {
+          endpoint: "/%{version}/customers/%{customer_id}/cards",
+          method: :post,
+          allowed_tokens: [:access_token]
+        },
+        retrieve: {
+          endpoint: "/%{version}/customers/%{customer_id}/cards/%{id}",
+          method: :get,
+          allowed_tokens: [:access_token]
+        },
+        update: {
+          endpoint: "/%{version}/customers/%{customer_id}/cards/%{id}",
+          method: :put,
+          allowed_tokens: [:access_token]
+        },
+        delete: {
+          endpoint: "/%{version}/customers/%{customer_id}/cards/%{id}",
+          method: :delete,
+          allowed_tokens: [:access_token]
+        }
+      },
+      customers: {
+        search: {
+          endpoint: "/%{version}/customers/search",
+          method: :get,
+          allowed_tokens: [:access_token]
+        },
+        create: {
+          endpoint: "/%{version}/customers",
+          method: :post,
+          allowed_tokens: [:access_token]
+        },
+        retrieve: {
+          endpoint: "/%{version}/customers/%{id}",
+          method: :get,
+          allowed_tokens: [:access_token]
+        },
+        update: {
+          endpoint: "/%{version}/customers/%{id}",
+          method: :put,
+          allowed_tokens: [:access_token]
+        },
+        delete: {
+          endpoint: "/%{version}/customers/%{id}",
+          method: :delete,
+          allowed_tokens: [:access_token]
+        }
+      },
+      identification_types:{
+        retrieve: {
+          endpoint: "/%{version}/identification_types",
+          method: :get,
+          allowed_tokens: [:public_key]
+        }
+      },
+      installments:{
+        retrieve: {
+          endpoint: "/%{version}/payment_methods/installments",
+          method: :get,
+          allowed_tokens: [:public_key]
+        }
+      },
+      payment_methods:{
+        retrieve: {
+          endpoint: "/%{version}/payment_methods",
+          method: :get,
+          allowed_tokens: [:public_key]
+        }
+      },
+      payments: {
+        search: {
+          endpoint: "/%{version}/payments/search",
+          method: :get,
+          allowed_tokens: [:access_token]
+        },
+        create: {
+          endpoint: "/%{version}/payments",
+          method: :post,
+          allowed_tokens: [:access_token]
+        },
+        retrieve: {
+          endpoint: "/%{version}/payments/%{id}",
+          method: :get,
+          allowed_tokens: [:access_token]
+        },
+        update: {
+          endpoint: "/%{version}/payments/%{id}",
+          method: :put,
+          allowed_tokens: [:access_token]
+        }
+      },
+      users: {
+        me: {
+          endpoint: "/users/me",
+          method: :get,
+          allowed_tokens: [:access_token]
+        }
+      }
+    }.freeze
+  end
+end

data/lib/mercadopago/core/errors.rb

@@ -0,0 +1,6 @@
+module MercadoPago
+  module Core
+    class ClientError < StandardError; end
+    class ResourceError < StandardError; end
+  end
+end

data/lib/mercadopago/core/gateway.rb

@@ -0,0 +1,84 @@
+module MercadoPago
+  module Core
+    module Gateway
+      extend self
+
+      MIME_JSON = 'application/json'.freeze
+      MERCADOPAGO_RUBY_SDK_VERSION = '0.3.4'.freeze
+      MERCADOPAGO_API_URL = 'https://api.mercadopago.com'.freeze
+
+      class Error < StandardError; end
+
+    private
+
+      def post(path, payload)
+        raise Error.new('No data given') if payload.nil? || payload.empty?
+
+        make_request(:post, path, payload)
+      end
+
+      def get(path, payload)
+        make_request(:get, path, payload)
+      end
+
+      def put(path, payload)
+        raise Error.new('No data given') if payload.nil? || payload.empty?
+
+        make_request(:put, path, payload)
+      end
+
+      def delete(path, payload)
+        make_request(:delete, path)
+      end
+
+      def headers(idempotency_key = nil)
+        {
+          'User-Agent' => "MercadoPago Ruby SDK v#{MERCADOPAGO_RUBY_SDK_VERSION}",
+          content_type: MIME_JSON,
+          accept: MIME_JSON
+        }.tap do |_hash|
+          _hash['X-Idempotency-Key'] = idempotency_key if idempotency_key
+        end
+      end
+
+      # Makes a HTTP request to the MercadoPago API.
+      #
+      # - type: the HTTP request type (:get, :post, :put, :delete).
+      # - path: the path of the API to be called.
+      # - json: the data to be trasmitted to the API.
+      def make_request(method, path, payload = {})
+        idempotency_key = payload.delete(:idempotency_key) || payload.delete('idempotency_key')
+        unless payload.empty?
+          payload = MultiJson.dump(payload) unless method == :get
+        end
+
+        response = connection(method).send(method) do |call|
+          call.url path
+          call.headers = headers( idempotency_key )
+          unless payload.empty?
+            if method == :get
+              call.params = call.params.merge(payload)
+            else
+              call.body = payload
+            end
+          end
+        end
+
+        MultiJson.load(response.body, symbolize_keys: true)
+      rescue Exception => e
+        if e.respond_to?(:response)
+          MultiJson.load(e.response, symbolize_keys: true)
+        else
+          raise e
+        end
+      end
+
+      def connection(method)
+        Faraday.new(MERCADOPAGO_API_URL, ssl: { verify: true }) do |faraday|
+          faraday.request(:url_encoded) if method == :get
+          faraday.adapter(Faraday.default_adapter)
+        end
+      end
+    end
+  end
+end

data/lib/mercadopago/custom_checkout.rb

@@ -0,0 +1,29 @@
+require 'faraday'
+require 'multi_json'
+
+# Core
+require "mercadopago/core/endpoints"
+require "mercadopago/core/errors"
+require "mercadopago/core/client"
+require "mercadopago/core/gateway"
+
+# CustomCheckout
+require "mercadopago/custom_checkout/account"
+require "mercadopago/custom_checkout/errors"
+require "mercadopago/custom_checkout/resource"
+require "mercadopago/custom_checkout/version"
+
+# Resources
+require "mercadopago/custom_checkout/card_issuer"
+require "mercadopago/custom_checkout/card_token"
+require "mercadopago/custom_checkout/identification_type"
+require "mercadopago/custom_checkout/payment_method"
+
+# require "mercadopago/custom_checkout/customer"
+# require "mercadopago/custom_checkout/payment_methods"
+# require "mercadopago/custom_checkout/payments"
+
+module MercadoPago
+  module CustomCheckout
+  end
+end

data/lib/mercadopago/custom_checkout/account.rb

@@ -0,0 +1,162 @@
+module MercadoPago
+  module CustomCheckout
+    class Account
+      attr_reader :client
+
+      def initialize(public_key: nil, access_token: nil)
+        @client = MercadoPago::Core::Client.new(public_key, access_token)
+      end
+
+      def inspect
+        "#<#{self.class.name} public_key:#{@client.public_key}>"
+      end
+
+      def valid?
+        me.key?(:id)
+      end
+
+      ## ---- Informative Methods ---- ##
+      # This methods allows to retrieve information only, there is no create/update
+      # just informative, about :payment_methods, or :card_issuers of a PaymentMethod
+      # etc.
+      # All of them are accesible with the :public_key.
+      def payment_methods
+        return @payment_methods unless @payment_methods.nil? || @payment_methods.empty?
+
+        response = @client.call(:payment_methods, :retrieve)
+        if response.is_a?(Array)
+          @payment_methods = response.map do |method|
+            PaymentMethod.new(self, method)
+          end
+        else
+          response
+        end
+      end
+
+      def payment_method(bin_number)
+        number = bin_number.gsub(/\s*/, '')[0,6]
+        payment_methods.select do |method|
+          bin = method.bin
+          bin &&
+          (number.match(bin[:pattern]) ? true : false) &&
+          (!bin[:exclusion_pattern] || !number.match(bin[:exclusion_pattern]))
+        end
+      end
+
+      def card_issuers_for(payment_method_id)
+        response = @client.call(:card_issuers, :retrieve, {
+          payment_method_id: payment_method_id
+        })
+        if response.is_a?(Array)
+          response.map do |issuer|
+            CardIssuer.new(issuer)
+          end
+        else
+          response
+        end
+      end
+
+      def installments_for(payment_method_id)
+        @client.call(:installments, :retrieve, {
+          payment_method_id: payment_method_id
+        })
+      end
+
+      def identification_types
+        return @identification_types unless @identification_types.nil?
+
+        response = @client.call(:identification_types, :retrieve)
+        if response.is_a?(Array)
+          @identification_types = response.map do |identification|
+            IdentificationType.new(identification)
+          end
+        else
+          if response[:status] == 404
+            @identification_types = []
+          else
+            response
+          end
+        end
+      end
+      ## ---- END - Informative Methods ---- ##
+
+
+      # The payload to create the card token is:
+      # {
+      #   cardNumber: '',
+      #   securityCode: '',
+      #   cardExpirationMonth: '',
+      #   cardExpirationYear: '',
+      #   cardholderName: '',
+      #   paymentMethodId: '',
+      #   docType: '', # Except for México
+      #   docNumber: '' # Except for México
+      # }
+      def create_card_token(**payload)
+        response = @client.call(:card_tokens, :create, payload)
+        if response.key?(:error)
+          response
+        else
+          CardToken.new(@client, response)
+        end
+      end
+
+      def create_payment(**payload)
+        @client.call(:payments, :create, payload)
+      end
+
+      def payment(payment_id)
+        @client.call(:payments, :retrieve, { id: payment_id })
+      end
+
+      def payments(**payload)
+        if response = @client.call(:payments, :search, payload)
+          response[:results]
+        else
+          []
+        end
+      end
+
+      def create_customer(**payload)
+        @client.call(:customers, :create, payload)
+      end
+
+      def add_card_to_customer(customer_id:, **payload)
+        @client.call(:cards, :create, payload.merge(customer_id: customer_id))
+      end
+
+      def customer(customer_id)
+        @client.call(:customers, :retrieve, { id: customer_id })
+      end
+
+      def customers(**payload)
+        if response = @client.call(:customers, :search, payload)
+          response[:results]
+        else
+          []
+        end
+      end
+
+      # # Card Tokens
+      # include MercadoPago::CustomCheckout::CardTokens
+
+      # # Customers
+      # include MercadoPago::CustomCheckout::Customers
+
+      # # Identification Types
+      # include MercadoPago::CustomCheckout::IdentificationTypes
+
+      # # Payment Methods
+      # include MercadoPago::CustomCheckout::PaymentMethods
+
+      # # Payments
+      # include MercadoPago::CustomCheckout::Payments
+
+      private
+
+      def me
+        @me ||= @client.call(:users, :me)
+      end
+    end
+  end
+end