activemerchant 1.54.0 → 1.55.0

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

@@ -0,0 +1,115 @@
+require 'json'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class KomojuGateway < Gateway
+      self.test_url = "https://sandbox.komoju.com/api/v1"
+      self.live_url = "https://komoju.com/api/v1"
+      self.supported_countries = ['JP']
+      self.default_currency = 'JPY'
+      self.money_format = :cents
+      self.homepage_url = 'https://www.komoju.com/'
+      self.display_name = 'Komoju'
+      self.supported_cardtypes = [:visa, :master, :american_express, :jcb]
+
+      STANDARD_ERROR_CODE_MAPPING = {
+        "bad_verification_value" => "incorrect_cvc",
+        "card_expired" => "expired_card",
+        "card_declined" => "card_declined",
+        "invalid_number" => "invalid_number"
+      }
+
+      def initialize(options = {})
+        requires!(options, :login)
+        super
+      end
+
+      def purchase(money, payment, options = {})
+        post = {}
+        post[:amount] = amount(money)
+        post[:description] = options[:description]
+        add_payment_details(post, payment, options)
+        post[:currency] = options[:currency] || default_currency
+        post[:external_order_num] = options[:order_id] if options[:order_id]
+        post[:tax] = options[:tax] if options[:tax]
+        add_fraud_details(post, options)
+
+        commit("/payments", post)
+      end
+
+      def refund(money, identification, options = {})
+        commit("/payments/#{identification}/refund", {})
+      end
+
+      private
+
+      def add_payment_details(post, payment, options)
+        details = {}
+
+        details[:type] = 'credit_card'
+        details[:number] = payment.number
+        details[:month] = payment.month
+        details[:year] = payment.year
+        details[:verification_value] = payment.verification_value
+        details[:given_name] = payment.first_name
+        details[:family_name] = payment.last_name
+        details[:email] = options[:email] if options[:email]
+
+        post[:payment_details] = details
+      end
+
+      def add_fraud_details(post, options)
+        details = {}
+
+        details[:customer_ip] = options[:ip] if options[:ip]
+        details[:customer_email] = options[:email] if options[:email]
+        details[:browser_language] = options[:browser_language] if options[:browser_language]
+        details[:browser_user_agent] = options[:browser_user_agent] if options[:browser_user_agent]
+
+        post[:fraud_details] = details unless details.empty?
+      end
+
+      def api_request(path, data)
+        raw_response = nil
+        begin
+          raw_response = ssl_post("#{url}#{path}", data, headers)
+        rescue ResponseError => e
+          raw_response = e.response.body
+        end
+
+        JSON.parse(raw_response)
+      end
+
+      def commit(path, params)
+        response = api_request(path, params.to_json)
+        success = !response.key?("error")
+        message = (success ? "Transaction succeeded" : response["error"]["message"])
+        Response.new(
+          success,
+          message,
+          response,
+          test: test?,
+          error_code: (success ? nil : error_code(response["error"]["code"])),
+          authorization: (success ? response["id"] : nil)
+        )
+      end
+
+      def error_code(code)
+        STANDARD_ERROR_CODE_MAPPING[code] || code
+      end
+
+      def url
+        test? ? self.test_url : self.live_url
+      end
+
+      def headers
+        {
+          "Authorization" => "Basic " + Base64.encode64(@options[:login].to_s + ":").strip,
+          "Accept" => "application/json",
+          "Content-Type" => "application/json",
+          "User-Agent" => "Komoju/v1 ActiveMerchantBindings/#{ActiveMerchant::VERSION}"
+        }
+      end
+    end
+  end
+end

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

@@ -103,13 +103,17 @@ module ActiveMerchant #:nodoc:
         commit(void_type(kind), request)
       end
 
-      def store(creditcard, options = {})
+      def store(payment_method, options = {})
         request = build_xml_request do |doc|
           add_authentication(doc)
           doc.registerTokenRequest(transaction_attributes(options)) do
             doc.orderId(truncate(options[:order_id], 24))
-            doc.accountNumber(creditcard.number)
-            doc.cardValidationNum(creditcard.verification_value) if creditcard.verification_value
+            if payment_method.is_a?(String)
+              doc.paypageRegistrationId(payment_method)
+            else
+              doc.accountNumber(payment_method.number)
+              doc.cardValidationNum(payment_method.verification_value) if payment_method.verification_value
+            end
           end
         end
 

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

@@ -20,7 +20,7 @@ module ActiveMerchant #:nodoc:
         :reference_purchase => 'RepeatSale',
         :authorize => "PreAuthorizationKeyed",
         :capture   => "PostAuthorization",
-        :void      => "VoidPreAuthorization",
+        :void      => "Void",
         :refund    => "Refund"
       }
 

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

@@ -5,13 +5,14 @@ module ActiveMerchant #:nodoc:
       self.display_name = "micropayment"
       self.homepage_url = "https://www.micropayment.de/"
 
-      self.test_url = self.live_url = "https://sipg.micropayment.de/public/creditcard/v1.5.2/nvp/"
+      self.test_url = self.live_url = "https://sipg.micropayment.de/public/creditcardpsp/v1/nvp/"
 
       self.supported_countries = %w(DE)
       self.default_currency = "EUR"
       self.money_format = :cents
       self.supported_cardtypes = [:visa, :master, :american_express]
 
+
       def initialize(options={})
         requires!(options, :access_key)
         super
@@ -20,40 +21,41 @@ module ActiveMerchant #:nodoc:
       def purchase(amount, payment_method, options={})
         post = {}
         add_invoice(post, amount, options)
-        add_payment_method(post, payment_method)
+        add_payment_method(post, payment_method, options)
         add_customer_data(post, options)
-        commit("shortTransactionPurchase", post)
+        commit("purchase", post)
       end
 
       def authorize(amount, payment_method, options={})
         post = {}
         add_invoice(post, amount, options)
-        add_payment_method(post, payment_method)
+        add_payment_method(post, payment_method, options)
         add_customer_data(post, options)
-        commit("shortTransactionAuthorization", post)
+        commit("authorize", post)
       end
 
       def capture(amount, authorization, options={})
         post = {}
         add_reference(post, authorization)
         add_invoice(post, amount, options)
-        commit("transactionCapture", post)
+        commit("capture", post)
       end
 
       def void(authorization, options={})
         post = {}
         add_reference(post, authorization)
-        commit("transactionReversal", post)
+        commit("void", post)
       end
 
       def refund(amount, authorization, options={})
         post = {}
         add_reference(post, authorization)
         add_invoice(post, amount, options)
-        commit("transactionRefund", post)
+        commit("refund", post)
       end
 
       def verify(credit_card, options={})
+
         MultiResponse.run(:use_first_response) do |r|
           r.process { authorize(250, credit_card, options) }
           r.process(:ignore_result) { void(r.authorization, options) }
@@ -78,13 +80,14 @@ module ActiveMerchant #:nodoc:
           post[:amount] = amount(money)
           post[:currency] = options[:currency] || currency(money)
         end
-        post[:project] = options[:project] || "sprdly"
+        post[:project] = options[:project] if options[:project]
       end
 
-      def add_payment_method(post, payment_method)
+      def add_payment_method(post, payment_method, options={})
         post[:firstname] = payment_method.first_name
         post[:surname] = payment_method.last_name
         post[:number] = payment_method.number
+        post[:recurring] = 1 if options[:recurring] == true
         post[:cvc2] = payment_method.verification_value
         post[:expiryYear] = format(payment_method.year, :four_digits)
         post[:expiryMonth] = format(payment_method.month, :two_digits)
@@ -103,9 +106,9 @@ module ActiveMerchant #:nodoc:
       end
 
       def commit(action, params)
-
         params[:testMode] = 1 if test?
         params[:accessKey] = @options[:access_key]
+        params[:apiKey] = @options[:api_key] || "af1fd841af792f4c50131414ff76e004"
 
         response = parse(ssl_post(url(action), post_data(action, params), headers))
 
@@ -113,7 +116,7 @@ module ActiveMerchant #:nodoc:
           succeeded = success_from(response),
           message_from(succeeded, response),
           response,
-          authorization: authorization_from(response),
+          authorization: authorization_from(response, params),
           avs_result: AVSResult.new(code: response["some_avs_result_key"]),
           cvv_result: CVVResult.new(response["some_cvv_result_key"]),
           test: test?
@@ -159,8 +162,9 @@ module ActiveMerchant #:nodoc:
         authorization.split("|")
       end
 
-      def authorization_from(response)
-        "#{response["sessionId"]}|#{response["transactionId"]}"
+      def authorization_from(response, request_params)
+        session_id = response["sessionId"] ? response["sessionId"] : request_params[:sessionId]
+        "#{session_id}|#{response["transactionId"]}"
       end
     end
   end

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

@@ -87,9 +87,7 @@ module ActiveMerchant #:nodoc:
         address = options[:billing_address] || options[:address] || {}
 
         if name = address[:name]
-          segments = name.split(' ')
-          post[:lastName] = segments.pop
-          post[:firstName] = segments.join(' ')
+          post[:firstName], post[:lastName] = split_names(name)
         else
           post[:firstName] = address[:first_name]
           post[:lastName]  = address[:last_name]

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

@@ -138,7 +138,7 @@ module ActiveMerchant #:nodoc:
         commit(request)
       end
 
-      # Private: Execute operation that depends on athorization code from previous purchase or authorize operation
+      # Private: Execute operation that depends on authorization code from previous purchase or authorize operation
       def execute_dependant(action, money, authorization, options)
         request = build_request do |xml|
           add_identification_authorization(xml, authorization, options)

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

@@ -46,6 +46,7 @@ module ActiveMerchant #:nodoc:
         add_payment_source(post, payment_source)
         add_address(post, payment_source, options)
         add_customer_data(post, options)
+        add_user_data(post, options)
 
         commit(:authorization, post)
       end
@@ -57,6 +58,7 @@ module ActiveMerchant #:nodoc:
         add_payment_source(post, payment_source)
         add_address(post, payment_source, options)
         add_customer_data(post, options)
+        add_user_data(post, options)
 
         commit(:purchase, post)
       end
@@ -81,6 +83,7 @@ module ActiveMerchant #:nodoc:
         add_credit_card(post, credit_card)
         add_address(post, credit_card, options)
         add_customer_data(post, options)
+        add_user_data(post, options)
 
         commit(:credit, post)
       end
@@ -142,10 +145,7 @@ module ActiveMerchant #:nodoc:
         end
 
        if shipping_address = options[:shipping_address]
-         first_name, last_name = parse_first_and_last_name(shipping_address[:name])
-
-         post[:ship_name1]      = first_name
-         post[:ship_name2]      = last_name
+         post[:ship_name1], post[:ship_name2] = split_names(shipping_address[:name])
          post[:ship_street]     = shipping_address[:address1]
          post[:ship_zip]        = shipping_address[:zip]
          post[:ship_city]       = shipping_address[:city]
@@ -166,6 +166,12 @@ module ActiveMerchant #:nodoc:
         end
       end
 
+      def add_user_data(post, options)
+        if options[:order_id]
+          post[:user_data] = "order_id:#{options[:order_id]}"
+        end
+      end
+
       def add_transaction_id(post, transaction_id)
         post[:card_number] = 'CS:' + transaction_id
       end
@@ -222,13 +228,6 @@ module ActiveMerchant #:nodoc:
         parameters.reject{|k,v| v.blank?}.collect { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join("&")
       end
 
-      def parse_first_and_last_name(value)
-        name = value.to_s.split(' ')
-
-        last_name = name.pop || ''
-        first_name = name.join(' ')
-        [ first_name, last_name ]
-      end
     end
   end
 end

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

@@ -15,7 +15,7 @@ module ActiveMerchant #:nodoc:
       self.live_url = self.test_url = API_URL
 
       # Currency supported by Omise
-      # * Thai Baht with Satang, ie. 9000 => 90 THB
+      # * Thai Baht with Satang, i.e. 9000 => 90 THB
       self.default_currency = 'THB'
       self.money_format     = :cents
 
@@ -145,7 +145,7 @@ module ActiveMerchant #:nodoc:
         commit(:delete, "customers/#{CGI.escape(customer_id)}")
       end
 
-      # Enable scrubbling sensitive information
+      # Enable scrubbing sensitive information
       def supports_scrubbing?
         true
       end

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

@@ -283,8 +283,9 @@ module ActiveMerchant #:nodoc:
 
       def build_address(xml, addr)
         if addr[:name]
-          xml.tag! 'firstName', addr[:name].split(' ').first
-          xml.tag! 'lastName' , addr[:name].split(' ').last
+          first_name, last_name = split_names(addr[:name])
+          xml.tag! 'firstName', first_name
+          xml.tag! 'lastName' , last_name
         end
         xml.tag! 'street' , addr[:address1] if addr[:address1].present?
         xml.tag! 'street2', addr[:address2] if addr[:address2].present?

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

@@ -668,6 +668,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def build_customer_request_xml(creditcard, options = {})
+        ActiveMerchant.deprecated "Customer Profile support in Orbital is non-conformant to the ActiveMerchant API and will be removed in its current form in a future version. Please contact the ActiveMerchant maintainers if you have an interest in modifying it to conform to the store/unstore/update API."
         xml = xml_envelope
         xml.tag! :Request do
           xml.tag! :Profile do

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

@@ -52,7 +52,7 @@ module ActiveMerchant #:nodoc:
     #
     # PayGateXML Field        ActiveMerchant Use
     #
-    # pgid                    use :login value to gateway instantation
+    # pgid                    use :login value to gateway instantiation
     # pwd                     use :password value to gateway instantiation
     #
     # cname                   credit_card.name

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

@@ -113,6 +113,7 @@ module ActiveMerchant #:nodoc:
         post = {}
         add_invoice(post, options)
         add_reference(post, identification)
+        add_amount(post, money, options)
         commit('refund', money, post)
       end
 
@@ -180,7 +181,7 @@ module ActiveMerchant #:nodoc:
           :dateq => Time.now.strftime('%d%m%Y%H%M%S'),
           :numquestion => unique_id(parameters[:order_id]),
           :site => @options[:login].to_s[0,7],
-          :rang => @options[:login].to_s[7..-1],
+          :rang => @options[:rang] || @options[:login].to_s[7..-1],
           :cle => @options[:password],
           :pays => '',
           :archivage => parameters[:order_id]

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

@@ -0,0 +1,238 @@
+module ActiveMerchant
+  module Billing
+    class PayeezyGateway < Gateway
+      class_attribute :integration_url
+
+      self.test_url = 'https://api-cert.payeezy.com/v1/transactions'
+      self.integration_url = 'https://api-cat.payeezy.com/v1/transactions'
+      self.live_url = 'https://api.payeezy.com/v1/transactions'
+
+      self.default_currency = 'USD'
+      self.money_format = :cents
+      self.supported_countries = %w(US CA)
+
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :jcb, :diners_club]
+
+      self.homepage_url = 'https://developer.payeezy.com/'
+      self.display_name = 'Payeezy'
+
+      CREDIT_CARD_BRAND = {
+        'visa' => 'Visa',
+        'master' => 'Mastercard',
+        'american_express' => 'American Express',
+        'discover' => 'Discover',
+        'jcb' => 'JCB',
+        'diners_club' => 'Diners Club'
+      }
+
+      def initialize(options = {})
+        requires!(options, :apikey, :apisecret, :token)
+        super
+      end
+
+      def purchase(amount, creditcard, options = {})
+        params = {transaction_type: 'purchase'}
+
+        add_invoice(params, options)
+        add_creditcard(params, creditcard)
+        add_address(params, options)
+        add_amount(params, amount, options)
+
+        commit(params, options)
+      end
+
+      def authorize(amount, creditcard, options = {})
+        params = {transaction_type: 'authorize'}
+
+        add_invoice(params, options)
+        add_creditcard(params, creditcard)
+        add_address(params, options)
+        add_amount(params, amount, options)
+
+        commit(params, options)
+      end
+
+      def capture(amount, authorization, options = {})
+        params = {transaction_type: 'capture'}
+
+        add_authorization_info(params, authorization)
+        add_amount(params, amount, options)
+
+        commit(params, options)
+      end
+
+      def refund(amount, authorization, options = {})
+        params = {transaction_type: 'refund'}
+
+        add_authorization_info(params, authorization)
+        add_amount(params, (amount || amount_from_authorization(authorization)), options)
+
+        commit(params, options)
+      end
+
+      def void(authorization, options = {})
+        params = {transaction_type: 'refund'}
+
+        add_authorization_info(params, authorization)
+        add_amount(params, amount_from_authorization(authorization), options)
+
+        commit(params, options)
+      end
+
+      private
+
+      def add_invoice(params, options)
+        params[:merchant_ref] = options[:order_id]
+      end
+
+      def amount_from_authorization(authorization)
+        authorization.split('|').last.to_i
+      end
+
+      def add_authorization_info(params, authorization)
+        transaction_id, transaction_tag, method, _ = authorization.split('|')
+        params[:transaction_id] = transaction_id
+        params[:transaction_tag] = transaction_tag
+        params[:method] = method
+      end
+
+      def add_creditcard(params, creditcard)
+        credit_card = {}
+
+        credit_card[:type] = CREDIT_CARD_BRAND[creditcard.brand]
+        credit_card[:cardholder_name] = creditcard.name
+        credit_card[:card_number] = creditcard.number
+        credit_card[:exp_date] = "#{format(creditcard.month, :two_digits)}#{format(creditcard.year, :two_digits)}"
+        credit_card[:cvv] = creditcard.verification_value if creditcard.verification_value?
+
+        params[:method] = 'credit_card'
+        params[:credit_card] = credit_card
+      end
+
+      def add_address(params, options)
+        address = options[:billing_address]
+        return unless address
+
+        billing_address = {}
+        billing_address[:street] = address[:address1] if address[:address1]
+        billing_address[:city] = address[:city] if address[:city]
+        billing_address[:state_province] = address[:state] if address[:state]
+        billing_address[:zip_postal_code] = address[:zip] if address[:zip]
+        billing_address[:country] = address[:country] if address[:country]
+
+        params[:billing_address] = billing_address
+      end
+
+      def add_amount(params, money, options)
+        params[:currency_code] = (options[:currency] || default_currency).upcase
+        params[:amount] = amount(money)
+      end
+
+      def commit(params, options)
+        url = if options[:integration]
+          integration_url
+        elsif test?
+          test_url
+        else
+          live_url
+        end
+
+        if transaction_id = params.delete(:transaction_id)
+          url = "#{url}/#{transaction_id}"
+        end
+
+        success = false
+        begin
+          body = params.to_json
+          raw_response = ssl_post(url, body, headers(body))
+          response = parse(raw_response)
+          success = (response['transaction_status'] == 'approved')
+        rescue ResponseError => e
+          response = response_error(e.response.body)
+        rescue JSON::ParserError
+          response = json_error(raw_response)
+        end
+
+        Response.new(
+          success,
+          handle_message(response, success),
+          response,
+          test: test?,
+          authorization: authorization_from(params, response),
+          avs_result: {code: response['avs']},
+          cvv_result: response['cvv2'],
+          error_code: error_code(response, success)
+        )
+      end
+
+      def authorization_from(params, response)
+        [
+          response['transaction_id'],
+          response['transaction_tag'],
+          params[:method],
+          (response['amount'] && response['amount'].to_i)
+        ].join('|')
+      end
+
+      def generate_hmac(nonce, current_timestamp, payload)
+        message = [
+          @options[:apikey],
+          nonce.to_s,
+          current_timestamp.to_s,
+          @options[:token],
+          payload
+        ].join("")
+        hash = Base64.strict_encode64(OpenSSL::HMAC.hexdigest('sha256', @options[:apisecret], message))
+        hash
+      end
+
+      def headers(payload)
+        nonce = (SecureRandom.random_number * 10_000_000_000)
+        current_timestamp = (Time.now.to_f * 1000).to_i
+        {
+          'Content-Type' => 'application/json',
+          'apikey' => options[:apikey],
+          'token' => options[:token],
+          'nonce' => nonce.to_s,
+          'timestamp' => current_timestamp.to_s,
+          'Authorization' => generate_hmac(nonce, current_timestamp, payload)
+        }
+      end
+
+      def error_code(response, success)
+        return if success
+        response['Error'].to_h['messages'].to_a.map { |e| e['code'] }.join(', ')
+      end
+
+      def handle_message(response, success)
+        if success
+          "#{response['gateway_message']} - #{response['bank_message']}"
+        elsif %w(401 403).include?(response['code'])
+          response['message']
+        elsif response.key?('Error')
+          response['Error']['messages'].first['description']
+        elsif response.key?('error')
+          response['error']
+        elsif response.key?('fault')
+          response['fault'].to_h['faultstring']
+        else
+          response['bank_message']
+        end
+      end
+
+      def parse(body)
+        JSON.parse(body)
+      end
+
+      def response_error(raw_response)
+        parse(raw_response)
+      rescue JSON::ParserError
+        json_error(raw_response)
+      end
+
+      def json_error(raw_response)
+        {"error" => "Unable to parse response: #{raw_response.inspect}"}
+      end
+    end
+  end
+end