activemerchant 1.42.6 → 1.90.0

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

@@ -0,0 +1,142 @@
+require 'nokogiri'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class FirstGivingGateway < Gateway
+      self.test_url = 'http://usapisandbox.fgdev.net'
+      self.live_url = 'https://api.firstgiving.com'
+
+      self.supported_countries = ['US']
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+      self.homepage_url = 'http://www.firstgiving.com/'
+      self.default_currency = 'USD'
+      self.display_name = 'FirstGiving'
+
+      def initialize(options = {})
+        requires!(options, :application_key, :security_token, :charity_id)
+        super
+      end
+
+      def purchase(money, creditcard, options = {})
+        post = {}
+        add_invoice(post, options)
+        add_creditcard(post, creditcard)
+        add_address(post, options)
+        add_customer_data(post, options)
+        add_donation_data(post, money, options)
+        commit('/donation/creditcard', post)
+      end
+
+      def refund(money, identifier, options = {})
+        get = {}
+        get[:transactionId] = identifier
+        get[:tranType]     = 'REFUNDREQUEST'
+        commit('/transaction/refundrequest?' + encode(get))
+      end
+
+      private
+
+      def add_donation_data(post, money, options)
+        post[:amount] = amount(money)
+        post[:charityId] = @options[:charity_id]
+        post[:description] = (options[:description] || 'Purchase')
+        post[:currencyCode] = (options[:currency] || currency(money))
+      end
+
+      def add_customer_data(post, options)
+        post[:billToEmail] = (options[:email] || 'activemerchant@example.com')
+        post[:remoteAddr]  = (options[:ip] || '127.0.0.1')
+      end
+
+      def add_address(post, options)
+        if(billing_address = (options[:billing_address] || options[:address]))
+          post[:billToAddressLine1]  = billing_address[:address1]
+          post[:billToCity]          = billing_address[:city]
+          post[:billToState]         = billing_address[:state]
+          post[:billToZip]           = billing_address[:zip]
+          post[:billToCountry]       = billing_address[:country]
+        end
+      end
+
+      def add_invoice(post, options)
+        post[:orderId] = options[:order_id]
+      end
+
+      def add_creditcard(post, creditcard)
+        post[:billToFirstName]     = creditcard.first_name
+        post[:billToLastName]      = creditcard.last_name
+        post[:ccNumber]            = creditcard.number
+        post[:ccType]              = creditcard_brand(creditcard.brand)
+        post[:ccExpDateMonth]      = creditcard.month
+        post[:ccExpDateYear]       = creditcard.year
+        post[:ccCardValidationNum] = creditcard.verification_value
+      end
+
+      def parse(body)
+        response = {}
+
+        xml = Nokogiri::XML(body)
+        element = xml.xpath('//firstGivingDonationApi/firstGivingResponse').first
+
+        element.attributes.each do |name, attribute|
+          response[name] = attribute.content
+        end
+        element.children.each do |child|
+          next if child.text?
+          response[child.name] = child.text
+        end
+
+        response
+      end
+
+      def commit(action, post=nil)
+        url = (test? ? self.test_url : self.live_url) + action
+
+        begin
+          if post
+            response = parse(ssl_post(url, post_data(post), headers))
+          else
+            response = parse(ssl_get(url, headers))
+          end
+        rescue ResponseError => e
+          response = parse(e.response.body)
+        end
+
+        Response.new(
+          (response['acknowledgement'] == 'Success'),
+          (response['friendlyErrorMessage'] || response['verboseErrorMessage'] || response['acknowledgement']),
+          response,
+          authorization: response['transactionId'],
+          test: test?
+        )
+      end
+
+      def post_data(post)
+        post.collect { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join('&')
+      end
+
+      def encode(hash)
+        hash.collect { |(k, v)| "#{CGI.escape(k.to_s)}=#{CGI.escape(v.to_s)}" }.join('&')
+      end
+
+      def creditcard_brand(brand)
+        case brand
+        when 'visa' then 'VI'
+        when 'master' then 'MC'
+        when 'discover' then 'DI'
+        when 'american_express' then 'AX'
+        else
+          raise "Unhandled credit card brand #{brand}"
+        end
+      end
+
+      def headers
+        {
+          'User-Agent'        => "ActiveMerchantBindings/#{ActiveMerchant::VERSION}",
+          'JG_APPLICATIONKEY' => @options[:application_key].to_s,
+          'JG_SECURITYTOKEN'  => @options[:security_token].to_s
+        }
+      end
+    end
+  end
+end

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

@@ -1,176 +1,182 @@
+require 'nokogiri'
+
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
     class FirstPayGateway < Gateway
-      class FirstPayPostData < PostData
-        # Fields that will be sent even if they are blank
-        self.required_fields = [ :action, :amount, :trackid ]
-      end
+      self.live_url = 'https://secure.goemerchant.com/secure/gateway/xmlgateway.aspx'
 
-      # both URLs are IP restricted
-      self.test_url = 'https://apgcert.first-pay.com/AcqENGIN/SecureCapture'
-      self.live_url = 'https://acqengin.first-pay.com/AcqENGIN/SecureCapture'
-
-      # The countries the gateway supports merchants from as 2 digit ISO country codes
       self.supported_countries = ['US']
+      self.default_currency = 'USD'
+      self.money_format = :dollars
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
 
-      # The card types supported by the payment gateway
-      self.supported_cardtypes = [:visa, :master]
-
-      # The homepage URL of the gateway
-      self.homepage_url = 'http://www.first-pay.com'
+      self.homepage_url = 'http://1stpaygateway.net/'
+      self.display_name = '1stPayGateway.Net'
 
-      # The name of the gateway
-      self.display_name = 'First Pay'
-
-      # all transactions are in cents
-      self.money_format = :cents
-
-      ACTIONS = {
-        'sale' => 1,
-        'credit' => 2,
-        'void' => 3
-      }
-
-      def initialize(options = {})
-        requires!(options, :login, :password)
+      def initialize(options={})
+        requires!(options, :transaction_center_id, :gateway_id)
         super
       end
 
-      def purchase(money, creditcard, options = {})
-        post = FirstPayPostData.new
-        add_invoice(post, options)
-        add_creditcard(post, creditcard)
-        add_address(post, options)
+      def purchase(money, payment, options={})
+        post = {}
+        add_invoice(post, money, options)
+        add_payment(post, payment, options)
+        add_address(post, payment, options)
         add_customer_data(post, options)
 
-        commit('sale', money, post)
+        commit('sale', post)
       end
 
-      def refund(money, reference, options = {})
-        requires!(options, :credit_card)
-
-        post = FirstPayPostData.new
-        add_invoice(post, options)
-        add_creditcard(post, options[:credit_card])
-        add_address(post, options)
+      def authorize(money, payment, options={})
+        post = {}
+        add_invoice(post, money, options)
+        add_payment(post, payment, options)
+        add_address(post, payment, options)
         add_customer_data(post, options)
-        add_credit_data(post, reference)
 
-        commit('credit', money, post)
+        commit('auth', post)
       end
 
-      def credit(money, reference, options = {})
-        deprecated CREDIT_DEPRECATION_MESSAGE
-        refund(money, reference, options)
+      def capture(money, authorization, options={})
+        post = {}
+        add_reference(post, 'settle', money, authorization)
+        commit('settle', post)
       end
 
-      def void(money, creditcard, options = {})
-        post = FirstPayPostData.new
-        add_creditcard(post, creditcard)
-        add_void_data(post, options)
-        add_invoice(post, options)
-        add_customer_data(post, options)
+      def refund(money, authorization, options={})
+        post = {}
+        add_reference(post, 'credit', money, authorization)
+        commit('credit', post)
+      end
 
-        commit('void', money, post)
+      def void(authorization, options={})
+        post = {}
+        add_reference(post, 'void', nil, authorization)
+        commit('void', post)
       end
 
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((gateway_id)[^<]*(</FIELD>))i, '\1[FILTERED]\2').
+          gsub(%r((card_number)[^<]*(</FIELD>))i, '\1[FILTERED]\2').
+          gsub(%r((cvv2)[^<]*(</FIELD>))i, '\1[FILTERED]\2')
+      end
 
       private
 
-      def add_customer_data(post, options)
-        post[:cardip] = options[:ip]
-        post[:email] = options[:email]
+      def add_authentication(post, options)
+        post[:transaction_center_id] = options[:transaction_center_id]
+        post[:gateway_id] = options[:gateway_id]
       end
 
-      def add_address(post, options)
-        if billing_address = options[:billing_address] || options[:address]
-          post[:addr]     = billing_address[:address1].to_s + ' ' + billing_address[:address2].to_s
-          post[:city]     = billing_address[:city]
-          post[:state]    = billing_address[:state]
-          post[:zip]      = billing_address[:zip]
-          post[:country]  = billing_address[:country]
+      def add_customer_data(post, options)
+        post[:owner_email] = options[:email] if options[:email]
+        post[:remote_ip_address] = options[:ip] if options[:ip]
+        post[:processor_id] = options[:processor_id] if options[:processor_id]
+      end
+
+      def add_address(post, creditcard, options)
+        if address = options[:billing_address] || options[:address]
+          post[:owner_name] = address[:name]
+          post[:owner_street] = address[:address1]
+          post[:owner_street2] = address[:address2] if address[:address2]
+          post[:owner_city] = address[:city]
+          post[:owner_state] = address[:state]
+          post[:owner_zip] = address[:zip]
+          post[:owner_country] = address[:country]
+          post[:owner_phone] = address[:phone] if address[:phone]
         end
       end
 
-      def add_invoice(post, options)
-        post[:trackid] = rand(Time.now.to_i)
+      def add_invoice(post, money, options)
+        post[:order_id] = options[:order_id]
+        post[:total] = amount(money)
       end
 
-      def add_creditcard(post, creditcard)
-        post[:member] = creditcard.first_name.to_s + " " + creditcard.last_name.to_s
-        post[:card] = creditcard.number
-        post[:exp] = expdate(creditcard)
+      def add_payment(post, payment, options)
+        post[:card_name] = payment.brand # Unclear if need to map to known names or open text field??
+        post[:card_number] = payment.number
+        post[:card_exp] = expdate(payment)
+        post[:cvv2] = payment.verification_value
+        post[:recurring] = options[:recurring] if options[:recurring]
+        post[:recurring_start_date] = options[:recurring_start_date] if options[:recurring_start_date]
+        post[:recurring_end_date] = options[:recurring_end_date] if options[:recurring_end_date]
+        post[:recurring_type] = options[:recurring_type] if options[:recurring_type]
       end
 
-      def expdate(credit_card)
-        year  = sprintf("%.4i", credit_card.year)
-        month = sprintf("%.2i", credit_card.month)
-
-        "#{month}#{year[-2..-1]}"
+      def add_reference(post, action, money, authorization)
+        post[:"#{action}_amount1"] = amount(money) if money
+        post[:total_number_transactions] = 1
+        post[:reference_number1] = authorization
       end
 
-      def add_credit_data(post, transaction_id)
-        post[:transid] = transaction_id
-      end
+      def parse(xml)
+        response = {}
 
-      def add_void_data(post, options)
-        post[:transid] = options[:transactionid]
+        doc = Nokogiri::XML(xml)
+        doc.root&.xpath('//RESPONSE/FIELDS/FIELD')&.each do |field|
+          response[field['KEY']] = field.text
+        end
+
+        response
       end
 
-      def commit(action, money, post)
-        response = parse( ssl_post(test? ? self.test_url : self.live_url, post_data(action, post, money)) )
+      def commit(action, parameters)
+        response = parse(ssl_post(live_url, post_data(action, parameters)))
 
-        Response.new(response[:response] == 'CAPTURED', response[:message], response,
-          :test => test?,
-          :authorization => response[:authorization],
-          :avs_result => { :code => response[:avsresponse] },
-          :cvv_result => response[:cvvresponse])
+        Response.new(
+          success_from(response),
+          message_from(response),
+          response,
+          authorization: authorization_from(response),
+          error_code: error_code_from(response),
+          test: test?
+        )
       end
 
-      def parse(body)
-        response = {}
+      def success_from(response)
+        (
+          (response['status'] == '1') ||
+          (response['status1'] == '1')
+        )
+      end
 
-        # check for an error first
-        if body.include?('!ERROR!')
-          response[:response] = 'ERROR'
-          response[:message] = error_message_from(body)
-        else
-          # a capture / not captured response will be : delimited
-          split = body.split(':')
-          response[:response] = split[0]
-
-          # FirstPay docs are worthless. turns out the transactionid is required for credits
-          # so we need to store that in authorization, not the actual auth.
-          if response[:response] == 'CAPTURED'
-            response[:message] = 'CAPTURED'
-            response[:authorization] = split[9] # actually the transactionid
-            response[:auth] = split[1]
-            response[:avsresponse] = split[3]
-            response[:cvvresponse] = split[17]
-          else
-            # NOT CAPTURED response
-            response[:message] = split[1]
-            response[:transactionid] = split[9]
-          end
-        end
+      def message_from(response)
+        # Silly inconsistent gateway. Always make capitalized (but not all caps)
+        msg = (response['auth_response'] || response['response1'])
+        msg&.downcase&.capitalize
+      end
 
-        return response
+      def error_code_from(response)
+        response['error']
       end
 
-      def error_message_from(response)
-        # error messages use this format - '!ERROR! 704-MISSING BASIC DATA TYPE:card, exp, zip, addr, member, amount\n'
-        response.split("! ")[1].chomp
+      def authorization_from(response)
+        response['reference_number'] || response['reference_number1']
       end
 
-      def post_data(action, post, money)
-        post[:vid]        = @options[:login]
-        post[:password]   = @options[:password]
-        post[:action]     = ACTIONS[action]
-        post[:amount]     = amount(money)
+      def post_data(action, parameters = {})
+        parameters[:transaction_center_id] = @options[:transaction_center_id]
+        parameters[:gateway_id] = @options[:gateway_id]
+
+        parameters[:operation_type] = action
 
-        return post.to_post_data
+        xml = Builder::XmlMarkup.new
+        xml.instruct!
+        xml.tag! 'TRANSACTION' do
+          xml.tag! 'FIELDS' do
+            parameters.each do |key, value|
+              xml.tag! 'FIELD', value, { 'KEY' => key }
+            end
+          end
+        end
+        xml.target!
       end
     end
   end
 end
-