activemerchant 1.38.0 → 1.79.2

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

@@ -0,0 +1,224 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    # For more information visit {Transact Pro Services}[https://www.transactpro.lv/business/]
+    #
+    # This gateway was formerly associated with www.1stpayments.net
+    #
+    # Written by Piers Chambers (Varyonic.com)
+    class TransactProGateway < Gateway
+      self.test_url = 'https://gw2sandbox.tpro.lv:8443/gw2test/gwprocessor2.php'
+      self.live_url = 'https://www2.1stpayments.net/gwprocessor2.php'
+
+      self.supported_countries = ['US']
+      self.default_currency = 'USD'
+      self.money_format = :cents
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+
+      self.homepage_url = 'https://www.transactpro.lv/business/online-payments-acceptance'
+      self.display_name = 'Transact Pro'
+
+      def initialize(options={})
+        requires!(options, :guid, :password, :terminal)
+        super
+      end
+
+      def purchase(amount, payment, options={})
+        post = PostData.new
+        add_invoice(post, amount, options)
+        add_payment(post, payment)
+        add_address(post, payment, options)
+        add_customer_data(post, options)
+        add_credentials(post)
+        post[:rs] = @options[:terminal]
+
+        MultiResponse.run do |r|
+          r.process{commit('init', post)}
+          r.process do
+            post = PostData.new
+            post[:init_transaction_id] = r.authorization
+            add_payment_cc(post, payment)
+            post[:f_extended] = '4'
+
+            commit('charge', post, amount)
+          end
+        end
+      end
+
+      def authorize(amount, payment, options={})
+        post = PostData.new
+        add_invoice(post, amount, options)
+        add_payment(post, payment)
+        add_address(post, payment, options)
+        add_customer_data(post, options)
+        add_credentials(post)
+        post[:rs] = @options[:terminal]
+
+        MultiResponse.run do |r|
+          r.process{commit('init_dms', post)}
+          r.process do
+            post = PostData.new
+            post[:init_transaction_id] = r.authorization
+            add_payment_cc(post, payment)
+            post[:f_extended] = '4'
+
+            commit('make_hold', post, amount)
+          end
+        end
+      end
+
+      def capture(amount, authorization, options={})
+        identifier, original_amount = split_authorization(authorization)
+        if amount && (amount != original_amount)
+          raise ArgumentError.new("Partial capture is not supported, and #{amount.inspect} != #{original_amount.inspect}")
+        end
+
+        post = PostData.new
+        add_credentials(post)
+        post[:init_transaction_id] = identifier
+        post[:f_extended] = '4'
+
+        commit('charge_hold', post, original_amount)
+      end
+
+      def refund(amount, authorization, options={})
+        identifier, original_amount = split_authorization(authorization)
+
+        post = PostData.new
+        add_credentials(post, :account_guid)
+        post[:init_transaction_id] = identifier
+        post[:amount_to_refund] = amount(amount || original_amount)
+
+        commit('refund', post)
+      end
+
+      def void(authorization, options={})
+        identifier, amount = split_authorization(authorization)
+
+        post = PostData.new
+        add_credentials(post, :account_guid)
+        post[:init_transaction_id] = identifier
+        post[:amount_to_refund] = amount(amount)
+        commit('cancel_dms', 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
+
+      private
+
+      def add_customer_data(post, options)
+        post[:email] = (options[:email] || 'noone@example.com')
+        post[:user_ip] = (options[:ip] || '127.0.0.1')
+      end
+
+      def add_address(post, creditcard, options)
+        if address = options[:billing_address]
+          post[:street]  = address[:address1].to_s
+          post[:city]    = address[:city].to_s
+          post[:state]   = (address[:state].blank? ? 'NA' : address[:state].to_s)
+          post[:zip]     = address[:zip].to_s
+          post[:country] = address[:country].to_s
+          post[:phone]   = (address[:phone].to_s.gsub(/[^0-9]/, '') || "0000000")
+        end
+
+        if address = options[:shipping_address]
+          post[:shipping_name]    = "#{address.first_name} #{address.last_name}"
+          post[:shipping_street]  = address[:address1].to_s
+          post[:shipping_phone]   = address[:phone].to_s
+          post[:shipping_zip]     = address[:zip].to_s
+          post[:shipping_city]    = address[:city].to_s
+          post[:shipping_country] = address[:country].to_s
+          post[:shipping_state]   = (address[:state].blank? ? 'NA' : address[:state].to_s)
+          post[:shipping_email]   = (options[:email] || 'noone@example.com')
+        end
+      end
+
+      def add_invoice(post, money, options)
+        post[:merchant_transaction_id] = options[:order_id] if options[:order_id]
+        post[:amount] = amount(money)
+        post[:currency] = (options[:currency] || currency(money))
+        post[:description] = options[:description]
+        post[:merchant_site_url] = options[:merchant]
+      end
+
+      def add_payment(post, payment)
+        post[:name_on_card] = "#{payment.first_name} #{payment.last_name}"
+        post[:card_bin] = payment.first_digits
+      end
+
+      def add_payment_cc(post, credit_card)
+        post[:cc] = credit_card.number
+        post[:cvv] = credit_card.verification_value if credit_card.verification_value?
+        year  = sprintf("%.4i", credit_card.year)
+        month = sprintf("%.2i", credit_card.month)
+        post[:expire] = "#{month}/#{year[2..3]}"
+      end
+
+      def add_credentials(post, key=:guid)
+        post[key] = @options[:guid]
+        post[:pwd] = Digest::SHA1.hexdigest(@options[:password])
+      end
+
+      def parse(body)
+        if body =~ /^ID:/
+          body.split('~').reduce(Hash.new) { |h,v|
+            m = v.match("(.*?):(.*)")
+            h.merge!(m[1].underscore.to_sym => m[2])
+          }
+        elsif (m = body.match("(.*?):(.*)"))
+          m[1] == 'OK' ?
+            { status: 'success', id: m[2] } :
+            { status: 'failure', message: m[2] }
+        else
+          Hash[ status: body ]
+        end
+      end
+
+      def commit(action, parameters, amount=nil)
+        url = (test? ? test_url : live_url)
+        response = parse(ssl_post(url, post_data(action,parameters)))
+
+        Response.new(
+          success_from(response),
+          message_from(response),
+          response,
+          authorization: authorization_from(parameters, response, amount),
+          test: test?
+        )
+      end
+
+      def authorization_from(parameters, response, amount)
+        identifier = (response[:id] || parameters[:init_transaction_id])
+        authorization = [identifier]
+        authorization << amount if amount
+        authorization.join("|")
+      end
+
+      def split_authorization(authorization)
+        if authorization =~ /|/
+          identifier, amount = authorization.split("|")
+          [identifier, amount.to_i]
+        else
+          authorization
+        end
+      end
+
+      def success_from(response)
+        (response[:status] =~ /success/i || response[:status] =~ /ok/i)
+      end
+
+      def message_from(response)
+        (response[:message] || response[:status])
+      end
+
+      def post_data(action, parameters = {})
+        parameters[:a] = action
+        parameters.to_s
+      end
+    end
+  end
+end

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

@@ -1,238 +1,9 @@
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
-    class TransnationalGateway < Gateway
-      self.live_url = self.test_url = 'https://secure.networkmerchants.com/api/transact.php'
-
-      self.supported_countries = ['US']
-      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
-
+    class TransnationalGateway < NetworkMerchantsGateway
       self.homepage_url = 'http://www.tnbci.com/'
       self.display_name = 'Transnational'
-
-      self.money_format = :dollars
-      self.default_currency = 'USD'
-
-      def initialize(options = {})
-        requires!(options, :login, :password)
-        super
-      end
-
-      def authorize(money, creditcard_or_vault_id, options = {})
-        post = build_auth_post(money, creditcard_or_vault_id, options)
-        commit('auth', post)
-      end
-
-      def purchase(money, creditcard_or_vault_id, options = {})
-        post = build_purchase_post(money, creditcard_or_vault_id, options)
-        commit('sale', post)
-      end
-
-      def capture(money, authorization, options = {})
-        post = build_capture_post(money, authorization, options)
-        commit('capture', post)
-      end
-
-      def void(authorization, options = {})
-        post = build_void_post(authorization, options)
-        commit('void', post)
-      end
-
-      def refund(money, authorization, options = {})
-        post = build_refund_post(money, authorization, options)
-        commit('refund', post)
-      end
-
-      def store(creditcard, options = {})
-        post = build_store_post(creditcard, options)
-        commit_vault('add_customer', post)
-      end
-
-      def unstore(customer_vault_id, options = {})
-        post = build_unstore_post(customer_vault_id, options)
-        commit_vault('delete_customer', post)
-      end
-
-      private
-
-      def build_auth_post(money, creditcard_or_vault_id, options)
-        post = {}
-        add_order(post, options)
-        add_address(post, options)
-        add_shipping_address(post, options)
-        add_payment_method(post, creditcard_or_vault_id, options)
-        add_amount(post, money)
-        post
-      end
-
-      def build_purchase_post(money, creditcard, options)
-        build_auth_post(money, creditcard, options)
-      end
-
-      def build_capture_post(money, authorization, option)
-        post = {}
-        post[:transactionid] = authorization
-        add_amount(post, money)
-        post
-      end
-
-      def build_void_post(authorization, options)
-        post = {}
-        post[:transactionid] = authorization
-        post
-      end
-
-      def build_refund_post(money, authorization, options)
-        post = {}
-        post[:transactionid] = authorization
-        add_amount(post, money)
-        post
-      end
-
-      def build_store_post(creditcard_or_check, options)
-        post = {}
-        add_address(post, options)
-        add_shipping_address(post, options)
-        add_payment_method(post, creditcard_or_check, options)
-        post
-      end
-
-      def build_unstore_post(customer_vault_id, options)
-        post = {}
-        post['customer_vault_id'] = customer_vault_id
-        post
-      end
-
-      def add_order(post, options)
-        post[:orderid] = options[:order_id]
-        post[:orderdescription] = options[:description]
-      end
-
-      def add_address(post, options)
-        post[:email] = options[:email]
-        post[:ipaddress] = options[:ip]
-
-        address = options[:billing_address] || options[:address] || {}
-        post[:address1] = address[:address1]
-        post[:address2] = address[:address2]
-        post[:city] = address[:city]
-        post[:state] = address[:state]
-        post[:zip] = address[:zip]
-        post[:country] = address[:country]
-        post[:phone] = address[:phone]
-      end
-
-      def add_shipping_address(post, options)
-        shipping_address = options[:shipping_address] || {}
-        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]
-      end
-
-      def add_swipe_data(post, options)
-        # unencrypted tracks
-        post[:track_1] = options[:track_1]
-        post[:track_2] = options[:track_2]
-        post[:track_3] = options[:track_3]
-
-        # encrypted tracks
-        post[:magnesafe_track_1] = options[:magnesafe_track_1]
-        post[:magnesafe_track_2] = options[:magnesafe_track_2]
-        post[:magnesafe_track_3] = options[:magnesafe_track_3]
-        post[:magnesafe_magneprint] = options[:magnesafe_magneprint]
-        post[:magnesafe_ksn] = options[:magnesafe_ksn]
-        post[:magnesafe_magneprint_status] = options[:magnesafe_magneprint_status]
-      end
-
-      def add_payment_method(post, creditcard_or_check_or_vault_id, options)
-        post[:processor_id] = options[:processor_id]
-        post[:customer_vault] = 'add_customer' if options[:store]
-
-        add_swipe_data(post, options)
-
-        # creditcard_or_check can be blank if using swipe data
-        if creditcard_or_check_or_vault_id.is_a?(CreditCard) # creditcard or check
-          creditcard = creditcard_or_check_or_vault_id
-          post[:firstname] = creditcard.first_name
-          post[:lastname] = creditcard.last_name
-          post[:ccnumber] = creditcard.number
-          post[:ccexp] = format(creditcard.month, :two_digits) + format(creditcard.year, :two_digits)
-          post[:cvv] = creditcard.verification_value
-          post[:payment] = 'creditcard'
-        elsif creditcard_or_check_or_vault_id.is_a?(Check)
-          check = creditcard_or_check_or_vault_id
-          post[:firstname] = check.first_name
-          post[:lastname] = check.last_name
-          post[:checkname] = check.name
-          post[:checkaba] = check.routing_number
-          post[:checkaccount] = check.account_number
-          post[:account_type] = check.account_type
-          post[:account_holder_type] = check.account_holder_type
-          post[:payment] = 'check'
-        else
-          post[:customer_vault_id] = creditcard_or_check_or_vault_id
-        end
-      end
-
-      def add_login(post)
-        post[:username] = @options[:login]
-        post[:password] = @options[:password]
-      end
-
-      def add_amount(post, money)
-        post[:currency] = options[:currency] || currency(money)
-        post[:amount] = amount(money)
-      end
-
-      def commit_vault(action, parameters)
-        commit(nil, parameters.merge(:customer_vault => action))
-      end
-
-      def commit(action, parameters)
-        raw = parse(ssl_post(self.live_url, build_request(action, parameters)))
-
-        success = (raw['response'] == ResponseCodes::APPROVED)
-
-        authorization = authorization_from(success, parameters, raw)
-
-        Response.new(success, raw['responsetext'], raw,
-          :test => test?,
-          :authorization => authorization,
-          :avs_result => { :code => raw['avsresponse']},
-          :cvv_result => raw['cvvresponse']
-        )
-      end
-
-      def build_request(action, parameters)
-        parameters[:type] = action if action
-        add_login(parameters)
-        parameters.to_query
-      end
-
-      def authorization_from(success, parameters, response)
-        return nil unless success
-
-        authorization = response['transactionid']
-        if(parameters[:customer_vault] && (authorization.nil? || authorization.empty?))
-          authorization = response['customer_vault_id']
-        end
-
-        authorization
-      end
-
-      class ResponseCodes
-        APPROVED = '1'
-        DENIED = '2'
-        ERROR = '3'
-      end
-
-      def parse(raw_response)
-        rsp = CGI.parse(raw_response)
-        rsp.keys.each { |k| rsp[k] = rsp[k].first } # flatten out the values
-        rsp
-      end
+      self.supported_countries = ["US"]
     end
   end
 end

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

@@ -0,0 +1,217 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class TrexleGateway < Gateway
+      self.test_url = 'https://core.trexle.com/api/v1'
+      self.live_url = 'https://core.trexle.com/api/v1'
+
+      self.default_currency = 'USD'
+      self.money_format = :cents
+      self.supported_countries = %w(AD AE AT AU BD BE BG BN CA CH CY CZ DE DK EE EG ES FI FR GB
+                                    GI GR HK HU ID IE IL IM IN IS IT JO KW LB LI LK LT LU LV MC
+                                    MT MU MV MX MY NL NO NZ OM PH PL PT QA RO SA SE SG SI SK SM
+                                    TR TT UM US VA VN ZA)
+      self.supported_cardtypes = [:visa, :master, :american_express]
+      self.homepage_url = 'https://trexle.com'
+      self.display_name = 'Trexle'
+
+      def initialize(options = {})
+        requires!(options, :api_key)
+        super
+      end
+
+      # Create a charge using a credit card, card token or customer token
+      #
+      # To charge a credit card: purchase([money], [creditcard hash], ...)
+      # To charge a customer: purchase([money], [token], ...)
+      def purchase(money, creditcard, options = {})
+        post = {}
+
+        add_amount(post, money, options)
+        add_customer_data(post, options)
+        add_invoice(post, options)
+        add_creditcard(post, creditcard)
+        add_address(post, creditcard, options)
+        commit(:post, 'charges', post, options)
+      end
+
+      # Create a customer and associated credit card. The token that is returned
+      # can be used instead of a credit card parameter in the purchase method
+      def store(creditcard, options = {})
+        post = {}
+
+        add_creditcard(post, creditcard)
+        add_customer_data(post, options)
+        add_address(post, creditcard, options)
+        commit(:post, 'customers', post, options)
+      end
+
+      # Refund a transaction
+      def refund(money, token, options = {})
+        commit(:post, "charges/#{CGI.escape(token)}/refunds", { amount: amount(money) }, options)
+      end
+
+      # Authorize an amount on a credit card. Once authorized, you can later
+      # capture this charge using the charge token that is returned.
+      def authorize(money, creditcard, options = {})
+        post = {}
+
+        add_amount(post, money, options)
+        add_customer_data(post, options)
+        add_invoice(post, options)
+        add_creditcard(post, creditcard)
+        add_address(post, creditcard, options)
+        post[:capture] = false
+        commit(:post, 'charges', post, options)
+      end
+
+      # Captures a previously authorized charge. Capturing only part of the original
+      # authorization is currently not supported.
+      def capture(money, token, options = {})
+        commit(:put, "charges/#{CGI.escape(token)}/capture", { amount: amount(money) }, options)
+      end
+
+      # Updates the credit card for the customer.
+      def update(token, creditcard, options = {})
+        post = {}
+
+        add_creditcard(post, creditcard)
+        add_customer_data(post, options)
+        add_address(post, creditcard, options)
+        commit(:put, "customers/#{CGI.escape(token)}", post, options)
+      end
+
+      def supports_scrubbing
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((Authorization: Basic )\w+), '\1[FILTERED]').
+          gsub(/(number\\?":\\?")(\d*)/, '\1[FILTERED]').
+          gsub(/(cvc\\?":\\?")(\d*)/, '\1[FILTERED]')
+      end
+      private
+
+      def add_amount(post, money, options)
+        post[:amount] = amount(money)
+        post[:currency] = (options[:currency] || currency(money))
+        post[:currency] = post[:currency].upcase if post[:currency]
+      end
+
+      def add_customer_data(post, options)
+        post[:email] = options[:email] if options[:email]
+        post[:ip_address] = options[:ip] if options[:ip]
+      end
+
+      def add_address(post, creditcard, options)
+        return if creditcard.kind_of?(String)
+        address = (options[:billing_address] || options[:address])
+        return unless address
+
+        post[:card] ||= {}
+        post[:card].merge!(
+          address_line1: address[:address1],
+          address_line2: address[:address_line2],
+          address_city: address[:city],
+          address_postcode: address[:zip],
+          address_state: address[:state],
+          address_country: address[:country]
+        )
+      end
+
+      def add_invoice(post, options)
+        post[:description] = options[:description] || "Active Merchant Purchase"
+      end
+
+      def add_creditcard(post, creditcard)
+        if creditcard.respond_to?(:number)
+          post[:card] ||= {}
+
+          post[:card].merge!(
+            number: creditcard.number,
+            expiry_month: creditcard.month,
+            expiry_year: creditcard.year,
+            cvc: creditcard.verification_value,
+            name: creditcard.name
+          )
+        elsif creditcard.kind_of?(String)
+          if creditcard =~ /^token_/
+            post[:card_token] = creditcard
+          else
+            post[:customer_token] = creditcard
+          end
+        end
+      end
+
+      def headers(params = {})
+        result = {
+          "Content-Type" => "application/json",
+          "Authorization" => "Basic #{Base64.strict_encode64(options[:api_key] + ':').strip}"
+        }
+
+        result['X-Partner-Key'] = params[:partner_key] if params[:partner_key]
+        result['X-Safe-Card'] = params[:safe_card] if params[:safe_card]
+        result
+      end
+      
+      def commit(method, action, params, options)
+        url = "#{test? ? test_url : live_url}/#{action}"
+        raw_response = ssl_request(method, url, post_data(params), headers(options))
+        parsed_response = parse(raw_response)
+        success_response(parsed_response) 
+      rescue ResponseError => e
+        error_response(parse(e.response.body))
+      rescue JSON::ParserError
+        unparsable_response(raw_response)
+      end
+  
+      def success_response(body)
+        return invalid_response unless body['response']
+      
+        response = body['response']
+        Response.new(
+         true,
+         response['status_message'],
+         body,
+         authorization: token(response),
+         test: test?
+        )
+      end
+
+      def error_response(body)
+        return invalid_response unless body['error']
+        Response.new(
+          false,
+          body['error'],
+          body,
+          authorization: nil,
+          test: test?
+        )
+      end
+
+      def unparsable_response(raw_response)
+        message = "Invalid JSON response received from Trexle. Please contact support@trexle.com 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
+      
+      def invalid_response
+        message = "Invalid response."
+        return Response.new(false, message)
+      end
+
+      def token(response)
+        response['token']
+      end
+
+      def parse(body)
+        return {} if body.blank?
+        JSON.parse(body) 
+      end
+
+      def post_data(parameters = {})
+        parameters.to_json
+      end
+    end
+  end
+end