swiss-crm-activemerchant 1.0.12

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

@@ -0,0 +1,224 @@
+require 'rexml/document'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class VerifiGateway < Gateway
+      class VerifiPostData < PostData
+        # Fields that will be sent even if they are blank
+        self.required_fields = %i[amount type ccnumber ccexp firstname lastname
+                                  company address1 address2 city state zip country phone]
+      end
+
+      self.live_url = self.test_url = 'https://secure.verifi.com/gw/api/transact.php'
+
+      RESPONSE_CODE_MESSAGES = {
+        '100' => 'Transaction was Approved',
+        '200' => 'Transaction was Declined by Processor',
+        '201' => 'Do Not Honor',
+        '202' => 'Insufficient Funds',
+        '203' => 'Over Limit',
+        '204' => 'Transaction not allowed',
+        '220' => 'Incorrect payment Data',
+        '221' => 'No Such Card Issuer',
+        '222' => 'No Card Number on file with Issuer',
+        '223' => 'Expired Card',
+        '224' => 'Invalid Expiration Date',
+        '225' => 'Invalid Card Security Code',
+        '240' => 'Call Issuer for Further Information',
+        '250' => 'Pick Up Card',
+        '251' => 'Lost Card',
+        '252' => 'Stolen Card',
+        '253' => 'Fraudulent Card',
+        '260' => 'Declined With further Instructions Available (see response text)',
+        '261' => 'Declined - Stop All Recurring Payments',
+        '262' => 'Declined - Stop this Recurring Program',
+        '263' => 'Declined - Update Cardholder Data Available',
+        '264' => 'Declined - Retry in a few days',
+        '300' => 'Transaction was Rejected by Gateway',
+        '400' => 'Transaction Error Returned by Processor',
+        '410' => 'Invalid Merchant Configuration',
+        '411' => 'Merchant Account is Inactive',
+        '420' => 'Communication Error',
+        '421' => 'Communication Error with Issuer',
+        '430' => 'Duplicate Transaction at Processor',
+        '440' => 'Processor Format Error',
+        '441' => 'Invalid Transaction Information',
+        '460' => 'Processor Feature Not Available',
+        '461' => 'Unsupported Card Type'
+      }
+
+      SUCCESS = 1
+
+      TRANSACTIONS = {
+        authorization: 'auth',
+        purchase: 'sale',
+        capture: 'capture',
+        void: 'void',
+        credit: 'credit',
+        refund: 'refund'
+      }
+
+      self.supported_countries = ['US']
+      self.supported_cardtypes = %i[visa master american_express discover]
+      self.homepage_url = 'http://www.verifi.com/'
+      self.display_name = 'Verifi'
+
+      def initialize(options = {})
+        requires!(options, :login, :password)
+        super
+      end
+
+      def purchase(money, credit_card, options = {})
+        sale_authorization_or_credit_template(:purchase, money, credit_card, options)
+      end
+
+      def authorize(money, credit_card, options = {})
+        sale_authorization_or_credit_template(:authorization, money, credit_card, options)
+      end
+
+      def capture(money, authorization, options = {})
+        capture_void_or_refund_template(:capture, money, authorization, options)
+      end
+
+      def void(authorization, options = {})
+        capture_void_or_refund_template(:void, 0, authorization, options)
+      end
+
+      def credit(money, credit_card_or_authorization, options = {})
+        if credit_card_or_authorization.is_a?(String)
+          ActiveMerchant.deprecated CREDIT_DEPRECATION_MESSAGE
+          refund(money, credit_card_or_authorization, options)
+        else
+          sale_authorization_or_credit_template(:credit, money, credit_card_or_authorization, options)
+        end
+      end
+
+      def refund(money, reference, options = {})
+        capture_void_or_refund_template(:refund, money, reference, options)
+      end
+
+      private
+
+      def sale_authorization_or_credit_template(trx_type, money, credit_card, options = {})
+        post = VerifiPostData.new
+        add_security_key_data(post, options, money)
+        add_credit_card(post, credit_card)
+        add_addresses(post, options)
+        add_customer_data(post, options)
+        add_invoice_data(post, options)
+        add_optional_data(post, options)
+        commit(trx_type, money, post)
+      end
+
+      def capture_void_or_refund_template(trx_type, money, authorization, options)
+        post = VerifiPostData.new
+        post[:transactionid] = authorization
+
+        commit(trx_type, money, post)
+      end
+
+      def add_credit_card(post, credit_card)
+        post[:ccnumber]  = credit_card.number
+        post[:ccexp]     = expdate(credit_card)
+        post[:firstname] = credit_card.first_name
+        post[:lastname]  = credit_card.last_name
+        post[:cvv]       = credit_card.verification_value
+      end
+
+      def add_addresses(post, options)
+        if billing_address = options[:billing_address] || options[:address]
+          post[:company]    = billing_address[:company]
+          post[:address1]   = billing_address[:address1]
+          post[:address2]   = billing_address[:address2]
+          post[:city]       = billing_address[:city]
+          post[:state]      = billing_address[:state]
+          post[:zip]        = billing_address[:zip]
+          post[:country]    = billing_address[:country]
+          post[:phone]      = billing_address[:phone]
+          post[:fax]        = billing_address[:fax]
+        end
+
+        if shipping_address = options[:shipping_address]
+          post[:shipping_firstname] = shipping_address[:first_name]
+          post[:shipping_lastname]  = shipping_address[:last_name]
+          post[:shipping_company]   = shipping_address[:company]
+          post[:shipping_address1]  = shipping_address[:address1]
+          post[:shipping_address2]  = shipping_address[:address2]
+          post[:shipping_city]      = shipping_address[:city]
+          post[:shipping_state]     = shipping_address[:state]
+          post[:shipping_zip]       = shipping_address[:zip]
+          post[:shipping_country]   = shipping_address[:country]
+          post[:shipping_email]     = shipping_address[:email]
+        end
+      end
+
+      def add_customer_data(post, options)
+        post[:email]     = options[:email]
+        post[:ipaddress] = options[:ip]
+      end
+
+      def add_invoice_data(post, options)
+        post[:orderid]            = options[:order_id]
+        post[:ponumber]           = options[:invoice]
+        post[:orderdescription]   = options[:description]
+        post[:tax]                = options[:tax]
+        post[:shipping]           = options[:shipping]
+      end
+
+      def add_optional_data(post, options)
+        post[:billing_method]     = options[:billing_method]
+        post[:website]            = options[:website]
+        post[:descriptor]         = options[:descriptor]
+        post[:descriptor_phone]   = options[:descriptor_phone]
+        post[:cardholder_auth]    = options[:cardholder_auth]
+        post[:cavv]               = options[:cavv]
+        post[:xid]                = options[:xid]
+        post[:customer_receipt]   = options[:customer_receipt]
+      end
+
+      def add_security_key_data(post, options, money)
+        # MD5(username|password|orderid|amount|time)
+        now = Time.now.to_i.to_s
+        md5 = Digest::MD5.new
+        md5 << @options[:login].to_s + '|'
+        md5 << @options[:password].to_s + '|'
+        md5 << options[:order_id].to_s + '|'
+        md5 << amount(money).to_s + '|'
+        md5 << now
+        post[:key]  = md5.hexdigest
+        post[:time] = now
+      end
+
+      def commit(trx_type, money, post)
+        post[:amount] = amount(money)
+
+        response = parse(ssl_post(self.live_url, post_data(trx_type, post)))
+
+        Response.new(response[:response].to_i == SUCCESS, message_from(response), response,
+          test: test?,
+          authorization: response[:transactionid],
+          avs_result: { code: response[:avsresponse] },
+          cvv_result: response[:cvvresponse])
+      end
+
+      def message_from(response)
+        response[:response_code_message] || ''
+      end
+
+      def parse(body)
+        results = {}
+        CGI.parse(body).each { |key, value| results[key.intern] = value[0] }
+        results[:response_code_message] = RESPONSE_CODE_MESSAGES[results[:response_code]] if results[:response_code]
+        results
+      end
+
+      def post_data(trx_type, post)
+        post[:username]   = @options[:login]
+        post[:password]   = @options[:password]
+        post[:type]       = TRANSACTIONS[trx_type]
+
+        post.to_s
+      end
+    end
+  end
+end

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

@@ -0,0 +1,171 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class ViaklixGateway < Gateway
+      class_attribute :test_url, :live_url, :delimiter, :actions
+
+      self.test_url = 'https://demo.viaklix.com/process.asp'
+      self.live_url = 'https://www.viaklix.com/process.asp'
+      self.delimiter = "\r\n"
+
+      self.actions = {
+        purchase: 'SALE',
+        credit: 'CREDIT'
+      }
+
+      APPROVED = '0'
+
+      self.supported_cardtypes = %i[visa master american_express discover]
+      self.supported_countries = ['US']
+      self.display_name = 'ViaKLIX'
+      self.homepage_url = 'http://viaklix.com'
+
+      # Initialize the Gateway
+      #
+      # The gateway requires that a valid login and password be passed
+      # in the +options+ hash.
+      #
+      # ==== Options
+      #
+      # * <tt>:login</tt> -- Merchant ID
+      # * <tt>:password</tt> -- PIN
+      # * <tt>:user</tt> -- Specify a subuser of the account (optional)
+      # * <tt>:test => +true+ or +false+</tt> -- Force test transactions
+      def initialize(options = {})
+        requires!(options, :login, :password)
+        super
+      end
+
+      # Make a purchase
+      def purchase(money, creditcard, options = {})
+        form = {}
+        add_invoice(form, options)
+        add_creditcard(form, creditcard)
+        add_address(form, options)
+        add_customer_data(form, options)
+        add_test_mode(form, options)
+        commit(:purchase, money, form)
+      end
+
+      # Make a credit to a card (Void can only be done from the virtual terminal)
+      # Viaklix does not support credits by reference. You must pass in the credit card
+      def credit(money, creditcard, options = {})
+        raise ArgumentError, 'Reference credits are not supported. Please supply the original credit card' if creditcard.is_a?(String)
+
+        form = {}
+        add_invoice(form, options)
+        add_creditcard(form, creditcard)
+        add_address(form, options)
+        add_customer_data(form, options)
+        add_test_mode(form, options)
+        commit(:credit, money, form)
+      end
+
+      private
+
+      def add_test_mode(form, options)
+        form[:test_mode] = 'TRUE' if options[:test_mode]
+      end
+
+      def add_customer_data(form, options)
+        form[:email] = options[:email].to_s.slice(0, 100) unless options[:email].blank?
+        form[:customer_code] = options[:customer].to_s.slice(0, 10) unless options[:customer].blank?
+      end
+
+      def add_invoice(form, options)
+        form[:invoice_number] = (options[:order_id] || options[:invoice]).to_s.slice(0, 10)
+        form[:description] = options[:description].to_s.slice(0, 255)
+      end
+
+      def add_address(form, options)
+        billing_address = options[:billing_address] || options[:address]
+
+        if billing_address
+          form[:avs_address]    = billing_address[:address1].to_s.slice(0, 30)
+          form[:address2]       = billing_address[:address2].to_s.slice(0, 30)
+          form[:avs_zip]        = billing_address[:zip].to_s.slice(0, 10)
+          form[:city]           = billing_address[:city].to_s.slice(0, 30)
+          form[:state]          = billing_address[:state].to_s.slice(0, 10)
+          form[:company]        = billing_address[:company].to_s.slice(0, 50)
+          form[:phone]          = billing_address[:phone].to_s.slice(0, 20)
+          form[:country]        = billing_address[:country].to_s.slice(0, 50)
+        end
+
+        if shipping_address = options[:shipping_address]
+          first_name, last_name = split_names(shipping_address[:name])
+          form[:ship_to_first_name]     = first_name.to_s.slice(0, 20)
+          form[:ship_to_last_name]      = last_name.to_s.slice(0, 30)
+          form[:ship_to_address]        = shipping_address[:address1].to_s.slice(0, 30)
+          form[:ship_to_city]           = shipping_address[:city].to_s.slice(0, 30)
+          form[:ship_to_state]          = shipping_address[:state].to_s.slice(0, 10)
+          form[:ship_to_company]        = shipping_address[:company].to_s.slice(0, 50)
+          form[:ship_to_country]        = shipping_address[:country].to_s.slice(0, 50)
+          form[:ship_to_zip]            = shipping_address[:zip].to_s.slice(0, 10)
+        end
+      end
+
+      def add_creditcard(form, creditcard)
+        form[:card_number] = creditcard.number
+        form[:exp_date] = expdate(creditcard)
+
+        add_verification_value(form, creditcard) if creditcard.verification_value?
+
+        form[:first_name] = creditcard.first_name.to_s.slice(0, 20)
+        form[:last_name] = creditcard.last_name.to_s.slice(0, 30)
+      end
+
+      def add_verification_value(form, creditcard)
+        form[:cvv2cvc2] = creditcard.verification_value
+        form[:cvv2] = 'present'
+      end
+
+      def preamble
+        result = {
+          'merchant_id'   => @options[:login],
+          'pin'           => @options[:password],
+          'show_form'     => 'false',
+          'result_format' => 'ASCII'
+        }
+
+        result['user_id'] = @options[:user] unless @options[:user].blank?
+        result
+      end
+
+      def commit(action, money, parameters)
+        parameters[:amount] = amount(money)
+        parameters[:transaction_type] = self.actions[action]
+
+        response = parse(ssl_post(test? ? self.test_url : self.live_url, post_data(parameters)))
+
+        Response.new(response['result'] == APPROVED, message_from(response), response,
+          test: @options[:test] || test?,
+          authorization: authorization_from(response),
+          avs_result: { code: response['avs_response'] },
+          cvv_result: response['cvv2_response'])
+      end
+
+      def authorization_from(response)
+        response['txn_id']
+      end
+
+      def message_from(response)
+        response['result_message']
+      end
+
+      def post_data(parameters)
+        result = preamble
+        result.merge!(parameters)
+        result.collect { |key, value| "ssl_#{key}=#{CGI.escape(value.to_s)}" }.join('&')
+      end
+
+      # Parse the response message
+      def parse(msg)
+        resp = {}
+        msg.split(self.delimiter).collect { |li|
+          key, value = li.split('=')
+          resp[key.strip.gsub(/^ssl_/, '')] = value.to_s.strip
+        }
+        resp
+      end
+    end
+  end
+end

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

@@ -0,0 +1,250 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class VisanetPeruGateway < Gateway
+      include Empty
+      self.display_name = 'VisaNet Peru Gateway'
+      self.homepage_url = 'http://www.visanet.com.pe'
+
+      self.test_url = 'https://devapi.vnforapps.com/api.tokenization/api/v2/merchant'
+      self.live_url = 'https://api.vnforapps.com/api.tokenization/api/v2/merchant'
+
+      self.supported_countries = %w[US PE]
+      self.default_currency = 'PEN'
+      self.money_format = :dollars
+      self.supported_cardtypes = %i[visa master american_express discover]
+
+      def initialize(options = {})
+        requires!(options, :access_key_id, :secret_access_key, :merchant_id)
+        super
+      end
+
+      def purchase(amount, payment_method, options = {})
+        MultiResponse.run() do |r|
+          r.process { authorize(amount, payment_method, options) }
+          r.process { capture(amount, r.authorization, options) }
+        end
+      end
+
+      def authorize(amount, payment_method, options = {})
+        params = {}
+
+        add_invoice(params, amount, options)
+        add_payment_method(params, payment_method)
+        add_antifraud_data(params, options)
+        params[:email] = options[:email] || 'unknown@email.com'
+        params[:createAlias] = false
+
+        commit('authorize', params, options)
+      end
+
+      def capture(amount, authorization, options = {})
+        params = {}
+        options[:id_unico] = split_authorization(authorization)[1]
+        add_auth_order_id(params, authorization, options)
+        commit('deposit', params, options)
+      end
+
+      def void(authorization, options = {})
+        params = {}
+        add_auth_order_id(params, authorization, options)
+        commit('void', params, options)
+      end
+
+      def refund(amount, authorization, options = {})
+        params = {}
+        params[:amount] = amount(amount) if amount
+        add_auth_order_id(params, authorization, options)
+        response = commit('cancelDeposit', params, options)
+        return response if response.success? || split_authorization(authorization).length == 1 || !options[:force_full_refund_if_unsettled]
+
+        # Attempt RefundSingleTransaction if unsettled (and stash the original
+        # response message so it will be included it in the follow-up response
+        # message)
+        options[:error_message] = response.message
+        prepare_refund_data(params, authorization, options)
+        commit('refund', params, options)
+      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((Authorization: Basic )\w+), '\1[FILTERED]').
+          gsub(%r((\"cardNumber\\\":\\\")\d+), '\1[FILTERED]').
+          gsub(%r((\"cvv2Code\\\":\\\")\d+), '\1[FILTERED]')
+      end
+
+      private
+
+      CURRENCY_CODES = Hash.new { |_h, k| raise ArgumentError.new("Unsupported currency: #{k}") }
+      CURRENCY_CODES['USD'] = 840
+      CURRENCY_CODES['PEN'] = 604
+
+      def add_invoice(params, money, options)
+        # Visanet Peru expects a 12-digit alphanumeric purchaseNumber
+        params[:purchaseNumber] = generate_purchase_number_stamp
+        params[:externalTransactionId] = options[:order_id]
+        params[:amount] = amount(money)
+        params[:currencyId] = CURRENCY_CODES[options[:currency] || currency(money)]
+      end
+
+      def add_auth_order_id(params, authorization, options)
+        purchase_number, = split_authorization(authorization)
+        params[:purchaseNumber] = purchase_number
+        params[:externalTransactionId] = options[:order_id]
+      end
+
+      def add_payment_method(params, payment_method)
+        params[:firstName] = payment_method.first_name
+        params[:lastName] = payment_method.last_name
+        params[:cardNumber] = payment_method.number
+        params[:cvv2Code] = payment_method.verification_value
+        params[:expirationYear] = format(payment_method.year, :four_digits)
+        params[:expirationMonth] = format(payment_method.month, :two_digits)
+      end
+
+      def add_antifraud_data(params, options)
+        antifraud = {}
+
+        if billing_address = options[:billing_address] || options[:address]
+          antifraud[:billTo_street1] = billing_address[:address1]
+          antifraud[:billTo_city] = billing_address[:city]
+          antifraud[:billTo_state] = billing_address[:state]
+          antifraud[:billTo_country] = billing_address[:country]
+          antifraud[:billTo_postalCode] = billing_address[:zip]
+        end
+
+        antifraud[:deviceFingerprintId] = options[:device_fingerprint_id] || SecureRandom.hex(16)
+        antifraud[:merchantDefineData] = options[:merchant_define_data] if options[:merchant_define_data]
+
+        params[:antifraud] = antifraud
+      end
+
+      def prepare_refund_data(params, authorization, options)
+        params.delete(:purchaseNumber)
+        params[:externalReferenceId] = params.delete(:externalTransactionId)
+        _, transaction_id = split_authorization(authorization)
+
+        options.update(transaction_id: transaction_id)
+        params[:ruc] = options[:ruc]
+      end
+
+      def split_authorization(authorization)
+        authorization.split('|')
+      end
+
+      def generate_purchase_number_stamp
+        Time.now.to_f.to_s.delete('.')[1..10] + rand(99).to_s
+      end
+
+      def commit(action, params, options = {})
+        raw_response = ssl_request(method(action), url(action, params, options), params.to_json, headers)
+        response = parse(raw_response)
+      rescue ResponseError => e
+        raw_response = e.response.body
+        response_error(raw_response, options, action)
+      rescue JSON::ParserError
+        unparsable_response(raw_response)
+      else
+        Response.new(
+          success_from(response),
+          message_from(response, options, action),
+          response,
+          test: test?,
+          authorization: authorization_from(params, response, options),
+          error_code: response['errorCode']
+        )
+      end
+
+      def headers
+        {
+          'Authorization' => 'Basic ' + Base64.strict_encode64("#{@options[:access_key_id]}:#{@options[:secret_access_key]}").strip,
+          'Content-Type'  => 'application/json'
+        }
+      end
+
+      def url(action, params, options = {})
+        if action == 'authorize'
+          "#{base_url}/#{@options[:merchant_id]}"
+        elsif action == 'refund'
+          "#{base_url}/#{@options[:merchant_id]}/#{action}/#{options[:transaction_id]}"
+        else
+          "#{base_url}/#{@options[:merchant_id]}/#{action}/#{params[:purchaseNumber]}"
+        end
+      end
+
+      def method(action)
+        %w(authorize refund).include?(action) ? :post : :put
+      end
+
+      def authorization_from(params, response, options)
+        id_unico = response['data']['ID_UNICO'] || options[:id_unico]
+        "#{params[:purchaseNumber]}|#{id_unico}"
+      end
+
+      def base_url
+        test? ? test_url : live_url
+      end
+
+      def parse(body)
+        JSON.parse(body)
+      end
+
+      def success_from(response)
+        response['errorCode'] == 0
+      end
+
+      def message_from(response, options, action)
+        message_from_messages(
+          response['errorMessage'],
+          action_code_description(response),
+          options[:error_message]
+        )
+      end
+
+      def message_from_messages(*args)
+        args.reject { |m| error_message_empty?(m) }.join(' | ')
+      end
+
+      def action_code_description(response)
+        return nil unless response['data']
+
+        response['data']['DSC_COD_ACCION']
+      end
+
+      def error_message_empty?(error_message)
+        empty?(error_message) || error_message == '[ ]'
+      end
+
+      def response_error(raw_response, options, action)
+        response = parse(raw_response)
+      rescue JSON::ParserError
+        unparsable_response(raw_response)
+      else
+        return Response.new(
+          false,
+          message_from(response, options, action),
+          response,
+          test: test?,
+          authorization: response['transactionUUID'],
+          error_code: response['errorCode']
+        )
+      end
+
+      def unparsable_response(raw_response)
+        message = 'Invalid JSON response received from VisanetPeruGateway. Please contact VisanetPeruGateway if you continue to receive this message.'
+        message += " (The raw response returned by the API was #{raw_response.inspect})"
+        return Response.new(false, message)
+      end
+    end
+  end
+end