activemerchant 1.42.6 → 1.90.0

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

@@ -0,0 +1,327 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class CardknoxGateway < Gateway
+      self.live_url = 'https://x1.cardknox.com/gateway'
+
+      self.supported_countries = ['US', 'CA', 'GB']
+      self.default_currency = 'USD'
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :diners_club, :jcb]
+
+      self.homepage_url = 'https://www.cardknox.com/'
+      self.display_name = 'Cardknox'
+
+      COMMANDS = {
+        credit_card: {
+          purchase:          'cc:sale',
+          authorization:     'cc:authonly',
+          capture:           'cc:capture',
+          refund:            'cc:refund',
+          void:              'cc:void',
+          save:              'cc:save'
+        },
+        check: {
+          purchase:    'check:sale',
+          refund:      'check:refund',
+          void:        'check:void',
+          save:        'check:save'
+        }
+      }
+
+      def initialize(options={})
+        requires!(options, :api_key)
+        super
+      end
+
+      # There are three sources for doing a purchase transation:
+      # - credit card
+      # - check
+      # - cardknox token, which is returned in the the authorization string "ref_num;token;command"
+
+      def purchase(amount, source, options={})
+        post = {}
+        add_amount(post, amount, options)
+        add_invoice(post, options)
+        add_source(post, source)
+        add_address(post, source, options)
+        add_customer_data(post, options)
+        add_custom_fields(post, options)
+        commit(:purchase, source_type(source), post)
+      end
+
+      def authorize(amount, source, options={})
+        post = {}
+        add_amount(post, amount)
+        add_invoice(post, options)
+        add_source(post, source)
+        add_address(post, source, options)
+        add_customer_data(post, options)
+        add_custom_fields(post, options)
+        commit(:authorization, source_type(source), post)
+      end
+
+      def capture(amount, authorization, options = {})
+        post = {}
+        add_reference(post, authorization)
+        add_amount(post, amount)
+        commit(:capture, source_type(authorization), post)
+      end
+
+      def refund(amount, authorization, options={})
+        post = {}
+        add_reference(post, authorization)
+        add_amount(post, amount)
+        commit(:refund, source_type(authorization), post)
+      end
+
+      def void(authorization, options = {})
+        post = {}
+        add_reference(post, authorization)
+        commit(:void, source_type(authorization), post)
+      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 store(source, options = {})
+        post = {}
+        add_source(post, source)
+        add_address(post, source, options)
+        add_invoice(post, options)
+        add_customer_data(post, options)
+        add_custom_fields(post, options)
+        commit(:save, source_type(source), post)
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((xCardNum=)\d+), '\1[FILTERED]').
+          gsub(%r((xCVV=)\d+), '\1[FILTERED]').
+          gsub(%r((xAccount=)\d+), '\1[FILTERED]').
+          gsub(%r((xRouting=)\d+), '\1[FILTERED]').
+          gsub(%r((xKey=)\w+), '\1[FILTERED]')
+      end
+
+      private
+
+      def split_authorization(authorization)
+        authorization.split(';')
+      end
+
+      def add_reference(post, reference)
+        reference, _, _ = split_authorization(reference)
+        post[:Refnum] = reference
+      end
+
+      def source_type(source)
+        if source.respond_to?(:brand)
+          :credit_card
+        elsif source.respond_to?(:routing_number)
+          :check
+        elsif source.kind_of?(String)
+          source_type_from(source)
+        else
+          raise ArgumentError, "Unknown source #{source.inspect}"
+        end
+      end
+
+      def source_type_from(authorization)
+        _, _, source_type = split_authorization(authorization)
+        (source_type || 'credit_card').to_sym
+      end
+
+      def add_source(post, source)
+        if source.respond_to?(:brand)
+          add_credit_card(post, source)
+        elsif source.respond_to?(:routing_number)
+          add_check(post, source)
+        elsif source.kind_of?(String)
+          add_cardknox_token(post, source)
+        else
+          raise ArgumentError, "Invalid payment source #{source.inspect}"
+        end
+      end
+
+      # Subtotal + Tax + Tip = Amount.
+
+      def add_amount(post, money, options = {})
+        post[:Tip]    = amount(options[:tip])
+        post[:Amount] = amount(money)
+      end
+
+      def expdate(credit_card)
+        year  = format(credit_card.year, :two_digits)
+        month = format(credit_card.month, :two_digits)
+        "#{month}#{year}"
+      end
+
+      def add_customer_data(post, options)
+        address = options[:billing_address] || {}
+        post[:Street] = address[:address1]
+        post[:Zip] = address[:zip]
+        post[:PONum] = options[:po_number]
+        post[:Fax] = options[:fax]
+        post[:Email] = options[:email]
+        post[:IP] = options[:ip]
+      end
+
+      def add_address(post, source, options)
+        add_address_for_type(:billing, post, source, options[:billing_address]) if options[:billing_address]
+        add_address_for_type(:shipping, post, source, options[:shipping_address]) if options[:shipping_address]
+      end
+
+      def add_address_for_type(type, post, source, address)
+        prefix = address_key_prefix(type)
+        if source.respond_to?(:first_name)
+          post[address_key(prefix, 'FirstName')] = source.first_name
+          post[address_key(prefix, 'LastName')]  = source.last_name
+        else
+          post[address_key(prefix, 'FirstName')] = address[:first_name]
+          post[address_key(prefix, 'LastName')]  = address[:last_name]
+        end
+        post[address_key(prefix, 'MiddleName')]  = address[:middle_name]
+
+        post[address_key(prefix, 'Company')]  = address[:company]
+        post[address_key(prefix, 'Street')]   = address[:address1]
+        post[address_key(prefix, 'Street2')]  = address[:address2]
+        post[address_key(prefix, 'City')]     = address[:city]
+        post[address_key(prefix, 'State')]    = address[:state]
+        post[address_key(prefix, 'Zip')]      = address[:zip]
+        post[address_key(prefix, 'Country')]  = address[:country]
+        post[address_key(prefix, 'Phone')]    = address[:phone]
+        post[address_key(prefix, 'Mobile')]   = address[:mobile]
+      end
+
+      def address_key_prefix(type)
+        case type
+        when :shipping then 'Ship'
+        when :billing then 'Bill'
+        else
+          raise ArgumentError, "Unknown address key prefix: #{type}"
+        end
+      end
+
+      def address_key(prefix, key)
+        "#{prefix}#{key}".to_sym
+      end
+
+      def add_invoice(post, options)
+        post[:Invoice] = options[:invoice]
+        post[:OrderID] = options[:order_id]
+        post[:Comments] = options[:comments]
+        post[:Description] = options[:description]
+        post[:Tax] = amount(options[:tax])
+      end
+
+      def add_custom_fields(post, options)
+        options.keys.grep(/^custom(?:[01]\d|20)$/) do |key|
+          post[key.to_s.capitalize] = options[key]
+        end
+      end
+
+      def add_credit_card(post, credit_card)
+        if credit_card.track_data.present?
+          post[:Magstripe] = credit_card.track_data
+          post[:Cardpresent] = true
+        else
+          post[:CardNum] = credit_card.number
+          post[:CVV] = credit_card.verification_value
+          post[:Exp] = expdate(credit_card)
+          post[:Name] = credit_card.name
+          post[:CardPresent] = true if credit_card.manual_entry
+        end
+      end
+
+      def add_check(post, check)
+        post[:Routing] = check.routing_number
+        post[:Account] = check.account_number
+        post[:Name] = check.name
+        post[:CheckNum] = check.number
+      end
+
+      def add_cardknox_token(post, authorization)
+        _, token, _ = split_authorization(authorization)
+
+        post[:Token] = token
+      end
+
+      def parse(body)
+        fields = {}
+        for line in body.split('&')
+          key, value = *line.scan(%r{^(\w+)\=(.*)$}).flatten
+          fields[key] = CGI.unescape(value.to_s)
+        end
+
+        {
+          result:            fields['xResult'],
+          status:            fields['xStatus'],
+          error:             fields['xError'],
+          auth_code:         fields['xAuthCode'],
+          ref_num:           fields['xRefNum'],
+          current_ref_num:   fields['xRefNumCurrent'],
+          token:             fields['xToken'],
+          batch:             fields['xBatch'],
+          avs_result:        fields['xAvsResult'],
+          avs_result_code:   fields['xAvsResultCode'],
+          cvv_result:        fields['xCvvResult'],
+          cvv_result_code:   fields['xCvvResultCode'],
+          remaining_balance: fields['xRemainingBalance'],
+          amount:            fields['xAuthAmount'],
+          masked_card_num:   fields['xMaskedCardNumber'],
+          masked_account_number: fields['MaskedAccountNumber']
+        }.delete_if { |k, v| v.nil? }
+      end
+
+      def commit(action, source_type, parameters)
+        response = parse(ssl_post(live_url, post_data(COMMANDS[source_type][action], parameters)))
+
+        Response.new(
+          (response[:status] == 'Approved'),
+          message_from(response),
+          response,
+          authorization: authorization_from(response, source_type),
+          avs_result: { code: response[:avs_result_code] },
+          cvv_result: response[:cvv_result_code]
+        )
+      end
+
+      def message_from(response)
+        if response[:status] == 'Approved'
+          'Success'
+        elsif response[:error].blank?
+          'Unspecified error'
+        else
+          response[:error]
+        end
+      end
+
+      def authorization_from(response, source_type)
+        "#{response[:ref_num]};#{response[:token]};#{source_type}"
+      end
+
+      def post_data(command, parameters = {})
+        initial_parameters = {
+          Key: @options[:api_key],
+          Version: '4.5.4',
+          SoftwareName: 'Active Merchant',
+          SoftwareVersion: ActiveMerchant::VERSION.to_s,
+          Command: command,
+        }
+
+        seed = SecureRandom.hex(32).upcase
+        hash = Digest::SHA1.hexdigest("#{initial_parameters[:command]}:#{@options[:pin]}:#{parameters[:amount]}:#{parameters[:invoice]}:#{seed}")
+        initial_parameters[:Hash] = "s/#{seed}/#{hash}/n" unless @options[:pin].blank?
+        parameters = initial_parameters.merge(parameters)
+
+        parameters.reject { |k, v| v.blank? }.collect { |key, value| "x#{key}=#{CGI.escape(value.to_s)}" }.join('&')
+      end
+    end
+  end
+end

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

@@ -0,0 +1,254 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class CardprocessGateway < Gateway
+      self.test_url = 'https://test.vr-pay-ecommerce.de/v1/payments'
+      self.live_url = 'https://vr-pay-ecommerce.de/v1/payments'
+
+      self.supported_countries = %w[ BE BG CZ DK DE EE IE ES FR HR IT CY LV LT LU
+                                     MT HU NL AT PL PT RO SI SK FI SE GB IS LI NO
+                                     CH ME MK AL RS TR BA ]
+      self.default_currency = 'EUR'
+      self.supported_cardtypes = [:visa, :master, :american_express, :diners_club, :jcb]
+
+      self.homepage_url = 'https://vr-pay-ecommerce.docs.oppwa.com/'
+      self.display_name = 'CardProcess VR-Pay'
+      self.money_format = :dollars
+
+      STANDARD_ERROR_CODE_MAPPING = {}
+
+      # Creates a new CardProcess Gateway
+      #
+      # The gateway requires a valid login, password, and entity ID
+      # to be passed in the +options+ hash.
+      #
+      # === Options
+      #
+      # * <tt>:user_id</tt> -- The CardProcess user ID
+      # * <tt>:password</tt> -- The CardProcess password
+      # * <tt>:entity_id</tt> -- The CardProcess channel or entity ID for any transactions
+      def initialize(options={})
+        requires!(options, :user_id, :password, :entity_id)
+        super
+        # This variable exists purely to allow remote tests to force error codes;
+        # the lack of a setter despite its usage is intentional.
+        @test_options = {}
+      end
+
+      def purchase(money, payment, options = {})
+        post = {}
+        add_invoice(post, money, options)
+        add_payment(post, payment)
+        add_address(post, payment, options)
+        add_customer_data(post, options)
+
+        commit('DB', post)
+      end
+
+      def authorize(money, payment, options = {})
+        post = {}
+        add_invoice(post, money, options)
+        add_payment(post, payment)
+        add_address(post, payment, options)
+        add_customer_data(post, options)
+
+        commit('PA', post)
+      end
+
+      def capture(money, authorization, options = {})
+        post = {
+          id: authorization
+        }
+        add_invoice(post, money, options)
+        commit('CP', post)
+      end
+
+      def refund(money, authorization, options = {})
+        post = {
+          id: authorization
+        }
+        add_invoice(post, money, options)
+        commit('RF', post)
+      end
+
+      def credit(money, payment, options = {})
+        post = {}
+        add_invoice(post, money, options)
+        add_payment(post, payment)
+        add_address(post, payment, options)
+        add_customer_data(post, options)
+
+        commit('CD', post)
+      end
+
+      def void(authorization, _options = {})
+        post = {
+          id: authorization
+        }
+        commit('RV', post)
+      end
+
+      def verify(credit_card, options = {})
+        MultiResponse.run do |r|
+          r.process { authorize(100, credit_card, options) }
+          r.process { void(r.authorization, options) }
+        end
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r{(authentication\.[^=]+=)[^&]+}, '\1[FILTERED]').
+          gsub(%r{(card\.number=)\d+}, '\1[FILTERED]').
+          gsub(%r{(cvv=)\d{3,4}}, '\1[FILTERED]\2')
+      end
+
+      private
+
+      def add_customer_data(post, options)
+        post['customer.ip'] = options[:ip] if options[:ip]
+      end
+
+      def add_address(post, _card, options)
+        if (address = options[:billing_address] || options[:address])
+          post[:billing] = hashify_address(address)
+        end
+
+        if (shipping = options[:shipping_address])
+          post[:shipping] = hashify_address(shipping)
+        end
+      end
+
+      def add_invoice(post, money, options)
+        return if money.nil?
+        post[:amount] = amount(money)
+        post[:currency] = (options[:currency] || currency(money))
+        post[:merchantInvoiceId] = options[:merchant_invoice_id] if options[:merchant_invoice_id]
+        post[:merchantTransactionId] = options[:merchant_transaction_id] if options[:merchant_transaction_id]
+        post[:transactionCategory] = options[:transaction_category] if options[:transaction_category]
+      end
+
+      def add_payment(post, payment)
+        return if payment.is_a?(String)
+        post[:paymentBrand] = payment.brand.upcase if payment.brand
+        post[:card] ||= {}
+        post[:card][:number] = payment.number
+        post[:card][:holder] = payment.name
+        post[:card][:expiryMonth] = sprintf('%02d', payment.month)
+        post[:card][:expiryYear] = sprintf('%02d', payment.year)
+        post[:card][:cvv] = payment.verification_value
+      end
+
+      def parse(body)
+        JSON.parse(body)
+      end
+
+      def commit(action, parameters)
+        url = (test? ? test_url : live_url)
+        if (id = parameters.delete(:id))
+          url += "/#{id}"
+        end
+
+        begin
+          raw_response = ssl_post(url, post_data(action, parameters.merge(@test_options)))
+        rescue ResponseError => e
+          raw_response = e.response.body
+        end
+        response = parse(raw_response)
+
+        Response.new(
+          success_from(response),
+          message_from(response),
+          response,
+          authorization: authorization_from(response),
+          avs_result: AVSResult.new(code: response['result']['avsResponse']),
+          cvv_result: CVVResult.new(response['result']['cvvResponse']),
+          test: test?,
+          error_code: error_code_from(response)
+        )
+      end
+
+      def success_from(response)
+        !(response['result']['code'] =~ /^(000\.000\.|000\.100\.1|000\.[36])/).nil?
+      end
+
+      def message_from(response)
+        response['result']['description']
+      end
+
+      def authorization_from(response)
+        response['id']
+      end
+
+      def post_data(action, parameters = {})
+        post = parameters.clone
+        post[:authentication] ||= {}
+        post[:authentication][:userId] = @options[:user_id]
+        post[:authentication][:password] = @options[:password]
+        post[:authentication][:entityId] = @options[:entity_id]
+        post[:paymentType] = action
+        dot_flatten_hash(post).map { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join('&')
+      end
+
+      def error_code_from(response)
+        unless success_from(response)
+          case response['result']['code']
+          when '100.100.101'
+            STANDARD_ERROR_CODE[:incorrect_number]
+          when '100.100.303'
+            STANDARD_ERROR_CODE[:expired_card]
+          when /100\.100\.(201|301|305)/
+            STANDARD_ERROR_CODE[:invalid_expiry_date]
+          when /100.100.60[01]/
+            STANDARD_ERROR_CODE[:invalid_cvc]
+          when '800.100.151'
+            STANDARD_ERROR_CODE[:invalid_number]
+          when '800.100.153'
+            STANDARD_ERROR_CODE[:incorrect_cvc]
+          when /800.800.(102|302)/
+            STANDARD_ERROR_CODE[:incorrect_address]
+          when '800.800.202'
+            STANDARD_ERROR_CODE[:invalid_zip]
+          when '800.100.166'
+            STANDARD_ERROR_CODE[:incorrect_pin]
+          when '800.100.171'
+            STANDARD_ERROR_CODE[:pickup_card]
+          when /^(200|700)\./
+            STANDARD_ERROR_CODE[:config_error]
+          when /^(800\.[17]00|800\.800\.[123])/
+            STANDARD_ERROR_CODE[:card_declined]
+          when /^(900\.[1234]00)/
+            STANDARD_ERROR_CODE[:processing_error]
+          else
+            STANDARD_ERROR_CODE[:processing_error]
+          end
+        end
+      end
+
+      def hashify_address(address)
+        hash = {}
+        hash[:street1] = address[:address1] if address[:address1]
+        hash[:street2] = address[:address2] if address[:address2]
+        hash[:city] = address[:city] if address[:city]
+        hash[:state] = address[:state] if address[:state]
+        hash[:postcode] = address[:zip] if address[:zip]
+        hash[:country] = address[:country] if address[:country]
+        hash
+      end
+
+      def dot_flatten_hash(hash, prefix = '')
+        h = {}
+        hash.each_pair do |k, v|
+          if v.is_a?(Hash)
+            h.merge!(dot_flatten_hash(v, prefix + k.to_s + '.'))
+          else
+            h[prefix + k.to_s] = v
+          end
+        end
+        h
+      end
+    end
+  end
+end