activemerchant 1.42.5 → 1.42.6

data/lib/active_merchant/billing/gateways/conekta.rb

@@ -37,7 +37,7 @@ module ActiveMerchant #:nodoc:
         commit(:post, "charges", post)
       end
 
-      def capture(identifier, money, options = {})
+      def capture(money, identifier, options = {})
         post = {}
 
         post[:order_id] = identifier
@@ -46,7 +46,7 @@ module ActiveMerchant #:nodoc:
         commit(:post, "charges/#{identifier}/capture", post)
       end
 
-      def refund(identifier, money, options)
+      def refund(money, identifier, options)
         post = {}
 
         post[:order_id] = identifier
@@ -77,8 +77,9 @@ module ActiveMerchant #:nodoc:
       private
 
       def add_order(post, money, options)
-        post[:description] = options[:description]
+        post[:description] = options[:description] || "Active Merchant Purchase"
         post[:reference_id] = options[:order_id]
+        post[:currency] = (options[:currency] || currency(money)).downcase
         post[:amount] = amount(money)
       end
 

data/lib/active_merchant/billing/gateways/litle.rb

@@ -283,18 +283,19 @@ module ActiveMerchant #:nodoc:
         exp_date    = exp_date_mo + exp_date_yr
 
         card_info = {
-            'type'              => cc_type,
-            'number'            => creditcard.number,
-            'expDate'           => exp_date,
-            'cardValidationNum' => creditcard.verification_value
+          'type'              => cc_type,
+          'number'            => creditcard.number,
+          'expDate'           => exp_date,
+          'cardValidationNum' => creditcard.verification_value
         }
 
         hash['card'] = card_info
         hash
       end
 
-      def create_capture_hash(money, authorization, options)
+      def create_capture_hash(money, authorization, options={})
         hash               = create_hash(money, options)
+        hash['partial']    = true if money
         hash['litleTxnId'] = authorization
         hash
       end
@@ -340,58 +341,63 @@ module ActiveMerchant #:nodoc:
 
         if options[:billing_address]
           bill_to_address = {
-              'name'         => options[:billing_address][:name],
-              'companyName'  => options[:billing_address][:company],
-              'addressLine1' => options[:billing_address][:address1],
-              'addressLine2' => options[:billing_address][:address2],
-              'city'         => options[:billing_address][:city],
-              'state'        => options[:billing_address][:state],
-              'zip'          => options[:billing_address][:zip],
-              'country'      => options[:billing_address][:country],
-              'email'        => options[:email],
-              'phone'        => options[:billing_address][:phone]
+            'name'         => options[:billing_address][:name],
+            'companyName'  => options[:billing_address][:company],
+            'addressLine1' => options[:billing_address][:address1],
+            'addressLine2' => options[:billing_address][:address2],
+            'city'         => options[:billing_address][:city],
+            'state'        => options[:billing_address][:state],
+            'zip'          => options[:billing_address][:zip],
+            'country'      => options[:billing_address][:country],
+            'email'        => options[:email],
+            'phone'        => options[:billing_address][:phone]
           }
         end
         if options[:shipping_address]
           ship_to_address = {
-              'name'         => options[:shipping_address][:name],
-              'companyName'  => options[:shipping_address][:company],
-              'addressLine1' => options[:shipping_address][:address1],
-              'addressLine2' => options[:shipping_address][:address2],
-              'city'         => options[:shipping_address][:city],
-              'state'        => options[:shipping_address][:state],
-              'zip'          => options[:shipping_address][:zip],
-              'country'      => options[:shipping_address][:country],
-              'email'        => options[:email],
-              'phone'        => options[:shipping_address][:phone]
+            'name'         => options[:shipping_address][:name],
+            'companyName'  => options[:shipping_address][:company],
+            'addressLine1' => options[:shipping_address][:address1],
+            'addressLine2' => options[:shipping_address][:address2],
+            'city'         => options[:shipping_address][:city],
+            'state'        => options[:shipping_address][:state],
+            'zip'          => options[:shipping_address][:zip],
+            'country'      => options[:shipping_address][:country],
+            'email'        => options[:email],
+            'phone'        => options[:shipping_address][:phone]
           }
         end
 
         hash = {
-            'billToAddress'  => bill_to_address,
-            'shipToAddress'  => ship_to_address,
-            'orderId'        => (options[:order_id] || @options[:order_id]),
-            'customerId'     => options[:customer],
-            'reportGroup'    => (options[:merchant] || @options[:merchant]),
-            'merchantId'     => (options[:merchant_id] || @options[:merchant_id]),
-            'orderSource'    => (options[:order_source] || 'ecommerce'),
-            'enhancedData'   => enhanced_data,
-            'fraudCheckType' => fraud_check_type,
-            'user'           => (options[:user] || @options[:user]),
-            'password'       => (options[:password] || @options[:password]),
-            'version'        => (options[:version] || @options[:version]),
-            'url'            => (options[:url] || url),
-            'proxy_addr'     => (options[:proxy_addr] || @options[:proxy_addr]),
-            'proxy_port'     => (options[:proxy_port] || @options[:proxy_port]),
-            'id'             => (options[:id] || options[:order_id] || @options[:order_id])
+          'billToAddress'  => bill_to_address,
+          'shipToAddress'  => ship_to_address,
+          'orderId'        => truncated_order_id(options),
+          'customerId'     => options[:customer],
+          'reportGroup'    => (options[:merchant] || @options[:merchant]),
+          'merchantId'     => (options[:merchant_id] || @options[:merchant_id]),
+          'orderSource'    => (options[:order_source] || 'ecommerce'),
+          'enhancedData'   => enhanced_data,
+          'fraudCheckType' => fraud_check_type,
+          'user'           => (options[:user] || @options[:user]),
+          'password'       => (options[:password] || @options[:password]),
+          'version'        => (options[:version] || @options[:version]),
+          'url'            => (options[:url] || url),
+          'proxy_addr'     => (options[:proxy_addr] || @options[:proxy_addr]),
+          'proxy_port'     => (options[:proxy_port] || @options[:proxy_port]),
+          'id'             => (options[:id] || options[:order_id] || @options[:order_id])
         }
 
-        if (!money.nil? && money.to_s.length > 0)
-          hash.merge!({ 'amount' => money })
-        end
+        hash.merge!('amount' => money) if(money && (money != ""))
+
         hash
       end
 
+      def truncated_order_id(options)
+        order_id = options[:order_id] || @options[:order_id]
+        return unless order_id
+        order_id[0..24]
+      end
+
       def fraud_result(authorization_response)
         if result = authorization_response['fraudResult']
           if result.key?('cardValidationResult')

data/lib/active_merchant/billing/gateways/maxipago.rb

@@ -0,0 +1,190 @@
+require 'nokogiri'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class MaxipagoGateway < Gateway
+      API_VERSION = '3.1.1.15'
+
+      self.live_url = 'https://api.maxipago.net/UniversalAPI/postXML'
+      self.test_url = 'https://testapi.maxipago.net/UniversalAPI/postXML'
+
+      self.supported_countries = ['BR']
+      self.default_currency = 'BRL'
+      self.money_format = :dollars
+      self.supported_cardtypes = [:visa, :master, :discover, :american_express, :diners_club]
+      self.homepage_url = 'http://www.maxipago.com/'
+      self.display_name = 'maxiPago!'
+
+      def initialize(options = {})
+        requires!(options, :login, :password)
+        super
+      end
+
+      def purchase(money, creditcard, options = {})
+        post = {}
+        add_aux_data(post, options)
+        add_amount(post, money)
+        add_creditcard(post, creditcard)
+        add_name(post, creditcard)
+        add_address(post, options)
+
+        commit(build_sale_request(post))
+      end
+
+      def authorize(money, creditcard, options = {})
+        post = {}
+        add_aux_data(post, options)
+        add_amount(post, money)
+        add_creditcard(post, creditcard)
+        add_name(post, creditcard)
+        add_address(post, options)
+
+        commit(build_sale_request(post, "auth"))
+      end
+
+      def capture(money, authorization, options = {})
+        post = {}
+        add_amount(post, money)
+        add_aux_data(post, options)
+        commit(build_capture_request(authorization, post))
+      end
+
+      private
+
+      def commit(request)
+        url = (test? ? self.test_url : self.live_url)
+        response = parse(ssl_post(url, request, 'Content-Type' => 'text/xml'))
+        Response.new(
+          success?(response),
+          message_from(response),
+          response,
+          test: test?,
+          authorization: response[:order_id]
+        )
+      end
+
+      def success?(response)
+        (response[:response_code] == '0')
+      end
+
+      def message_from(response)
+        return response[:error_message] if response[:error_message].present?
+        return response[:processor_message] if response[:processor_message].present?
+        return response[:response_message] if response[:response_message].present?
+        return (success?(response) ? 'success' : 'error')
+      end
+
+      def add_aux_data(post, options)
+        post[:processorID] = (test? ? 1 : 4) # test: 1, redecard: 2, cielo: 4
+        post[:referenceNum] = options[:order_id]
+      end
+
+      def add_amount(post, money)
+        post[:amount] = amount(money)
+      end
+
+      def add_creditcard(post, creditcard)
+        post[:card_number] = creditcard.number
+        post[:card_exp_month] = creditcard.month
+        post[:card_exp_year] = creditcard.year
+        post[:card_cvv] = creditcard.verification_value
+      end
+
+      def add_name(post, creditcard)
+        post[:billing_name] = creditcard.name
+      end
+
+      def add_address(post, options)
+        if(address = (options[:address] || options[:billing_address]))
+          post[:billing_address] = address[:address1]
+          post[:billing_address2] = address[:address2]
+          post[:billing_city] = address[:city]
+          post[:billing_state] = address[:state]
+          post[:billing_postalcode] = address[:zip]
+          post[:billing_country] = address[:country]
+          post[:billing_phone] = address[:phone]
+        end
+      end
+
+      def build_capture_request(authorization, params)
+        build_request(params) do |xml|
+          xml.capture! {
+            xml.orderID authorization
+            xml.referenceNum params[:referenceNum]
+            xml.payment {
+              xml.chargeTotal params[:amount]
+            }
+          }
+        end
+      end
+
+      def build_sale_request(params, action="sale")
+        build_request(params) do |xml|
+          xml.send(action) {
+            xml.processorID params[:processorID]
+            xml.fraudCheck 'N'
+            xml.referenceNum params[:referenceNum] # spree_order
+            xml.transactionDetail {
+              xml.payType {
+                xml.creditCard {
+                  xml.number params[:card_number]
+                  xml.expMonth params[:card_exp_month]
+                  xml.expYear params[:card_exp_year]
+                  xml.cvvNumber params[:card_cvv]
+                }
+              }
+            }
+            xml.payment {
+              xml.chargeTotal params[:amount]
+            }
+            xml.billing {
+              xml.name params[:billing_name]
+              xml.address params[:billing_address] if params[:billing_address].present?
+              xml.address2 params[:billing_address2] if params[:billing_address2].present?
+              xml.city params[:billing_city] if params[:billing_city].present?
+              xml.state params[:billing_state] if params[:billing_state].present?
+              xml.postalcode params[:billing_postalcode] if params[:billing_postalcode].present?
+              xml.country params[:billing_country] if params[:billing_country].present?
+              xml.phone params[:billing_phone] if params[:billing_phone].present?
+            }
+          }
+        end
+      end
+
+      def build_request(params)
+        builder = Nokogiri::XML::Builder.new(encoding: 'UTF-8') do |xml|
+          xml.send("transaction-request") {
+            xml.version API_VERSION
+            xml.verification {
+              xml.merchantId @options[:login]
+              xml.merchantKey @options[:password]
+            }
+            xml.order {
+              yield(xml)
+            }
+          }
+        end
+        builder.to_xml(indent: 2)
+      end
+
+      def parse(body)
+        xml = REXML::Document.new(body)
+
+        response = {}
+        xml.root.elements.to_a.each do |node|
+          parse_element(response, node)
+        end
+        response
+      end
+
+      def parse_element(response, node)
+        if node.has_elements?
+          node.elements.each{|element| parse_element(response, element) }
+        else
+          response[node.name.underscore.to_sym] = node.text
+        end
+      end
+    end
+  end
+end
+

data/lib/active_merchant/billing/gateways/ogone.rb

@@ -244,6 +244,8 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_payment_source(post, payment_source, options)
+        add_d3d(post, options) if options[:d3d]
+
         if payment_source.is_a?(String)
           add_alias(post, payment_source, options[:alias_operation])
           add_eci(post, options[:eci] || '9')
@@ -254,7 +256,6 @@ module ActiveMerchant #:nodoc:
           end
           add_alias(post, options[:billing_id], options[:alias_operation])
           add_eci(post, options[:eci] || '7')
-          add_d3d(post, options) if options[:d3d]
           add_creditcard(post, payment_source)
         end
       end

data/lib/active_merchant/billing/gateways/openpay.rb

@@ -0,0 +1,200 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class OpenpayGateway < Gateway
+      self.live_url = 'https://api.openpay.mx/v1/'
+      self.test_url = 'https://sandbox-api.openpay.mx/v1/'
+
+      self.supported_countries = ['MX']
+      self.supported_cardtypes = [:visa, :master, :american_express]
+      self.homepage_url = 'http://www.openpay.mx/'
+      self.display_name = 'Openpay'
+      self.default_currency = 'MXN'
+
+      # Instantiate a instance of OpenpayGateway by passing through your
+      # merchant id and private api key.
+      #
+      # === To obtain your own credentials
+      # 1. Visit http://openpay.mx
+      # 2. Sign up
+      # 3. Activate your account clicking on the email confirmation
+      def initialize(options = {})
+        requires!(options, :key, :merchant_id)
+        @api_key = options[:key]
+        @merchant_id = options[:merchant_id]
+        super
+      end
+
+      def purchase(money, creditcard, options = {})
+        post = create_post_for_auth_or_purchase(money, creditcard, options)
+        commit(:post, 'charges', post, options)
+      end
+
+      def authorize(money, creditcard, options = {})
+        post = create_post_for_auth_or_purchase(money, creditcard, options)
+        post[:capture] = false
+        commit(:post, 'charges', post, options)
+      end
+
+      def capture(money, authorization, options = {})
+        post = {}
+        post[:amount] = amount(money) if money
+        commit(:post, "charges/#{CGI.escape(authorization)}/capture", post, options)
+      end
+
+      def void(identification, options = {})
+        commit(:post, "charges/#{CGI.escape(identification)}/refund", nil, options)
+      end
+
+      def refund(money, identification, options = {})
+        post = {}
+        post[:description] = options[:description]
+        post[:amount] = amount(money)
+        commit(:post, "charges/#{CGI.escape(identification)}/refund", post, options)
+      end
+
+      def store(creditcard, options = {})
+        card_params = {}
+        add_creditcard(card_params, creditcard, options)
+        card = card_params[:card]
+
+        if options[:customer].present?
+          commit(:post, "customers/#{CGI.escape(options[:customer])}/cards", card, options)
+        else
+          requires!(options, :email, :name)
+          post = {}
+          post[:name] = options[:name]
+          post[:email] = options[:email]
+          MultiResponse.run(:first) do |r|
+            r.process { commit(:post, 'customers', post, options) }
+
+            if(r.success? && !r.params['id'].blank?)
+              customer_id = r.params['id']
+              r.process { commit(:post, "customers/#{customer_id}/cards", card, options) }
+            end
+          end
+        end
+      end
+
+      def unstore(customer_id, card_id = nil, options = {})
+        if card_id.nil?
+          commit(:delete, "customers/#{CGI.escape(customer_id)}", nil, options)
+        else
+          commit(:delete, "customers/#{CGI.escape(customer_id)}/cards/#{CGI.escape(card_id)}", nil, options)
+        end
+      end
+
+      private
+
+      def create_post_for_auth_or_purchase(money, creditcard, options)
+        post = {}
+        post[:amount] = amount(money)
+        post[:method] = 'card'
+        post[:description] = options[:description]
+        post[:order_id] = options[:order_id]
+        add_creditcard(post, creditcard, options)
+        post
+      end
+
+      def add_creditcard(post, creditcard, options)
+        if creditcard.kind_of?(String)
+          post[:source_id] = creditcard
+        elsif creditcard.respond_to?(:number)
+          card = {
+            card_number: creditcard.number,
+            expiration_month: "#{sprintf("%02d", creditcard.month)}",
+            expiration_year: "#{"#{creditcard.year}"[-2, 2]}",
+            cvv2: creditcard.verification_value,
+            holder_name: creditcard.name
+          }
+          add_address(card, options)
+          post[:card] = card
+        end
+      end
+
+      def add_address(card, options)
+        return unless card.kind_of?(Hash)
+        if address = (options[:billing_address] || options[:address])
+          card[:address] = {
+            line1: address[:address1],
+            line2: address[:address2],
+            line3: address[:company],
+            city: address[:city],
+            postal_code: address[:zip],
+            state: address[:state],
+            country_code: address[:country]
+          }
+        end
+      end
+
+      def headers(options = {})
+        @@ua ||= JSON.dump(
+          :bindings_version => ActiveMerchant::VERSION,
+          :lang => 'ruby',
+          :lang_version => "#{RUBY_VERSION} p#{RUBY_PATCHLEVEL} (#{RUBY_RELEASE_DATE})",
+          :platform => RUBY_PLATFORM,
+          :publisher => 'active_merchant'
+        )
+        {
+          "Content-Type" => "application/json",
+          "Authorization" => "Basic " + Base64.encode64(@api_key.to_s + ":").strip,
+          "User-Agent" => "Openpay/v1 ActiveMerchantBindings/#{ActiveMerchant::VERSION}",
+          "X-Openpay-Client-User-Agent" => @@ua
+        }
+      end
+
+      def parse(body)
+        return {} unless body
+        JSON.parse(body)
+      end
+
+      def commit(method, resource, parameters, options = {})
+        response = http_request(method, resource, parameters, options)
+        success = !error?(response)
+
+        Response.new(success,
+          (success ? response['error_code'] : response['description']),
+          response,
+          :test => test?,
+          :authorization => response['id']
+        )
+      end
+
+      def http_request(method, resource, parameters={}, options={})
+        url = (test? ? self.test_url : self.live_url) + @merchant_id + '/' + resource
+        raw_response = nil
+        begin
+          raw_response = ssl_request(method, url, (parameters ? parameters.to_json : nil), headers(options))
+          parse(raw_response)
+        rescue ResponseError => e
+          raw_response = e.response.body
+          response_error(raw_response)
+        rescue JSON::ParserError
+          json_error(raw_response)
+        end
+      end
+
+      def error?(response)
+        response.key?('error_code')
+      end
+
+      def response_error(raw_response)
+        begin
+          parse(raw_response)
+        rescue JSON::ParserError
+          json_error(raw_response)
+        end
+      end
+
+      def json_error(raw_response)
+        msg = 'Invalid response received from the Openpay API.  Please contact soporte@openpay.mx if you continue to receive this message.'
+        msg += "  (The raw response returned by the API was #{raw_response.inspect})"
+        {
+            'category' => 'request',
+            'error_code' => '9999',
+            'description' => msg
+        }
+      end
+    end
+  end
+end
+