activemerchant 1.56.0 → 1.66.0

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

@@ -0,0 +1,292 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class DigitzsGateway < Gateway
+      include Empty
+
+      self.test_url = 'https://beta.digitzsapi.com/sandbox'
+      self.live_url = 'https://beta.digitzsapi.com/v3'
+
+      self.supported_countries = ['US']
+      self.default_currency = 'USD'
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+      self.money_format = :cents
+
+      self.homepage_url = 'https://digitzs.com'
+      self.display_name = 'Digitzs'
+
+      def initialize(options={})
+        requires!(options, :app_key, :api_key)
+        super
+      end
+
+      def purchase(money, payment, options={})
+        MultiResponse.run do |r|
+          r.process { commit("auth/token", app_token_request(options)) }
+          r.process { commit('payments', purchase_request(money, payment, options), options.merge({ app_token: app_token_from(r) })) }
+        end
+      end
+
+      def refund(money, authorization, options={})
+        MultiResponse.run do |r|
+          r.process { commit("auth/token", app_token_request(options)) }
+          r.process { commit('payments', refund_request(money, authorization, options), options.merge({ app_token: app_token_from(r) })) }
+        end
+      end
+
+      def store(payment, options = {})
+        MultiResponse.run do |r|
+          r.process { commit("auth/token", app_token_request(options)) }
+          options.merge!({ app_token: app_token_from(r) })
+
+          if options[:customer_id].present?
+            customer_id = check_customer_exists(options)
+
+            if customer_id
+              r.process { add_credit_card_to_customer(payment, options) }
+            else
+              r.process { add_customer_with_credit_card(payment, options) }
+            end
+          else
+            r.process { add_customer_with_credit_card(payment, options) }
+          end
+        end
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((Authorization: Bearer ).+), '\1[FILTERED]').
+          gsub(%r((X-Api-Key: )\w+), '\1[FILTERED]').
+          gsub(%r((\"id\\\":\\\").+), '\1[FILTERED]').
+          gsub(%r((\"appKey\\\":\\\").+), '\1[FILTERED]').
+          gsub(%r((\"appToken\\\":\\\").+), '\1[FILTERED]').
+          gsub(%r((\"code\\\":\\\")\d+), '\1[FILTERED]').
+          gsub(%r((\"number\\\":\\\")\d+), '\1[FILTERED]')
+      end
+
+      private
+
+      def new_post
+        {
+          data: {
+            attributes: {}
+          }
+        }
+      end
+
+      def add_split(post, options)
+        return unless options[:payment_type] == "card_split" || options[:payment_type] == "token_split"
+
+        post[:data][:attributes][:split] = {
+          merchantId: options[:split_merchant_id],
+          amount: amount(options[:split_amount])
+        }
+      end
+
+      def add_payment(post, payment, options)
+        if payment.is_a? String
+          customer_id, token = split_authorization(payment)
+          post[:data][:attributes][:token] = {
+            customerId: customer_id,
+            tokenId: token
+          }
+        else
+          post[:data][:attributes][:card] = {
+            type: payment.brand,
+            holder: payment.name,
+            number: payment.number,
+            expiry: expdate(payment),
+            code: payment.verification_value
+          }
+        end
+      end
+
+      def add_transaction(post, money, options)
+        post[:data][:attributes][:transaction] = {
+          amount: amount(money),
+          currency: (options[:currency] || currency(money)),
+          invoice: options[:order_id] || generate_unique_id
+        }
+      end
+
+      def add_address(post, options)
+        if address = options[:billing_address] || options[:address]
+          post[:data][:attributes][:billingAddress] = {
+            line1: address[:address1] || "",
+            line2: address[:address2] || "",
+            city: address[:city] || "",
+            state: address[:state] || "",
+            zip: address[:zip] || "",
+            country: address["country"] || "USA"
+          }
+        end
+      end
+
+      def app_token_request(options)
+        post = new_post
+        post[:data][:type] = "auth"
+        post[:data][:attributes] = { appKey: @options[:app_key] }
+
+        post
+      end
+
+      def purchase_request(money, payment, options)
+        post = new_post
+        post[:data][:type] = "payments"
+        post[:data][:attributes][:merchantId] = options[:merchant_id]
+        post[:data][:attributes][:paymentType] = determine_payment_type(payment, options)
+        add_split(post, options)
+        add_payment(post, payment, options)
+        add_transaction(post, money, options)
+        add_address(post, options)
+
+        post
+      end
+
+      def refund_request(money, authorization, options)
+        post = new_post
+        post[:data][:type] = "payments"
+        post[:data][:attributes][:merchantId] = options[:merchant_id]
+        post[:data][:attributes][:paymentType] = "cardRefund"
+        post[:data][:attributes][:originalTransaction] = {id: authorization}
+        add_transaction(post, money, options)
+
+        post
+      end
+
+      def create_customer_request(payment, options)
+        post = new_post
+        post[:data][:type] = "customers"
+        post[:data][:attributes] = {
+          merchantId: options[:merchant_id],
+          name: payment.name,
+          externalId: "#{SecureRandom.hex(16)}"
+        }
+
+        post
+      end
+
+      def create_token_request(payment, options)
+        post = new_post
+        post[:data][:type] = "tokens"
+        post[:data][:attributes] = {
+          tokenType: "card",
+          customerId: options[:customer_id],
+          label: "Credit Card",
+        }
+        add_payment(post, payment, options)
+        add_address(post, options)
+
+        post
+      end
+
+      def check_customer_exists(options = {})
+        url = (test? ? test_url : live_url)
+        response = parse(ssl_get(url + "/customers/#{options[:customer_id]}", headers(options)))
+
+        return response.try(:[], "data").try(:[], "customerId") if success_from(response)
+        return nil
+      end
+
+      def add_credit_card_to_customer(payment, options = {})
+        commit('tokens', create_token_request(payment, options), options)
+      end
+
+      def add_customer_with_credit_card(payment, options = {})
+        customer_response = commit('customers', create_customer_request(payment, options), options)
+        options.merge!({customer_id: customer_response.authorization})
+        commit('tokens', create_token_request(payment, options), options)
+      end
+
+      def parse(body)
+        JSON.parse(body)
+      end
+
+      def commit(action, parameters, options={})
+        url = (test? ? test_url : live_url)
+        response = parse(ssl_post(url + "/#{action}", parameters.to_json, headers(options)))
+
+        Response.new(
+          success_from(response),
+          message_from(response),
+          response,
+          authorization: authorization_from(response),
+          avs_result: AVSResult.new(code: avs_result_from(response)),
+          cvv_result: CVVResult.new(cvv_result_from(response)),
+          test: test?,
+          error_code: error_code_from(response)
+        )
+      end
+
+      def success_from(response)
+        response["errors"].nil? && response["message"].nil?
+      end
+
+      def message_from(response)
+        return response["message"] if response["message"]
+        return "Success" if success_from(response)
+        response["errors"].map {|error_hash| error_hash["detail"] }.join(", ")
+      end
+
+      def authorization_from(response)
+        if customer_id = response.try(:[], "data").try(:[], "attributes").try(:[], "customerId")
+          "#{customer_id}|#{response.try(:[], "data").try(:[], "id")}"
+        else
+          response.try(:[], "data").try(:[], "id")
+        end
+      end
+
+      def avs_result_from(response)
+        response.try(:[], "data").try(:[], "attributes").try(:[], "transaction").try(:[], "avsResult")
+      end
+
+      def cvv_result_from(response)
+        response.try(:[], "data").try(:[], "attributes").try(:[], "transaction").try(:[], "codeResult")
+      end
+
+      def app_token_from(response)
+        response.params.try(:[], "data").try(:[], "attributes").try(:[], "appToken")
+      end
+
+      def headers(options)
+        headers = {
+          'Content-Type' => 'application/json',
+          'x-api-key' => @options[:api_key]
+        }
+
+        headers.merge!({"Authorization" => "Bearer #{options[:app_token]}"}) if options[:app_token]
+        headers
+      end
+
+      def error_code_from(response)
+        unless success_from(response)
+          response["errors"].nil? ? response["message"] : response["errors"].map {|error_hash| error_hash["code"] }.join(", ")
+        end
+      end
+
+      def split_authorization(authorization)
+        customer_id, token = authorization.split("|")
+        [customer_id, token]
+      end
+
+      def determine_payment_type(payment, options)
+        return "cardSplit" if options[:payment_type] == "card_split"
+        return "tokenSplit" if options[:payment_type] == "token_split"
+        return "token" if payment.is_a? String
+        "card"
+      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/elavon.rb

@@ -30,6 +30,8 @@ module ActiveMerchant #:nodoc:
     #   puts response.authorization # Retrieve the unique transaction ID returned by Elavon
     #
     class ElavonGateway < Gateway
+      include Empty
+
       class_attribute :test_url, :live_url, :delimiter, :actions
 
       self.test_url = 'https://demo.myvirtualmerchant.com/VirtualMerchantDemo/process.do'
@@ -212,8 +214,8 @@ module ActiveMerchant #:nodoc:
       private
 
       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)
+        form[:invoice_number] = truncate((options[:order_id] || options[:invoice]), 10)
+        form[:description] = truncate(options[:description], 255)
       end
 
       def add_approval_code(form, authorization)
@@ -236,8 +238,8 @@ module ActiveMerchant #:nodoc:
           add_verification_value(form, creditcard)
         end
 
-        form[:first_name] = creditcard.first_name.to_s.slice(0, 20)
-        form[:last_name] = creditcard.last_name.to_s.slice(0, 30)
+        form[:first_name] = truncate(creditcard.first_name, 20)
+        form[:last_name] = truncate(creditcard.last_name, 30)
       end
 
       def add_token(form, token)
@@ -250,8 +252,9 @@ module ActiveMerchant #:nodoc:
       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?
+        form[:email] = truncate(options[:email], 100) unless empty?(options[:email])
+        form[:customer_code] = truncate(options[:customer], 10) unless empty?(options[:customer])
+        form[:customer_number] = options[:customer_number] unless empty?(options[:customer_number])
       end
 
       def add_salestax(form, options)
@@ -262,27 +265,27 @@ module ActiveMerchant #:nodoc:
         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.gsub(/[^a-zA-Z0-9]/, '').slice(0, 9)
-          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)
+          form[:avs_address]    = truncate(billing_address[:address1], 30)
+          form[:address2]       = truncate(billing_address[:address2], 30)
+          form[:avs_zip]        = truncate(billing_address[:zip].to_s.gsub(/[^a-zA-Z0-9]/, ''), 9)
+          form[:city]           = truncate(billing_address[:city], 30)
+          form[:state]          = truncate(billing_address[:state], 10)
+          form[:company]        = truncate(billing_address[:company], 50)
+          form[:phone]          = truncate(billing_address[:phone], 20)
+          form[:country]        = truncate(billing_address[:country], 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_address1]       = shipping_address[:address1].to_s.slice(0, 30)
-          form[:ship_to_address2]       = shipping_address[:address2].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)
+          form[:ship_to_first_name]     = truncate(first_name, 20)
+          form[:ship_to_last_name]      = truncate(last_name, 30)
+          form[:ship_to_address1]       = truncate(shipping_address[:address1], 30)
+          form[:ship_to_address2]       = truncate(shipping_address[:address2], 30)
+          form[:ship_to_city]           = truncate(shipping_address[:city], 30)
+          form[:ship_to_state]          = truncate(shipping_address[:state], 10)
+          form[:ship_to_company]        = truncate(shipping_address[:company], 50)
+          form[:ship_to_country]        = truncate(shipping_address[:country], 50)
+          form[:ship_to_zip]            = truncate(shipping_address[:zip], 10)
         end
       end
 
@@ -327,7 +330,19 @@ module ActiveMerchant #:nodoc:
       def post_data(parameters)
         result = preamble
         result.merge!(parameters)
-        result.collect { |key, value| "ssl_#{key}=#{CGI.escape(value.to_s)}" }.join("&")
+        result.collect { |key, value| post_data_string(key, value) }.join("&")
+      end
+
+      def post_data_string(key, value)
+        if custom_field?(key)
+          "#{key}=#{CGI.escape(value.to_s)}"
+        else
+          "ssl_#{key}=#{CGI.escape(value.to_s)}"
+        end
+      end
+
+      def custom_field?(field_name)
+        field_name == :customer_number
       end
 
       def preamble
@@ -338,7 +353,7 @@ module ActiveMerchant #:nodoc:
           'result_format' => 'ASCII'
         }
 
-        result['user_id'] = @options[:user] unless @options[:user].blank?
+        result['user_id'] = @options[:user] unless empty?(@options[:user])
         result
       end
 
@@ -354,4 +369,3 @@ module ActiveMerchant #:nodoc:
     end
   end
 end
-