swiss-activemerchant 1.0.1

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

@@ -0,0 +1,348 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class MercadoPagoGateway < Gateway
+      self.live_url = self.test_url = 'https://api.mercadopago.com/v1'
+
+      self.supported_countries = %w[AR BR CL CO MX PE UY]
+      self.supported_cardtypes = %i[visa master american_express elo cabal naranja creditel]
+
+      self.homepage_url = 'https://www.mercadopago.com/'
+      self.display_name = 'Mercado Pago'
+      self.money_format = :dollars
+
+      def initialize(options = {})
+        requires!(options, :access_token)
+        super
+      end
+
+      def purchase(money, payment, options = {})
+        MultiResponse.run do |r|
+          r.process { commit('tokenize', 'card_tokens', card_token_request(money, payment, options)) }
+          options[:card_token] = r.authorization.split('|').first
+          r.process { commit('purchase', 'payments', purchase_request(money, payment, options)) }
+        end
+      end
+
+      def authorize(money, payment, options = {})
+        MultiResponse.run do |r|
+          r.process { commit('tokenize', 'card_tokens', card_token_request(money, payment, options)) }
+          options[:card_token] = r.authorization.split('|').first
+          r.process { commit('authorize', 'payments', authorize_request(money, payment, options)) }
+        end
+      end
+
+      def capture(money, authorization, options = {})
+        post = {}
+        authorization, = authorization.split('|')
+        post[:capture] = true
+        post[:transaction_amount] = amount(money).to_f
+        commit('capture', "payments/#{authorization}", post)
+      end
+
+      def refund(money, authorization, options = {})
+        post = {}
+        authorization, original_amount = authorization.split('|')
+        post[:amount] = amount(money).to_f if original_amount && original_amount.to_f > amount(money).to_f
+        commit('refund', "payments/#{authorization}/refunds", post)
+      end
+
+      def void(authorization, options = {})
+        authorization, = authorization.split('|')
+        post = { status: 'cancelled' }
+        commit('void', "payments/#{authorization}", post)
+      end
+
+      def verify(credit_card, options = {})
+        verify_amount = 100
+        verify_amount = options[:amount].to_i if options[:amount]
+        MultiResponse.run(:use_first_response) do |r|
+          r.process { authorize(verify_amount, credit_card, options) }
+          r.process(:ignore_result) { void(r.authorization, options) }
+        end
+      end
+
+      def inquire(authorization, options = {})
+        commit('inquire', inquire_path(authorization, options), {})
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((access_token=).*?([^\s]+)), '\1[FILTERED]').
+          gsub(%r((\"card_number\\\":\\\")\d+), '\1[FILTERED]').
+          gsub(%r((\"security_code\\\":\\\")\d+), '\1[FILTERED]')
+      end
+
+      private
+
+      def card_token_request(money, payment, options = {})
+        post = {}
+        post[:card_number] = payment.number
+        post[:security_code] = payment.verification_value
+        post[:expiration_month] = payment.month
+        post[:expiration_year] = payment.year
+        post[:cardholder] = {
+          name: payment.name,
+          identification: {
+            type: options[:cardholder_identification_type],
+            number: options[:cardholder_identification_number]
+          }
+        }
+        post
+      end
+
+      def purchase_request(money, payment, options = {})
+        post = {}
+        add_invoice(post, money, options)
+        add_payment(post, options)
+        add_additional_data(post, options)
+        add_customer_data(post, payment, options)
+        add_address(post, options)
+        add_processing_mode(post, options)
+        add_net_amount(post, options)
+        add_taxes(post, options)
+        add_notification_url(post, options)
+        post[:binary_mode] = (options[:binary_mode].nil? ? true : options[:binary_mode])
+        post
+      end
+
+      def authorize_request(money, payment, options = {})
+        post = purchase_request(money, payment, options)
+        post[:capture] = options[:capture] || false
+        post
+      end
+
+      def add_processing_mode(post, options)
+        return unless options[:processing_mode]
+
+        post[:processing_mode] = options[:processing_mode]
+        post[:merchant_account_id] = options[:merchant_account_id] if options[:merchant_account_id]
+        post[:payment_method_option_id] = options[:payment_method_option_id] if options[:payment_method_option_id]
+        add_merchant_services(post, options)
+      end
+
+      def add_merchant_services(post, options)
+        return unless options[:fraud_scoring] || options[:fraud_manual_review]
+
+        merchant_services = {}
+        merchant_services[:fraud_scoring] = options[:fraud_scoring] if options[:fraud_scoring]
+        merchant_services[:fraud_manual_review] = options[:fraud_manual_review] if options[:fraud_manual_review]
+        post[:merchant_services] = merchant_services
+      end
+
+      def add_additional_data(post, options)
+        post[:sponsor_id] = options[:sponsor_id]
+        post[:metadata] = options[:metadata] if options[:metadata]
+        post[:device_id] = options[:device_id] if options[:device_id]
+        post[:additional_info] = {
+          ip_address: options[:ip_address]
+        }.merge(options[:additional_info] || {})
+
+        add_address(post, options)
+        add_shipping_address(post, options)
+      end
+
+      def add_customer_data(post, payment, options)
+        post[:payer] = {
+          email: options[:email],
+          first_name: payment.first_name,
+          last_name: payment.last_name
+        }.merge(options[:payer] || {})
+      end
+
+      def add_address(post, options)
+        if address = (options[:billing_address] || options[:address])
+
+          post[:additional_info].merge!({
+            payer: {
+              address: {
+                zip_code: address[:zip],
+                street_name: "#{address[:address1]} #{address[:address2]}"
+              }
+            }
+          })
+        end
+      end
+
+      def add_shipping_address(post, options)
+        if address = options[:shipping_address]
+
+          post[:additional_info].merge!({
+            shipments: {
+              receiver_address: {
+                zip_code: address[:zip],
+                street_name: "#{address[:address1]} #{address[:address2]}"
+              }
+            }
+          })
+        end
+      end
+
+      def split_street_address(address1)
+        street_number = address1.split(' ').first
+
+        if street_name = address1.split(' ')[1..-1]
+          street_name = street_name.join(' ')
+        else
+          nil
+        end
+
+        [street_number, street_name]
+      end
+
+      def add_invoice(post, money, options)
+        post[:transaction_amount] = amount(money).to_f
+        post[:description] = options[:description]
+        post[:installments] = options[:installments] ? options[:installments].to_i : 1
+        post[:statement_descriptor] = options[:statement_descriptor] if options[:statement_descriptor]
+        post[:external_reference] = options[:order_id] || options[:external_reference] || SecureRandom.hex(16)
+      end
+
+      def add_payment(post, options)
+        post[:token] = options[:card_token]
+        post[:issuer_id] = options[:issuer_id] if options[:issuer_id]
+        post[:payment_method_id] = options[:payment_method_id] if options[:payment_method_id]
+      end
+
+      def add_net_amount(post, options)
+        post[:net_amount] = Float(options[:net_amount]) if options[:net_amount]
+      end
+
+      def add_notification_url(post, options)
+        post[:notification_url] = options[:notification_url] if options[:notification_url]
+      end
+
+      def add_taxes(post, options)
+        return unless (tax_object = options[:taxes])
+
+        if tax_object.is_a?(Array)
+          post[:taxes] = process_taxes_array(tax_object)
+        elsif tax_object.is_a?(Hash)
+          post[:taxes] = process_taxes_hash(tax_object)
+        else
+          raise taxes_error
+        end
+      end
+
+      def process_taxes_hash(tax_object)
+        [sanitize_taxes_hash(tax_object)]
+      end
+
+      def process_taxes_array(taxes_array)
+        taxes_array.map do |tax_object|
+          raise taxes_error unless tax_object.is_a?(Hash)
+
+          sanitize_taxes_hash(tax_object)
+        end
+      end
+
+      def sanitize_taxes_hash(tax_object)
+        tax_value = tax_object['value'] || tax_object[:value]
+        tax_type = tax_object['type'] || tax_object[:type]
+
+        raise taxes_error if tax_value.nil? || tax_type.nil?
+
+        { value: Float(tax_value), type: tax_type }
+      end
+
+      def taxes_error
+        ArgumentError.new("Taxes should be a single object or array of objects with the shape: { value: 500, type: 'IVA' }")
+      end
+
+      def parse(body)
+        JSON.parse(body)
+      rescue JSON::ParserError
+        {
+          'status' => 'error',
+          'status_detail' => 'json_parse_error',
+          'message' => "A non-JSON response was received from Mercado Pago where one was expected. The raw response was:\n\n#{body}"
+        }
+      end
+
+      def commit(action, path, parameters)
+        if %w[capture void].include?(action)
+          response = parse(ssl_request(:put, url(path), post_data(parameters), headers))
+        elsif action == 'inquire'
+          response = parse(ssl_get(url(path), headers))
+
+          response = response[0]['results'][0] if response.is_a?(Array)
+        else
+          response = parse(ssl_post(url(path), post_data(parameters), headers(parameters)))
+        end
+
+        Response.new(
+          success_from(action, response),
+          message_from(response),
+          response,
+          authorization: authorization_from(response, parameters),
+          test: test?,
+          error_code: error_code_from(action, response)
+        )
+      end
+
+      def success_from(action, response)
+        if action == 'refund'
+          response['status'] != 404 && response['error'].nil?
+        else
+          %w[active approved authorized cancelled in_process].include?(response['status'])
+        end
+      end
+
+      def message_from(response)
+        (response['status_detail']) || (response['message'])
+      end
+
+      def authorization_from(response, params)
+        [response['id'], params[:transaction_amount]].join('|')
+      end
+
+      def post_data(parameters = {})
+        parameters.clone.tap { |p| p.delete(:device_id) }.to_json
+      end
+
+      def inquire_path(authorization, options)
+        if authorization
+          authorization, = authorization.split('|')
+          "payments/#{authorization}"
+        else
+          "payments/search?external_reference=#{options[:order_id] || options[:external_reference]}"
+        end
+      end
+
+      def error_code_from(action, response)
+        unless success_from(action, response)
+          if cause = response['cause']
+            cause.empty? ? nil : cause.first['code']
+          else
+            response['status']
+          end
+        end
+      end
+
+      def url(action)
+        full_url = (test? ? test_url : live_url)
+        full_url + "/#{action}?access_token=#{CGI.escape(@options[:access_token])}"
+      end
+
+      def headers(options = {})
+        headers = {
+          'Content-Type' => 'application/json'
+        }
+        headers['X-meli-session-id'] = options[:device_id] if options[:device_id]
+        headers
+      end
+
+      def handle_response(response)
+        case response.code.to_i
+        when 200..499
+          response.body
+        else
+          raise ResponseError.new(response)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,228 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class MerchantESolutionsGateway < Gateway
+      include Empty
+
+      self.test_url = 'https://cert.merchante-solutions.com/mes-api/tridentApi'
+      self.live_url = 'https://api.merchante-solutions.com/mes-api/tridentApi'
+
+      # The countries the gateway supports merchants from as 2 digit ISO country codes
+      self.supported_countries = ['US']
+
+      # The card types supported by the payment gateway
+      self.supported_cardtypes = %i[visa master american_express discover jcb]
+
+      # The homepage URL of the gateway
+      self.homepage_url = 'http://www.merchante-solutions.com/'
+
+      # The name of the gateway
+      self.display_name = 'Merchant e-Solutions'
+
+      SUCCESS_RESPONSE_CODES = %w(000 085)
+
+      def initialize(options = {})
+        requires!(options, :login, :password)
+        super
+      end
+
+      def authorize(money, creditcard_or_card_id, options = {})
+        post = {}
+        add_invoice(post, options)
+        add_payment_source(post, creditcard_or_card_id, options)
+        add_address(post, options)
+        add_3dsecure_params(post, options)
+        add_stored_credentials(post, options)
+        commit('P', money, post)
+      end
+
+      def purchase(money, creditcard_or_card_id, options = {})
+        post = {}
+        add_invoice(post, options)
+        add_payment_source(post, creditcard_or_card_id, options)
+        add_address(post, options)
+        add_3dsecure_params(post, options)
+        add_stored_credentials(post, options)
+        commit('D', money, post)
+      end
+
+      def capture(money, transaction_id, options = {})
+        post = {}
+        post[:transaction_id] = transaction_id
+        post[:client_reference_number] = options[:customer] if options.has_key?(:customer)
+        add_invoice(post, options)
+        add_3dsecure_params(post, options)
+        commit('S', money, post)
+      end
+
+      def store(creditcard, options = {})
+        MultiResponse.run do |r|
+          r.process { temporary_store(creditcard, options) }
+          r.process { verify(r.authorization, { store_card: 'y' }) }
+        end
+      end
+
+      def unstore(card_id, options = {})
+        post = {}
+        post[:client_reference_number] = options[:customer] if options.has_key?(:customer)
+        post[:card_id] = card_id
+        commit('X', nil, post)
+      end
+
+      def refund(money, identification, options = {})
+        post = {}
+        post[:transaction_id] = identification
+        post[:client_reference_number] = options[:customer] if options.has_key?(:customer)
+        options.delete(:customer)
+        options.delete(:billing_address)
+        commit('U', money, options.merge(post))
+      end
+
+      def credit(money, creditcard_or_card_id, options = {})
+        post = {}
+        post[:client_reference_number] = options[:customer] if options.has_key?(:customer)
+        add_invoice(post, options)
+        add_payment_source(post, creditcard_or_card_id, options)
+        commit('C', money, post)
+      end
+
+      def void(transaction_id, options = {})
+        post = {}
+        post[:transaction_id] = transaction_id
+        post[:client_reference_number] = options[:customer] if options.has_key?(:customer)
+        options.delete(:customer)
+        options.delete(:billing_address)
+        commit('V', nil, options.merge(post))
+      end
+
+      def verify(credit_card, options = {})
+        post = {}
+        post[:store_card] = options[:store_card] if options[:store_card]
+        add_payment_source(post, credit_card, options)
+        commit('A', 0, post)
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((&?profile_key=)\w*(&?)), '\1[FILTERED]\2').
+          gsub(%r((&?card_number=)\d*(&?)), '\1[FILTERED]\2').
+          gsub(%r((&?cvv2=)\d*(&?)), '\1[FILTERED]\2')
+      end
+
+      private
+
+      def temporary_store(creditcard, options = {})
+        post = {}
+        post[:client_reference_number] = options[:customer] if options.has_key?(:customer)
+        add_creditcard(post, creditcard, options)
+        commit('T', nil, post)
+      end
+
+      def add_address(post, options)
+        if address = options[:billing_address] || options[:address]
+          post[:cardholder_street_address] = address[:address1].to_s.gsub(/[^\w.]/, '+')
+          post[:cardholder_zip] = address[:zip].to_s
+        end
+      end
+
+      def add_invoice(post, options)
+        if options.has_key? :order_id
+          order_id = options[:order_id].to_s.gsub(/[^\w.]/, '')
+          post[:invoice_number] = truncate(order_id, 17)
+        end
+      end
+
+      def add_payment_source(post, creditcard_or_card_id, options)
+        if creditcard_or_card_id.is_a?(String)
+          # using stored card
+          post[:card_id] = creditcard_or_card_id
+          post[:card_exp_date] = options[:expiration_date] if options[:expiration_date]
+        else
+          # card info is provided
+          add_creditcard(post, creditcard_or_card_id, options)
+        end
+      end
+
+      def add_creditcard(post, creditcard, options)
+        post[:card_number] = creditcard.number
+        post[:cvv2] = creditcard.verification_value if creditcard.verification_value?
+        post[:card_exp_date] = expdate(creditcard)
+      end
+
+      def add_3dsecure_params(post, options)
+        post[:xid] = options[:xid] unless empty?(options[:xid])
+        post[:cavv] = options[:cavv] unless empty?(options[:cavv])
+        post[:ucaf_collection_ind] = options[:ucaf_collection_ind] unless empty?(options[:ucaf_collection_ind])
+        post[:ucaf_auth_data] = options[:ucaf_auth_data] unless empty?(options[:ucaf_auth_data])
+      end
+
+      def add_stored_credentials(post, options)
+        post[:client_reference_number] = options[:client_reference_number] if options[:client_reference_number]
+        post[:moto_ecommerce_ind] = options[:moto_ecommerce_ind] if options[:moto_ecommerce_ind]
+        post[:recurring_pmt_num] = options[:recurring_pmt_num] if options[:recurring_pmt_num]
+        post[:recurring_pmt_count] = options[:recurring_pmt_count] if options[:recurring_pmt_count]
+        post[:card_on_file] = options[:card_on_file] if options[:card_on_file]
+        post[:cit_mit_indicator] = options[:cit_mit_indicator] if options[:cit_mit_indicator]
+        post[:account_data_source] = options[:account_data_source] if options[:account_data_source]
+      end
+
+      def parse(body)
+        results = {}
+        body.split(/&/).each do |pair|
+          key, val = pair.split(/=/)
+          results[key] = val
+        end
+        results
+      end
+
+      def commit(action, money, parameters)
+        url = test? ? self.test_url : self.live_url
+        parameters[:transaction_amount] = amount(money) if money unless action == 'V'
+
+        response =
+          begin
+            parse(ssl_post(url, post_data(action, parameters)))
+          rescue ActiveMerchant::ResponseError => e
+            { 'error_code' => '404', 'auth_response_text' => e.to_s }
+          end
+
+        Response.new(success_from(response), message_from(response), response,
+          authorization: authorization_from(response),
+          test: test?,
+          cvv_result: response['cvv2_result'],
+          avs_result: { code: response['avs_result'] })
+      end
+
+      def authorization_from(response)
+        return response['card_id'] if response['card_id']
+
+        response['transaction_id']
+      end
+
+      def success_from(response)
+        SUCCESS_RESPONSE_CODES.include?(response['error_code'])
+      end
+
+      def message_from(response)
+        if response['error_code'] == '000'
+          'This transaction has been approved'
+        else
+          response['auth_response_text']
+        end
+      end
+
+      def post_data(action, parameters = {})
+        post = {}
+        post[:profile_id] = @options[:login]
+        post[:profile_key] = @options[:password]
+        post[:transaction_type] = action if action
+
+        request = post.merge(parameters).map { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join('&')
+        request
+      end
+    end
+  end
+end

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

@@ -0,0 +1,110 @@
+require 'cgi'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class MerchantOneGateway < Gateway
+      class MerchantOneSslConnection < ActiveMerchant::Connection
+        def configure_ssl(http)
+          super(http)
+          http.use_ssl = true
+        end
+      end
+
+      BASE_URL = 'https://secure.merchantonegateway.com/api/transact.php'
+
+      self.supported_countries = ['US']
+      self.supported_cardtypes = %i[visa master american_express discover]
+      self.homepage_url = 'http://merchantone.com/'
+      self.display_name = 'Merchant One Gateway'
+      self.money_format = :dollars
+
+      def initialize(options = {})
+        requires!(options, :username, :password)
+        super
+      end
+
+      def authorize(money, creditcard, options = {})
+        post = {}
+        add_customer_data(post, options)
+        add_creditcard(post, creditcard)
+        add_address(post, creditcard, options)
+        add_customer_data(post, options)
+        add_amount(post, money, options)
+        commit('auth', money, post)
+      end
+
+      def purchase(money, creditcard, options = {})
+        post = {}
+        add_customer_data(post, options)
+        add_creditcard(post, creditcard)
+        add_address(post, creditcard, options)
+        add_customer_data(post, options)
+        add_amount(post, money, options)
+        commit('sale', money, post)
+      end
+
+      def capture(money, authorization, options = {})
+        post = {}
+        post[:transactionid] = authorization
+        add_amount(post, money, options)
+        commit('capture', money, post)
+      end
+
+      def new_connection(endpoint)
+        MerchantOneSslConnection.new(endpoint)
+      end
+
+      private
+
+      def add_customer_data(post, options)
+        post['firstname'] = options[:billing_address][:first_name]
+        post['lastname'] = options[:billing_address][:last_name]
+      end
+
+      def add_amount(post, money, options)
+        post['amount'] = amount(money)
+      end
+
+      def add_address(post, creditcard, options)
+        post['address1'] = options[:billing_address][:address1]
+        post['city'] = options[:billing_address][:city]
+        post['state'] = options[:billing_address][:state]
+        post['zip'] = options[:billing_address][:zip]
+        post['country'] = options[:billing_address][:country]
+      end
+
+      def add_creditcard(post, creditcard)
+        post['cvv'] = creditcard.verification_value
+        post['ccnumber'] = creditcard.number
+        post['ccexp'] = "#{sprintf('%02d', creditcard.month)}#{creditcard.year.to_s[-2, 2]}"
+      end
+
+      def commit(action, money, parameters = {})
+        parameters['username'] = @options[:username]
+        parameters['password'] = @options[:password]
+        parse(ssl_post(BASE_URL, post_data(action, parameters)))
+      end
+
+      def post_data(action, parameters = {})
+        parameters[:type] = action
+        ret = ''
+        for key in parameters.keys
+          ret += "#{key}=#{CGI.escape(parameters[key].to_s)}"
+          ret += '&' if key != parameters.keys.last
+        end
+        ret.to_s
+      end
+
+      def parse(data)
+        responses = CGI.parse(data).inject({}) { |h, (k, v)| h[k] = v.first; h }
+        Response.new(
+          (responses['response'].to_i == 1),
+          responses['responsetext'],
+          responses,
+          test: test?,
+          authorization: responses['transactionid']
+        )
+      end
+    end
+  end
+end