archetype2142_activemerchant 1.124.0

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

@@ -0,0 +1,312 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class IatsPaymentsGateway < Gateway
+      class_attribute :live_na_url, :live_uk_url
+
+      self.live_na_url = 'https://www.iatspayments.com/NetGate'
+      self.live_uk_url = 'https://www.uk.iatspayments.com/NetGate'
+
+      self.supported_countries = %w(AU BR CA CH DE DK ES FI FR GR HK IE IT NL NO PT SE SG TR GB US TH ID PH BE)
+      self.default_currency = 'USD'
+      self.supported_cardtypes = %i[visa master american_express discover]
+
+      self.homepage_url = 'http://home.iatspayments.com/'
+      self.display_name = 'iATS Payments'
+
+      ACTIONS = {
+        purchase: 'ProcessCreditCard',
+        purchase_check: 'ProcessACHEFT',
+        purchase_customer_code: 'ProcessCreditCardWithCustomerCode',
+        refund: 'ProcessCreditCardRefundWithTransactionId',
+        refund_check: 'ProcessACHEFTRefundWithTransactionId',
+        store: 'CreateCreditCardCustomerCode',
+        unstore: 'DeleteCustomerCode'
+      }
+
+      def initialize(options = {})
+        if options[:login]
+          ActiveMerchant.deprecated("The 'login' option is deprecated in favor of 'agent_code' and will be removed in a future version.")
+          options[:agent_code] = options[:login]
+        end
+
+        options[:region] = 'na' unless options[:region]
+
+        requires!(options, :agent_code, :password, :region)
+        super
+      end
+
+      def purchase(money, payment, options = {})
+        post = {}
+        add_invoice(post, money, options)
+        add_payment(post, payment)
+        add_address(post, options)
+        add_ip(post, options)
+        add_description(post, options)
+        add_customer_details(post, options)
+
+        commit(determine_purchase_type(payment), post)
+      end
+
+      def refund(money, authorization, options = {})
+        post = {}
+        transaction_id, payment_type = split_authorization(authorization)
+        post[:transaction_id] = transaction_id
+        add_invoice(post, -money, options)
+        add_ip(post, options)
+        add_description(post, options)
+
+        commit((payment_type == 'check' ? :refund_check : :refund), post)
+      end
+
+      def store(credit_card, options = {})
+        post = {}
+        add_payment(post, credit_card)
+        add_address(post, options)
+        add_ip(post, options)
+        add_description(post, options)
+        add_store_defaults(post)
+
+        commit(:store, post)
+      end
+
+      def unstore(authorization, options = {})
+        post = {}
+        post[:customer_code] = authorization
+        add_ip(post, options)
+
+        commit(:unstore, post)
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((<agentCode>).+(</agentCode>)), '\1[FILTERED]\2').
+          gsub(%r((<password>).+(</password>)), '\1[FILTERED]\2').
+          gsub(%r((<creditCardNum>).+(</creditCardNum>)), '\1[FILTERED]\2').
+          gsub(%r((<cvv2>).+(</cvv2>)), '\1[FILTERED]\2').
+          gsub(%r((<accountNum>).+(</accountNum>)), '\1[FILTERED]\2')
+      end
+
+      private
+
+      def determine_purchase_type(payment)
+        if payment.is_a?(String)
+          :purchase_customer_code
+        elsif payment.is_a?(Check)
+          :purchase_check
+        else
+          :purchase
+        end
+      end
+
+      def add_ip(post, options)
+        post[:customer_ip_address] = options[:ip] if options.has_key?(:ip)
+      end
+
+      def add_address(post, options)
+        billing_address = options[:billing_address] || options[:address]
+        if billing_address
+          post[:address] = billing_address[:address1]
+          post[:city] = billing_address[:city]
+          post[:state] = billing_address[:state]
+          post[:zip_code] = billing_address[:zip]
+          post[:phone] = billing_address[:phone] if billing_address[:phone]
+          post[:email] = billing_address[:email] if billing_address[:email]
+          post[:country] = billing_address[:country] if billing_address[:country]
+        end
+      end
+
+      def add_invoice(post, money, options)
+        post[:invoice_num] = options[:order_id] if options[:order_id]
+        post[:total] = amount(money)
+      end
+
+      def add_description(post, options)
+        post[:comment] = options[:description] if options[:description]
+      end
+
+      def add_payment(post, payment)
+        if payment.is_a?(String)
+          post[:customer_code] = payment
+        elsif payment.is_a?(Check)
+          add_check(post, payment)
+        else
+          add_credit_card(post, payment)
+        end
+      end
+
+      def add_credit_card(post, payment)
+        post[:first_name] = payment.first_name
+        post[:last_name] = payment.last_name
+        post[:credit_card_num] = payment.number
+        post[:credit_card_expiry] = expdate(payment)
+        post[:cvv2] = payment.verification_value if payment.verification_value?
+        post[:mop] = creditcard_brand(payment.brand)
+      end
+
+      def add_check(post, payment)
+        post[:first_name] = payment.first_name
+        post[:last_name] = payment.last_name
+        post[:account_num] = "#{payment.routing_number}#{payment.account_number}"
+        post[:account_type] = payment.account_type.upcase
+      end
+
+      def add_store_defaults(post)
+        post[:recurring] = false
+        post[:begin_date] = Time.now.xmlschema
+        post[:end_date] = Time.now.xmlschema
+        post[:amount] = 0
+      end
+
+      def add_customer_details(post, options)
+        post[:email] = options[:email] if options[:email]
+      end
+
+      def expdate(creditcard)
+        year  = sprintf('%.4i', creditcard.year)
+        month = sprintf('%.2i', creditcard.month)
+
+        "#{month}/#{year[-2..-1]}"
+      end
+
+      def creditcard_brand(brand)
+        case brand
+        when 'visa' then 'VISA'
+        when 'master' then 'MC'
+        when 'discover' then 'DSC'
+        when 'american_express' then 'AMX'
+        when 'maestro' then 'MAESTR'
+        else
+          raise "Unhandled credit card brand #{brand}"
+        end
+      end
+
+      def commit(action, parameters)
+        response = parse(ssl_post(url(action), post_data(action, parameters),
+          { 'Content-Type' => 'application/soap+xml; charset=utf-8' }))
+
+        Response.new(
+          success_from(response),
+          message_from(response),
+          response,
+          authorization: authorization_from(action, response),
+          test: test?
+        )
+      end
+
+      def endpoints
+        {
+          purchase: 'ProcessLinkv3.asmx',
+          purchase_check: 'ProcessLinkv3.asmx',
+          purchase_customer_code: 'ProcessLinkv3.asmx',
+          refund: 'ProcessLinkv3.asmx',
+          refund_check: 'ProcessLinkv3.asmx',
+          store: 'CustomerLinkv3.asmx',
+          unstore: 'CustomerLinkv3.asmx'
+        }
+      end
+
+      def url(action)
+        base_url = @options[:region] == 'uk' ? live_uk_url : live_na_url
+        "#{base_url}/#{endpoints[action]}?op=#{ACTIONS[action]}"
+      end
+
+      def parse(body)
+        response = {}
+        hashify_xml!(body, response)
+        response
+      end
+
+      def dexmlize_param_name(name)
+        names = {
+          'AUTHORIZATIONRESULT' => :authorization_result,
+          'SETTLEMENTBATCHDATE' => :settlement_batch_date,
+          'SETTLEMENTDATE' => :settlement_date,
+          'TRANSACTIONID' => :transaction_id
+        }
+        names[name] || name.to_s.downcase.intern
+      end
+
+      def hashify_xml!(xml, response)
+        xml = REXML::Document.new(xml)
+
+        xml.elements.each('//IATSRESPONSE/*') do |node|
+          recursively_parse_element(node, response)
+        end
+      end
+
+      def recursively_parse_element(node, response)
+        if node.has_elements?
+          node.elements.each { |n| recursively_parse_element(n, response) }
+        else
+          response[dexmlize_param_name(node.name)] = (node.text ? node.text.strip : nil)
+        end
+      end
+
+      def successful_result_message?(response)
+        response[:authorization_result] ? response[:authorization_result].start_with?('OK') : false
+      end
+
+      def success_from(response)
+        response[:status] == 'Success' && successful_result_message?(response)
+      end
+
+      def message_from(response)
+        if !successful_result_message?(response) && response[:authorization_result]
+          return response[:authorization_result].strip
+        elsif response[:status] == 'Failure'
+          return response[:errors]
+        else
+          response[:status]
+        end
+      end
+
+      def authorization_from(action, response)
+        if %i[store unstore].include?(action)
+          response[:customercode]
+        elsif [:purchase_check].include?(action)
+          response[:transaction_id] ? "#{response[:transaction_id]}|check" : nil
+        else
+          response[:transaction_id]
+        end
+      end
+
+      def split_authorization(authorization)
+        authorization.split('|')
+      end
+
+      def envelope_namespaces
+        {
+          'xmlns:xsi' => 'http://www.w3.org/2001/XMLSchema-instance',
+          'xmlns:xsd' => 'http://www.w3.org/2001/XMLSchema',
+          'xmlns:soap12' => 'http://www.w3.org/2003/05/soap-envelope'
+        }
+      end
+
+      def post_data(action, parameters = {})
+        xml = Builder::XmlMarkup.new
+        xml.instruct!(:xml, version: '1.0', encoding: 'utf-8')
+        xml.tag! 'soap12:Envelope', envelope_namespaces do
+          xml.tag! 'soap12:Body' do
+            xml.tag! ACTIONS[action], { 'xmlns' => 'https://www.iatspayments.com/NetGate/' } do
+              xml.tag!('agentCode', @options[:agent_code])
+              xml.tag!('password', @options[:password])
+              parameters.each do |name, value|
+                xml.tag!(xmlize_param_name(name), value)
+              end
+            end
+          end
+        end
+        xml.target!
+      end
+
+      def xmlize_param_name(name)
+        names = { customer_ip_address: 'customerIPAddress' }
+        names[name] || name.to_s.camelcase(:lower)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class InContextPaypalExpressGateway < PaypalExpressGateway
+      self.test_redirect_url = 'https://www.sandbox.paypal.com/checkoutnow'
+      self.live_redirect_url = 'https://www.paypal.com/checkoutnow'
+
+      def redirect_url_for(token, options = {})
+        options = { review: true }.update(options)
+        url  = "#{redirect_url}?token=#{token}"
+        url += '&useraction=commit' unless options[:review]
+        url
+      end
+    end
+  end
+end

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

@@ -0,0 +1,213 @@
+require File.join(File.dirname(__FILE__), '..', 'check.rb')
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class InspireGateway < Gateway
+      self.live_url = self.test_url = 'https://secure.inspiregateway.net/api/transact.php'
+
+      self.supported_countries = ['US']
+      self.supported_cardtypes = %i[visa master american_express]
+      self.homepage_url = 'http://www.inspiregateway.com'
+      self.display_name = 'Inspire Commerce'
+
+      # Creates a new InspireGateway
+      #
+      # The gateway requires that a valid login and password be passed
+      # in the +options+ hash.
+      #
+      # ==== Options
+      #
+      # * <tt>:login</tt> -- The Inspire Username.
+      # * <tt>:password</tt> -- The Inspire Password.
+      # See the Inspire Integration Guide for details. (default: +false+)
+      def initialize(options = {})
+        requires!(options, :login, :password)
+        super
+      end
+
+      # Pass :store => true in the options to store the
+      # payment info at Inspire Gateway and get a generated
+      # customer_vault_id in the response.
+      # Pass :store => some_number_or_string to specify the
+      # customer_vault_id InspireGateway should use (make sure it's
+      # unique).
+      def authorize(money, creditcard, options = {})
+        post = {}
+        add_invoice(post, options)
+        add_payment_source(post, creditcard, options)
+        add_address(post, creditcard, options)
+        add_customer_data(post, options)
+
+        commit('auth', money, post)
+      end
+
+      def purchase(money, payment_source, options = {})
+        post = {}
+        add_invoice(post, options)
+        add_payment_source(post, payment_source, options)
+        add_address(post, payment_source, options)
+        add_customer_data(post, options)
+
+        commit('sale', money, post)
+      end
+
+      def capture(money, authorization, options = {})
+        post = {}
+        post[:transactionid] = authorization
+        commit('capture', money, post)
+      end
+
+      def void(authorization, options = {})
+        post = {}
+        post[:transactionid] = authorization
+        commit('void', nil, post)
+      end
+
+      def refund(money, authorization, options = {})
+        post = {}
+        post[:transactionid] = authorization
+        commit('refund', money, post)
+      end
+
+      # Update the values (such as CC expiration) stored at
+      # InspireGateway.  The CC number must be supplied in the
+      # CreditCard object.
+      def update(vault_id, creditcard, options = {})
+        post = {}
+        post[:customer_vault] = 'update_customer'
+        add_customer_vault_id(post, vault_id)
+        add_creditcard(post, creditcard, options)
+        add_address(post, creditcard, options)
+        add_customer_data(post, options)
+
+        commit(nil, nil, post)
+      end
+
+      def delete(vault_id)
+        post = {}
+        post[:customer_vault] = 'delete_customer'
+        add_customer_vault_id(post, vault_id)
+        commit(nil, nil, post)
+      end
+
+      # To match the other stored-value gateways, like TrustCommerce,
+      # store and unstore need to be defined
+      def store(creditcard, options = {})
+        billing_id = options.delete(:billing_id).to_s || true
+        authorize(100, creditcard, options.merge(store: billing_id))
+      end
+
+      alias unstore delete
+
+      private
+
+      def add_customer_data(post, options)
+        post[:email] = options[:email] if options.has_key? :email
+
+        post[:ipaddress] = options[:ip] if options.has_key? :ip
+      end
+
+      def add_address(post, creditcard, options)
+        if address = options[:billing_address] || options[:address]
+          post[:address1]    = address[:address1].to_s
+          post[:address2]    = address[:address2].to_s unless address[:address2].blank?
+          post[:company]     = address[:company].to_s
+          post[:phone]       = address[:phone].to_s
+          post[:zip]         = address[:zip].to_s
+          post[:city]        = address[:city].to_s
+          post[:country]     = address[:country].to_s
+          post[:state]       = address[:state].blank? ? 'n/a' : address[:state]
+        end
+      end
+
+      def add_invoice(post, options)
+        post[:orderid] = options[:order_id].to_s.gsub(/[^\w.]/, '')
+        post[:orderdescription] = options[:description]
+      end
+
+      def add_payment_source(params, source, options = {})
+        case determine_funding_source(source)
+        when :vault       then add_customer_vault_id(params, source)
+        when :credit_card then add_creditcard(params, source, options)
+        when :check       then add_check(params, source)
+        end
+      end
+
+      def add_customer_vault_id(params, vault_id)
+        params[:customer_vault_id] = vault_id
+      end
+
+      def add_creditcard(post, creditcard, options)
+        if options[:store]
+          post[:customer_vault] = 'add_customer'
+          post[:customer_vault_id] = options[:store] unless options[:store] == true
+        end
+        post[:ccnumber] = creditcard.number
+        post[:cvv] = creditcard.verification_value if creditcard.verification_value?
+        post[:ccexp] = expdate(creditcard)
+        post[:firstname] = creditcard.first_name
+        post[:lastname]  = creditcard.last_name
+      end
+
+      def add_check(post, check)
+        post[:payment] = 'check' # Set transaction to ACH
+        post[:checkname] = check.name # The name on the customer's Checking Account
+        post[:checkaba] = check.routing_number # The customer's bank routing number
+        post[:checkaccount] = check.account_number # The customer's account number
+        post[:account_holder_type] = check.account_holder_type # The customer's type of ACH account
+        post[:account_type] = check.account_type # The customer's type of ACH account
+      end
+
+      def parse(body)
+        results = {}
+        body.split(/&/).each do |pair|
+          key, val = pair.split(%r{=})
+          results[key] = val
+        end
+
+        results
+      end
+
+      def commit(action, money, parameters)
+        parameters[:amount] = amount(money) if money
+
+        response = parse(ssl_post(self.live_url, post_data(action, parameters)))
+
+        Response.new(response['response'] == '1', message_from(response), response,
+          authorization: response['transactionid'],
+          test: test?,
+          cvv_result: response['cvvresponse'],
+          avs_result: { code: response['avsresponse'] })
+      end
+
+      def message_from(response)
+        case response['responsetext']
+        when 'SUCCESS', 'Approved'
+          'This transaction has been approved'
+        when 'DECLINE'
+          'This transaction has been declined'
+        else
+          response['responsetext']
+        end
+      end
+
+      def post_data(action, parameters = {})
+        post = {}
+        post[:username]   = @options[:login]
+        post[:password]   = @options[:password]
+        post[:type]       = action if action
+
+        request = post.merge(parameters).map { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join('&')
+        request
+      end
+
+      def determine_funding_source(source)
+        case
+        when source.is_a?(String) then :vault
+        when CreditCard.card_companies.include?(card_brand(source)) then :credit_card
+        when card_brand(source) == 'check' then :check
+        else raise ArgumentError, 'Unsupported funding source provided'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,159 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class InstapayGateway < Gateway
+      self.live_url = 'https://trans.instapaygateway.com/cgi-bin/process.cgi'
+
+      # The countries the gateway supports merchants from as 2 digit ISO country codes
+      self.supported_countries = ['US']
+      self.money_format = :dollars
+      self.default_currency = 'USD'
+      # The card types supported by the payment gateway
+      self.supported_cardtypes = %i[visa master american_express discover]
+
+      # The homepage URL of the gateway
+      self.homepage_url = 'http://www.instapayllc.com'
+
+      # The name of the gateway
+      self.display_name = 'InstaPay'
+
+      SUCCESS         = 'Accepted'
+      SUCCESS_MESSAGE = 'The transaction has been approved'
+
+      def initialize(options = {})
+        requires!(options, :login)
+        super
+      end
+
+      def authorize(money, creditcard, options = {})
+        post = {}
+        post[:authonly] = 1
+        add_amount(post, money)
+        add_invoice(post, options)
+        add_creditcard(post, creditcard)
+        add_address(post, options)
+        add_customer_data(post, options)
+
+        commit('ns_quicksale_cc', post)
+      end
+
+      def purchase(money, creditcard, options = {})
+        post = {}
+        add_amount(post, money)
+        add_invoice(post, options)
+        add_creditcard(post, creditcard)
+        add_address(post, options)
+        add_customer_data(post, options)
+
+        commit('ns_quicksale_cc', post)
+      end
+
+      def capture(money, authorization, options = {})
+        post = {}
+        add_amount(post, money)
+        add_reference(post, authorization)
+        commit('ns_quicksale_cc', post)
+      end
+
+      private
+
+      def add_amount(post, money)
+        post[:amount] = amount(money)
+      end
+
+      def add_reference(post, reference)
+        post[:postonly] = reference
+      end
+
+      def add_customer_data(post, options)
+        post[:ci_email]       = options[:email]
+        post['ci_IP Address'] = options[:ip]
+      end
+
+      def add_address(post, options)
+        if address = options[:billing_address] || options[:address]
+          post[:ci_billaddr1]   = address[:address1]
+          post[:ci_billaddr2]   = address[:address2]
+          post[:ci_billcity]    = address[:city]
+          post[:ci_billstate]   = address[:state]
+          post[:ci_billzip]     = address[:zip]
+          post[:ci_billcountry] = address[:country]
+          post[:ci_phone]       = address[:phone]
+        end
+
+        if address = options[:shipping_address]
+          post[:ci_shipaddr1]   = address[:address1]
+          post[:ci_shipaddr2]   = address[:address2]
+          post[:ci_shipcity]    = address[:city]
+          post[:ci_shipstate]   = address[:state]
+          post[:ci_shipzip]     = address[:zip]
+          post[:ci_shipcountry] = address[:country]
+        end
+      end
+
+      def add_invoice(post, options)
+        post[:merchantordernumber] = options[:order_id]
+        post[:ci_memo]             = options[:description]
+        post[:pocustomerrefid]     = options[:invoice]
+      end
+
+      def add_creditcard(post, creditcard)
+        post[:ccnum]   = creditcard.number
+        post[:expmon]  = format(creditcard.month, :two_digits)
+        post[:cvv2]    = creditcard.verification_value if creditcard.verification_value?
+        post[:expyear] = creditcard.year
+        post[:ccname]  = creditcard.name
+      end
+
+      def parse(body)
+        results = {}
+        fields = body.split("\r\n")
+
+        response = fields[1].split('=')
+        response_data = response[1].split(':')
+
+        if response[0] == SUCCESS
+          results[:success] = true
+          results[:message] = SUCCESS_MESSAGE
+          results[:transaction_type] = response_data[0]
+          results[:authorization_code] = response_data[1]
+          results[:reference_number] = response_data[2]
+          results[:batch_number] = response_data[3]
+          results[:transaction_id] = response_data[4]
+          results[:avs_result] = response_data[5]
+          results[:authorize_net] = response_data[6]
+          results[:cvv_result] = response_data[7]
+        else
+          results[:success] = false
+          results[:result] = response_data[0]
+          results[:response_code] = response_data[1]
+          results[:message] = response_data[2]
+        end
+
+        fields[1..-1].each do |pair|
+          key, value = pair.split('=')
+          results[key] = value
+        end
+        results
+      end
+
+      def commit(action, parameters)
+        data = ssl_post self.live_url, post_data(action, parameters)
+        response = parse(data)
+
+        Response.new(response[:success], response[:message], response,
+          authorization: response[:transaction_id],
+          avs_result: { code: response[:avs_result] },
+          cvv_result: response[:cvv_result])
+      end
+
+      def post_data(action, parameters = {})
+        post = {}
+        post[:acctid] = @options[:login]
+        post[:merchantpin] = @options[:password] if @options[:password]
+        post[:action] = action
+        request = post.merge(parameters).collect { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join('&')
+        request
+      end
+    end
+  end
+end