activemerchant 1.42.6 → 1.90.0

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

@@ -4,7 +4,7 @@ module ActiveMerchant #:nodoc:
       self.live_url = 'https://api.conekta.io/'
 
       self.supported_countries = ['MX']
-      self.supported_cardtypes = [:visa, :master]
+      self.supported_cardtypes = [:visa, :master, :american_express, :carnet]
       self.homepage_url = 'https://conekta.io/'
       self.display_name = 'Conekta Gateway'
       self.money_format = :cents
@@ -12,7 +12,7 @@ module ActiveMerchant #:nodoc:
 
       def initialize(options = {})
         requires!(options, :key)
-        options[:version] ||= '0.2.0'
+        options[:version] ||= '1.0.0'
         super
       end
 
@@ -23,7 +23,7 @@ module ActiveMerchant #:nodoc:
         add_payment_source(post, payment_source, options)
         add_details_data(post, options)
 
-        commit(:post, 'charges', post)
+        commit(:post, 'charges', post, options)
       end
 
       def authorize(money, payment_source, options = {})
@@ -34,7 +34,7 @@ module ActiveMerchant #:nodoc:
         add_details_data(post, options)
 
         post[:capture] = false
-        commit(:post, "charges", post)
+        commit(:post, 'charges', post, options)
       end
 
       def capture(money, identifier, options = {})
@@ -43,7 +43,7 @@ module ActiveMerchant #:nodoc:
         post[:order_id] = identifier
         add_order(post, money, options)
 
-        commit(:post, "charges/#{identifier}/capture", post)
+        commit(:post, "charges/#{identifier}/capture", post, options)
       end
 
       def refund(money, identifier, options)
@@ -52,71 +52,69 @@ module ActiveMerchant #:nodoc:
         post[:order_id] = identifier
         add_order(post, money, options)
 
-        commit(:post, "charges/#{identifier}/refund", post)
+        commit(:post, "charges/#{identifier}/refund", post, options)
       end
 
-      def store(creditcard, options = {})
+      def void(identifier, options = {})
         post = {}
-        add_payment_source(post, creditcard, options)
-        post[:name] = options[:name]
-        post[:email] = options[:email]
-
-        path = if options[:customer]
-          "customers/#{CGI.escape(options[:customer])}"
-        else
-          'customers'
-        end
+        commit(:post, "charges/#{identifier}/void", post, options)
+      end
 
-        commit(:post, path, post)
+      def supports_scrubbing
+        true
       end
 
-      def unstore(customer_id, options = {})
-        commit(:delete, "customers/#{CGI.escape(customer_id)}", nil)
+      def scrub(transcript)
+        transcript.
+          gsub(%r((Authorization: Basic )\w+), '\1[FILTERED]').
+          gsub(%r((&?card%5Bnumber%5D=)[^&]*)i, '\1[FILTERED]').
+          gsub(%r((&?card%5Bcvc%5D=)[^&]*)i, '\1[FILTERED]')
       end
 
       private
 
       def add_order(post, money, options)
-        post[:description] = options[:description] || "Active Merchant Purchase"
-        post[:reference_id] = options[:order_id]
+        post[:description] = options[:description] || 'Active Merchant Purchase'
+        post[:reference_id] = options[:order_id] if options[:order_id]
         post[:currency] = (options[:currency] || currency(money)).downcase
+        post[:monthly_installments] = options[:monthly_installments] if options[:monthly_installments]
         post[:amount] = amount(money)
       end
 
       def add_details_data(post, options)
         details = {}
-        details[:name] = options[:customer]
-        details[:email] = options[:email]
-        details[:phone] = options[:phone]
-        details[:device_fingerprint] = options[:device_fingerprint]
-        details[:ip] = options[:ip]
+        details[:name] = options[:customer] || (options[:billing_address][:name] if options[:billing_address])
+        details[:phone] = options[:phone] || (options[:billing_address][:phone] if options[:billing_address])
+        details[:email] = options[:email] if options[:email]
+        details[:ip] = options[:ip] if options[:ip]
         add_billing_address(details, options)
         add_line_items(details, options)
         add_shipment(details, options)
-
         post[:details] = details
+        post[:device_fingerprint] = options[:device_fingerprint] if options[:device_fingerprint]
       end
 
       def add_shipment(post, options)
         shipment = {}
-        shipment[:carrier] = options[:carrier]
-        shipment[:service] = options[:service]
-        shipment[:tracking_number] = options[:tracking_number]
-        shipment[:price] = options[:price]
+        shipment[:carrier] = options[:carrier] if options[:carrier]
+        shipment[:service] = options[:service] if options[:service]
+        shipment[:tracking_number] = options[:tracking_number] if options[:tracking_number]
+        shipment[:price] = options[:price] if options[:price]
         add_shipment_address(shipment, options)
         post[:shipment] = shipment
       end
 
       def add_shipment_address(post, options)
-        address = {}
-        address[:street1] = options[:address1]
-        address[:street2] = options[:address2]
-        address[:street3] = options[:address3]
-        address[:city] = options[:city]
-        address[:state] = options[:state]
-        address[:country] = options[:country]
-        address[:zip] = options[:zip]
-        post[:address] = address
+        if(address = options[:shipping_address])
+          post[:address] = {}
+          post[:address][:street1] = address[:address1] if address[:address1]
+          post[:address][:street2] = address[:address2] if address[:address2]
+          post[:address][:street3] = address[:address3] if address[:address3]
+          post[:address][:city] = address[:city] if address[:city]
+          post[:address][:state] = address[:state] if address[:state]
+          post[:address][:country] = address[:country] if address[:country]
+          post[:address][:zip] = address[:zip] if address[:zip]
+        end
       end
 
       def add_line_items(post, options)
@@ -126,45 +124,46 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_billing_address(post, options)
-        address = {}
-        address[:street1] = options[:address1]
-        address[:street2] = options[:address2]
-        address[:street3] = options[:address3]
-        address[:city] = options[:city]
-        address[:state] = options[:state]
-        address[:country] = options[:country]
-        address[:zip] = options[:zip]
-        address[:company_name] = options[:company_name]
-        address[:tax_id] = options[:tax_id]
-        address[:name] = options[:name]
-        address[:phone] = options[:phone]
-        address[:email] = options[:email]
-        post[:billing_address] = address
+        if(address = (options[:billing_address] || options[:address]))
+          post[:billing_address] = {}
+          post[:billing_address][:street1] = address[:address1] if address[:address1]
+          post[:billing_address][:street2] = address[:address2] if address[:address2]
+          post[:billing_address][:street3] = address[:address3] if address[:address3]
+          post[:billing_address][:city] = address[:city] if address[:city]
+          post[:billing_address][:state] = address[:state] if address[:state]
+          post[:billing_address][:country] = address[:country] if address[:country]
+          post[:billing_address][:zip] = address[:zip] if address[:zip]
+          post[:billing_address][:company_name] = address[:company_name] if address[:company_name]
+          post[:billing_address][:tax_id] = address[:tax_id] if address[:tax_id]
+          post[:billing_address][:name] = address[:name] if address[:name]
+          post[:billing_address][:phone] = address[:phone] if address[:phone]
+          post[:billing_address][:email] = address[:email] if address[:email]
+        end
       end
 
       def add_address(post, options)
-        address = {}
-        address[:street1] = options[:address1]
-        address[:street2] = options[:address2]
-        address[:street3] = options[:address3]
-        address[:city] = options[:city]
-        address[:state] = options[:state]
-        address[:country] = options[:country]
-        address[:zip] = options[:zip]
-        post[:address] = address
+        if(address = (options[:billing_address] || options[:address]))
+          post[:address] = {}
+          post[:address][:street1] = address[:address1] if address[:address1]
+          post[:address][:street2] = address[:address2] if address[:address2]
+          post[:address][:street3] = address[:address3] if address[:address3]
+          post[:address][:city] = address[:city] if address[:city]
+          post[:address][:state] = address[:state] if address[:state]
+          post[:address][:country] = address[:country] if address[:country]
+          post[:address][:zip] = address[:zip] if address[:zip]
+        end
       end
 
       def add_payment_source(post, payment_source, options)
         if payment_source.kind_of?(String)
           post[:card] = payment_source
         elsif payment_source.respond_to?(:number)
-          card = {}
-          card[:name] = payment_source.name
-          card[:cvc] = payment_source.verification_value
-          card[:number] = payment_source.number
-          card[:exp_month] = "#{sprintf("%02d", payment_source.month)}"
-          card[:exp_year] = "#{"#{payment_source.year}"[-2, 2]}"
-          post[:card] = card
+          post[:card] = {}
+          post[:card][:name] = payment_source.name
+          post[:card][:cvc] = payment_source.verification_value
+          post[:card][:number] = payment_source.number
+          post[:card][:exp_month] = sprintf('%02d', payment_source.month)
+          post[:card][:exp_year] = payment_source.year.to_s[-2, 2]
           add_address(post[:card], options)
         end
       end
@@ -174,30 +173,28 @@ module ActiveMerchant #:nodoc:
         JSON.parse(body)
       end
 
-      def headers(meta)
-        @@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'
-        })
-
+      def headers(options)
         {
-          "Accept" => "application/vnd.conekta-v#{options[:version]}+json",
-          "Authorization" => "Basic " + Base64.encode64("#{options[:key]}:"),
-          "RaiseHtmlError" => "false",
-          "User-Agent" => "Conekta ActiveMerchantBindings/#{ActiveMerchant::VERSION}",
-          "X-Conekta-Client-User-Agent" => @@ua,
-          "X-Conekta-Client-User-Metadata" => meta.to_json
+          'Accept' => "application/vnd.conekta-v#{@options[:version]}+json",
+          'Accept-Language' => 'es',
+          'Authorization' => 'Basic ' + Base64.encode64("#{@options[:key]}:"),
+          'RaiseHtmlError' => 'false',
+          'Conekta-Client-User-Agent' => {'agent'=>"Conekta ActiveMerchantBindings/#{ActiveMerchant::VERSION}"}.to_json,
+          'X-Conekta-Client-User-Agent' => conekta_client_user_agent(options),
+          'X-Conekta-Client-User-Metadata' => options[:meta].to_json
         }
       end
 
+      def conekta_client_user_agent(options)
+        return user_agent unless options[:application]
+        JSON.dump(JSON.parse(user_agent).merge!({application: options[:application]}))
+      end
+
       def commit(method, url, parameters, options = {})
         success = false
         begin
-          raw_response = parse(ssl_request(method, live_url + url, (parameters ? parameters.to_query : nil), headers(options[:meta])))
-          success = (raw_response.key?("object") && (raw_response["object"] != "error"))
+          raw_response = parse(ssl_request(method, live_url + url, (parameters ? parameters.to_query : nil), headers(options)))
+          success = (raw_response.key?('object') && (raw_response['object'] != 'error'))
         rescue ResponseError => e
           raw_response = response_error(e.response.body)
         rescue JSON::ParserError
@@ -206,29 +203,26 @@ module ActiveMerchant #:nodoc:
 
         Response.new(
           success,
-          raw_response["message"],
+          raw_response['message_to_purchaser'],
           raw_response,
-          :test => test?,
-          :authorization => raw_response["id"]
+          test: test?,
+          authorization: raw_response['id']
         )
       end
 
       def response_error(raw_response)
-        begin
-          parse(raw_response)
-        rescue JSON::ParserError
-          json_error(raw_response)
-        end
+        parse(raw_response)
+      rescue JSON::ParserError
+        json_error(raw_response)
       end
 
       def json_error(raw_response)
         msg = 'Invalid response received from the Conekta API.'
         msg += "  (The raw response returned by the API was #{raw_response.inspect})"
         {
-          "message" => msg
+          'message' => msg
         }
       end
     end
   end
 end
-

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

@@ -0,0 +1,271 @@
+require 'nokogiri'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class CreditcallGateway < Gateway
+      include Empty
+
+      self.test_url = 'https://test.cardeasexml.com/generic.cex'
+      self.live_url = 'https://live.cardeasexml.com/generic.cex'
+
+      self.supported_countries = ['US']
+      self.default_currency = 'USD'
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+
+      self.homepage_url = 'https://www.creditcall.com'
+      self.display_name = 'Creditcall'
+
+      CVV_CODE = {
+        'matched' => 'M',
+        'notmatched' => 'N',
+        'notchecked' => 'P',
+        'partialmatch' => 'N'
+      }
+
+      AVS_CODE = {
+        'matched;matched' => 'D',
+        'matched;notchecked' =>'B',
+        'matched;notmatched' => 'A',
+        'matched;partialmatch' => 'A',
+        'notchecked;matched' => 'P',
+        'notchecked;notchecked' =>'I',
+        'notchecked;notmatched' => 'I',
+        'notchecked;partialmatch' => 'I',
+        'notmatched;matched' => 'W',
+        'notmatched;notchecked' =>'C',
+        'notmatched;notmatched' => 'C',
+        'notmatched;partialmatch' => 'C',
+        'partialmatched;matched' => 'W',
+        'partialmatched;notchecked' =>'C',
+        'partialmatched;notmatched' => 'C',
+        'partialmatched;partialmatch' => 'C'
+      }
+
+      def initialize(options={})
+        requires!(options, :terminal_id, :transaction_key)
+        super
+      end
+
+      def purchase(money, payment_method, options={})
+        multi_response = MultiResponse.run do |r|
+          r.process { authorize(money, payment_method, options) }
+          r.process { capture(money, r.authorization, options) }
+        end
+
+        merged_params = multi_response.responses.map(&:params).reduce({}, :merge)
+
+        Response.new(
+          multi_response.primary_response.success?,
+          multi_response.primary_response.message,
+          merged_params,
+          authorization: multi_response.responses.first.authorization,
+          avs_result: AVSResult.new(code: avs_result_code_from(merged_params)),
+          cvv_result: CVVResult.new(cvv_result_code_from(merged_params)),
+          error_code: error_result_code_from(merged_params),
+          test: test?
+        )
+      end
+
+      def authorize(money, payment_method, options={})
+        request = build_xml_request do |xml|
+          add_transaction_details(xml, money, nil, 'Auth', options)
+          add_terminal_details(xml, options)
+          add_card_details(xml, payment_method, options)
+        end
+
+        commit(request)
+      end
+
+      def capture(money, authorization, options={})
+        request = build_xml_request do |xml|
+          add_transaction_details(xml, money, authorization, 'Conf', options)
+          add_terminal_details(xml, options)
+        end
+
+        commit(request)
+      end
+
+      def refund(money, authorization, options={})
+        request = build_xml_request do |xml|
+          add_transaction_details(xml, money, authorization, 'Refund', options)
+          add_terminal_details(xml, options)
+        end
+
+        commit(request)
+      end
+
+      def void(authorization, options={})
+        request = build_xml_request do |xml|
+          add_transaction_details(xml, nil, authorization, 'Void', options)
+          add_terminal_details(xml, options)
+        end
+
+        commit(request)
+      end
+
+      def verify(credit_card, options={})
+        MultiResponse.run(:use_first_response) do |r|
+          r.process { authorize(100, credit_card, options) }
+          r.process(:ignore_result) { void(r.authorization, options) }
+        end
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((<TransactionKey>).+?(</TransactionKey>))i, '\1[FILTERED]\2').
+          gsub(%r((<PAN>).+?(</PAN>))i, '\1[FILTERED]\2').
+          gsub(%r((<CSC>).+?(</CSC>))i, '\1[FILTERED]\2')
+      end
+
+      private
+
+      def avs_result_code_from(params)
+        AVS_CODE["#{params['Address']};#{params['Zip']}"]
+      end
+
+      def cvv_result_code_from(params)
+        CVV_CODE[params['CSC']]
+      end
+
+      def error_result_code_from(params)
+        params['ErrorCode']
+      end
+
+      def build_xml_request
+        builder = Nokogiri::XML::Builder.new do |xml|
+          xml.Request(type: 'CardEaseXML', version: '1.0.0') do
+            yield(xml)
+          end
+        end
+        builder.to_xml
+      end
+
+      def add_transaction_details(xml, amount, authorization, type, options={})
+        xml.TransactionDetails do
+          xml.MessageType type
+          xml.Amount(unit: 'Minor') { xml.text(amount) } if amount
+          xml.CardEaseReference authorization if authorization
+          xml.VoidReason '01' if type == 'Void'
+        end
+      end
+
+      def add_terminal_details(xml, options={})
+        xml.TerminalDetails do
+          xml.TerminalID @options[:terminal_id]
+          xml.TransactionKey @options[:transaction_key]
+          xml.Software(version: 'SoftwareVersion') { xml.text('SoftwareName') }
+        end
+      end
+
+      def add_card_details(xml, payment_method, options={})
+        xml.CardDetails do
+          xml.Manual(type: manual_type(options)) do
+            xml.PAN payment_method.number
+            xml.ExpiryDate exp_date(payment_method)
+            xml.CSC payment_method.verification_value unless empty?(payment_method.verification_value)
+          end
+
+          add_additional_verification(xml, options)
+        end
+      end
+
+      def add_additional_verification(xml, options)
+        return unless (options[:verify_zip].to_s == 'true') || (options[:verify_address].to_s == 'true')
+        if address = options[:billing_address]
+          xml.AdditionalVerification do
+            xml.Zip address[:zip] if options[:verify_zip].to_s  == 'true'
+            xml.Address address[:address1] if options[:verify_address].to_s  == 'true'
+          end
+        end
+      end
+
+      def exp_date(payment_method)
+        "#{format(payment_method.year, :two_digits)}#{format(payment_method.month, :two_digits)}"
+      end
+
+      def parse(body)
+        response = {}
+        xml = Nokogiri::XML(body)
+
+        node = xml.xpath('//Response/TransactionDetails')
+        node.children.each do |childnode|
+          response[childnode.name] = childnode.text
+        end
+
+        node = xml.xpath('//Response/Result')
+        node.children.each do |childnode|
+          if childnode.elements.empty?
+            response[childnode.name] = childnode.text
+          else
+            childnode_to_response(response, childnode)
+          end
+        end
+
+        node = xml.xpath('//Response/CardDetails')
+        node.children.each do |childnode|
+          if childnode.elements.empty?
+            response[childnode.name] = childnode.text
+          else
+            childnode_to_response(response, childnode)
+          end
+        end
+
+        response
+      end
+
+      def childnode_to_response(response, childnode)
+        childnode.elements.each do |element|
+          if element.name == 'Error'
+            response['ErrorCode'] = element.attr('code')
+            response['ErrorMessage'] = element.text
+          else
+            response[element.name] = element.text
+          end
+        end
+      end
+
+      def commit(parameters)
+        response = parse(ssl_post(url, parameters))
+
+        Response.new(
+          success_from(response),
+          message_from(response),
+          response,
+          authorization: authorization_from(response),
+          avs_result: AVSResult.new(code: avs_result_code_from(response)),
+          cvv_result: CVVResult.new(cvv_result_code_from(response)),
+          error_code: error_result_code_from(response),
+          test: test?
+        )
+      end
+
+      def url
+        test? ? test_url : live_url
+      end
+
+      def success_from(response)
+        response['LocalResult'] == '0' || response['LocalResult'] == '00'
+      end
+
+      def message_from(response)
+        if success_from(response)
+          'Succeeded'
+        else
+          response['ErrorMessage']
+        end
+      end
+
+      def authorization_from(response)
+        response['CardEaseReference']
+      end
+
+      def manual_type(options)
+        options[:manual_type] || 'ecommerce'
+      end
+    end
+  end
+end