solidus_conekta 1.1

data/lib/spree/conekta/client.rb

@@ -0,0 +1,36 @@
+module Spree::Conekta
+  module Client
+    CONEKTA_API = 'https://api.conekta.io/'
+
+    attr_accessor :auth_token
+
+    def post(params)
+      Oj.load connection.post(endpoint, Oj.dump(params)).body
+    end
+
+    def get
+      Oj.load connection.get(endpoint).body
+    end
+
+    def connection
+      Faraday.new(url: CONEKTA_API) do |faraday|
+        faraday.request :url_encoded
+
+        faraday.headers = headers
+        faraday.adapter :typhoeus
+        faraday.basic_auth(auth_token, nil)
+      end
+    end
+
+    def headers
+      {
+        'Accept' => ' application/vnd.conekta-v0.3.0+json',
+        'Content-type' => ' application/json'
+      }
+    end
+
+    def endpoint
+      raise 'Not Implemented'
+    end
+  end
+end

data/lib/spree/conekta/configuration.rb

@@ -0,0 +1,25 @@
+module Spree
+  module Conekta
+    
+    class << self
+      attr_accessor :configuration
+    end
+
+    def self.configure
+      self.configuration ||= Configuration.new
+      yield(configuration)
+    end
+
+    class Configuration
+      attr_accessor :installment_options, :installment_default
+
+      def installment_options
+        @installment_options ||= :installment_options
+      end
+
+      def installment_default
+        @installment_default ||= :installment_default
+      end
+    end
+  end
+end

data/lib/spree/conekta/credit_card.rb

@@ -0,0 +1,42 @@
+module Spree
+  module Conekta
+    class CreditCard
+      include Spree::Conekta::Client
+
+      attr_reader   :customer
+      attr_accessor :id, :brand, :last4
+
+      def self.create(customer, token, auth_token)
+        new(customer, token: token, auth_token: auth_token)
+      end
+
+      def self.build(customer, card, auth_token)
+        new(customer, card: card, auth_token: auth_token)
+      end
+
+      def initialize(customer, options)
+        @customer   = customer
+        @auth_token = options[:auth_token]
+        build_card(options[:card])   if options[:card]
+        create_card(options[:token]) if options[:token]
+      end
+
+      def endpoint
+        "customers/#{customer.id}/cards"
+      end
+
+      private
+
+      def build_card(card)
+        @id    = card['id']
+        @brand = card['brand']
+        @last4 = card['last4']
+      end
+
+      def create_card(token)
+        response = post(token: token)
+        build_card(response)
+      end
+    end
+  end
+end

data/lib/spree/conekta/credit_card_collection.rb

@@ -0,0 +1,36 @@
+module Spree
+  module Conekta
+    class CreditCardCollection
+      include Enumerable
+      include Spree::Conekta::Client
+
+      extend  Forwardable
+
+      def_instance_delegators :@cards, :each, :size
+
+      attr_reader :customer
+
+      def initialize(customer, options)
+        @customer   = customer
+        @auth_token = options[:auth_token]
+        @cards      = build_cards(get)
+      end
+
+      def add(token)
+        @cards << Spree::Conekta::CreditCard.create(customer, token, auth_token)
+      end
+
+      def endpoint
+        "customers/#{customer.id}/cards"
+      end
+
+      private
+
+      def build_cards(response)
+        response.map do |credit_card|
+          Spree::Conekta::CreditCard.build(customer, credit_card, auth_token: auth_token)
+        end
+      end
+    end
+  end
+end

data/lib/spree/conekta/customer.rb

@@ -0,0 +1,39 @@
+module Spree
+  module Conekta
+    class Customer
+      include Spree::Conekta::Client
+
+      attr_reader :user, :options, :credit_cards
+
+      def initialize(user, options = {})
+        @user         = user
+        @options      = options
+        @auth_token   = options[:auth_token]
+      end
+
+      def id
+        @id ||= user.gateway_customer_profile_id || create_new_client
+      end
+
+      def add_credit_card(token)
+        credit_cards.add(token)
+      end
+
+      def credit_cards
+        @credit_cards ||= Spree::Conekta::CreditCardCollection.new(self, auth_token: auth_token)
+      end
+
+      def endpoint
+        'customers'
+      end
+
+      private
+
+      def create_new_client
+        response = post(name: user.email, email: user.email)
+        user.update_column(:gateway_customer_profile_id, response['id']) if options[:persist]
+        response['id']
+      end
+    end
+  end
+end

data/lib/spree/conekta/exchange.rb

@@ -0,0 +1,30 @@
+module Spree::Conekta
+  class Exchange
+    
+    EXCHANCE_SERVICES = 'https://currency-api.appspot.com/api/'
+    
+    def initialize(amount, currency_from)
+      @amount = (amount.to_i)
+      @currency_from = currency_from
+      get_exchange_rate
+    end
+    
+    def amount_exchanged
+      @amount_exchanged ||= (@amount * @exchange_rate).round
+    end
+    
+    private
+    
+    def get_exchange_rate
+      response = JSON.parse(connection.get("#{@currency_from}/MXN.json?amount=#{@amount}").body)
+      @exchange_rate = response['rate'].nil? ? 0 : response['rate'].to_f
+    end
+    
+    def connection
+      Faraday.new(url: EXCHANCE_SERVICES) do |faraday|
+        faraday.request :url_encoded
+        faraday.adapter :typhoeus
+      end
+    end
+  end
+end

data/lib/spree/conekta/fake_response.rb

@@ -0,0 +1,10 @@
+module Spree::Conekta
+  class FakeResponse < ActiveMerchant::Billing::Response
+
+    def initialize
+      @success = true
+      @message = "Orden devuelta"
+      @params = {}
+    end
+  end
+end

data/lib/spree/conekta/monthly_payment_provider.rb

@@ -0,0 +1,26 @@
+module Spree::Conekta
+  class MonthlyPaymentProvider
+    attr_accessor :auth_token
+
+    attr_reader :options
+
+    def initialize(options = {})
+      @options       = options
+      @auth_token    = options[:auth_token]
+    end
+
+    def authorize(amount, source, gateway_options = {})
+      Response.new(parse_conekta_response(source.conekta_response), gateway_options)
+    end
+
+    def capture(amount, source, gateway_options = {})
+      Response.new({}, gateway_options)
+    end
+
+    private
+
+    def parse_conekta_response(response)
+      Oj.load response || '{}'
+    end
+  end
+end

data/lib/spree/conekta/payment_notification_handler.rb

@@ -0,0 +1,36 @@
+require 'celluloid'
+
+module Spree
+  module Conekta
+    class PaymentNotificationHandler
+      include Celluloid
+
+      attr_reader :params, :action, :order, :delay
+
+      ACTIONS = Hash.new(:failure!).merge! 'charge.paid' => :capture!
+
+      def initialize(params, delay = 60)
+        @params = params
+        @delay  = delay
+        @action = ACTIONS[params['type']]
+        @order  = params['data']['object']['reference_id'].split('-').first
+      end
+
+      def perform_action
+        after(delay) do
+          ActiveRecord::Base.connection_pool.with_connection do
+            payment.try(action)
+          end
+        end
+      end
+
+      private
+
+      def payment
+        ActiveRecord::Base.connection_pool.with_connection do
+          Spree::Payment.find_by_order_number(order)
+        end
+      end
+    end
+  end
+end

data/lib/spree/conekta/payment_source/bank.rb

@@ -0,0 +1,13 @@
+module Spree::Conekta::PaymentSource
+  module Bank
+    def request(common, method, gateway_options)
+      type = gateway_options[:type]
+      type ||= 'banorte'
+      common['bank'] = {
+          'type' => type
+      }
+    end
+
+    module_function :request
+  end
+end

data/lib/spree/conekta/payment_source/card.rb

@@ -0,0 +1,21 @@
+module Spree::Conekta::PaymentSource
+  module Card
+    def request(common, method, gateway_options)
+      common['card'] = method.gateway_payment_profile_id
+      common['monthly_installments'] = installments_number(method)
+    end
+
+    def self.customer_address(gateway_options)
+      customer = gateway_options[:billing_address]
+      customer['street1'] = customer.delete(:address1)
+      customer['street2'] = customer.delete(:address2)
+      customer
+    end
+
+    def installments_number(source)
+      [3,6,9,12].include?(source.installments_number) ? source.installments_number : nil
+    end
+
+    module_function :request, :installments_number
+  end
+end

data/lib/spree/conekta/payment_source/cash.rb

@@ -0,0 +1,13 @@
+module Spree::Conekta::PaymentSource
+  module Cash
+    def request(common, method, gateway_options)
+      type = gateway_options[:type]
+      type ||= 'oxxo'
+      common['cash'] = {
+        'type' => type
+      }
+    end
+
+    module_function :request
+  end
+end

data/lib/spree/conekta/provider.rb

@@ -0,0 +1,134 @@
+module Spree::Conekta
+  class Provider
+    include Spree::Conekta::Client
+
+    attr_accessor :auth_token, :source_method
+
+    attr_reader :options
+
+    PAYMENT_SOURCES = {
+      'card' => Spree::Conekta::PaymentSource::Card,
+      'banorte' => Spree::Conekta::PaymentSource::Bank,
+      'spei' => Spree::Conekta::PaymentSource::Bank,
+      'oxxo' => Spree::Conekta::PaymentSource::Cash
+    }
+
+    def initialize(options = {})
+      @options       = options
+      @auth_token    = options[:auth_token]
+      @source_method = payment_processor(options[:source_method])
+    end
+
+    def authorize(amount, method_params, gateway_options = {})
+      common = build_common(amount, gateway_options)
+      commit common, method_params, gateway_options.merge({type: @options[:source_method]})
+    end
+
+    alias_method :purchase, :authorize
+
+    def capture(amount, method_params, gateway_options = {})
+      Response.new({}, gateway_options)
+    end
+
+    def endpoint
+      'charges'
+    end
+
+    def payment_processor(source_name)
+      PAYMENT_SOURCES[source_name]
+    end
+
+    def supports?(brand)
+      %w(visa master).include? brand
+    end
+
+    def credit(credit_cents, response_code, gateway_options)
+      Spree::Conekta::FakeResponse.new
+    end
+
+    private
+
+    def commit(common, method_params, gateway_options)
+      source_method.request(common, method_params, gateway_options)
+      Spree::Conekta::Response.new post(common), source_method
+    end
+
+    def build_common(amount, gateway_params)
+      if source_method == Spree::Conekta::PaymentSource::Cash && gateway_params[:currency] != 'MXN'
+        return build_common_to_cash(amount, gateway_params)
+      else
+        {
+          'amount'               => amount,
+          'reference_id'         => gateway_params[:order_id],
+          'currency'             => gateway_params[:currency],
+          'description'          => gateway_params[:order_id],
+          'details'              => details(gateway_params)
+        }
+      end
+    end
+
+    def details(gateway_params)
+      {
+        'name'            => gateway_params[:billing_address][:name],
+        'email'           => gateway_params[:email],
+        'phone'           => gateway_params[:billing_address][:phone],
+        'billing_address' => billing_address(gateway_params),
+        'line_items'      => line_items(gateway_params),
+        'shipment'        => shipment(gateway_params)
+      }
+    end
+
+    def shipping_address(gateway_params)
+      {
+        'street1' => gateway_params[:shipping_address][:address1],
+        'street2' => gateway_params[:shipping_address][:address2],
+        'city'    => gateway_params[:shipping_address][:city],
+        'state'   => gateway_params[:shipping_address][:state],
+        'country' => gateway_params[:shipping_address][:country],
+        'zip'     => gateway_params[:shipping_address][:zip]
+      }
+    end
+
+    def billing_address(gateway_params)
+      {
+        'email'   => gateway_params[:email],
+        'street1' => gateway_params[:billing_address][:address1],
+        'street2' => gateway_params[:billing_address][:address2],
+        'city'    => gateway_params[:billing_address][:city],
+        'state'   => gateway_params[:billing_address][:state],
+        'country' => gateway_params[:billing_address][:country],
+        'zip'     => gateway_params[:billing_address][:zip]
+      }
+    end
+
+    def line_items(gateway_params)
+      order = Spree::Order.find_by_number(gateway_params[:order_id].split('-').first)
+      order.line_items.map(&:to_conekta)
+    end
+
+    def shipment(gateway_params)
+      order = Spree::Order.find_by_number(gateway_params[:order_id].split('-').first)
+      shipment = order.shipments[0]
+      carrier = (shipment.present? ? shipment.shipping_method.name : "other")
+      traking_id = (shipment.present? ? shipment.tracking : nil)
+      {
+        'price'   => gateway_params[:shipping],
+        'address' => shipping_address(gateway_params),
+        'service'     => "other",
+        'carrier'     => carrier,
+        'tracking_id'  => traking_id
+      }
+    end
+
+    def build_common_to_cash(amount, gateway_params)
+      amount_exchanged = Spree::Conekta::Exchange.new(amount, gateway_params[:currency]).amount_exchanged
+      {
+        'amount' => amount_exchanged,
+        'reference_id' => gateway_params[:order_id],
+        'currency' => "MXN",
+        'description' => gateway_params[:order_id],
+        'details' => details(gateway_params)
+      }
+    end
+  end
+end

data/lib/spree/conekta/response.rb

@@ -0,0 +1,14 @@
+module Spree::Conekta
+  class Response < ActiveMerchant::Billing::Response
+    attr_accessor :response, :source_method, :status
+
+    def initialize(response, source_method)
+      @success = !(response.eql?('null') || response.include?('type')) if response
+      @message = @success ? 'Ok' : response['message']
+      @params = response
+      @params['message'] = @success ? 'Ok' : response['message_to_purchaser']
+      @status = response['status']
+      @source_method = source_method
+    end
+  end
+end

data/lib/tasks/solidus_conekta_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :solidus_conekta do
+#   # Task goes here
+# end