nexio_activemerchant 0.2.7 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '09b41171285a1391d8d99233c196e387bc1822c3efdbb8187eb8422764f1beae'
-  data.tar.gz: 85f11b3a8a146594f3f0919a1f8b3aa2a6a5415c342b541931acea748ce81c94
+  metadata.gz: 270866bef6896178cdc8fcae4ae1c2e158bcfdca7106ae24a09d91b7823e15a0
+  data.tar.gz: d7d76d0a219146a0e8a7f37e68944836e693c1218fd8fad8fd75f4c1ed65b2a9
 SHA512:
-  metadata.gz: '094f7c5d9058ef1ceb7ed58fc77f217c0190175a64f75a24027909d75003b3bd4b7da8812a3b972b62b864e5f123e63c38129856ad74f0d5483592cc803377c0'
-  data.tar.gz: b82b1e74e01c35752e1f64e4949ccb038b841d62e32686590a58e3aba1ee2dd6959883fda3d0e9a7529130b86b216419f3983ee1b3ade95b0b93b18500a3fcae
+  metadata.gz: 395afe852039e7b35d972a2230e52cd77c938bb94ccb44f49cf14fff5734636cc5a7c4885d37d07b21d82fb67fe174cfb020611190ffd953ebb7e6cb8296bca0
+  data.tar.gz: 03651caa2f01c34336ac9f66e4c577c191b77dae6fe4f0f536f7801a066669c181c1cd86c0909a0ae29f8e1d8a92641d4eed9cd8ac0b52bf9dc43850577ed58b

data/.rubocop.yml

@@ -11,6 +11,10 @@
 
 Gemspec/RequiredRubyVersion:
   Enabled: false
+Metrics/AbcSize:
+  Enabled: false
+Metrics/CyclomaticComplexity:
+  Enabled: false
 Metrics/ClassLength:
   Enabled: false
 Metrics/MethodLength:
@@ -19,3 +23,5 @@ Lint/AssignmentInCondition:
   Enabled: false
 Style/GuardClause:
   Enabled: false
+Style/Documentation:
+  Enabled: false

data/lib/active_merchant/billing/encrypted_nexio_card.rb

@@ -3,7 +3,7 @@
 module ActiveMerchant
   module Billing
     class EncryptedNexioCard < CreditCard
-      ALLOWED_CARD_BRANDS = %w(amex discover jcb mastercard visa).freeze
+      ALLOWED_CARD_BRANDS = %w[amex discover jcb mastercard visa].freeze
 
       attr_accessor :encrypted_number, :own_form, :one_time_token
 

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative './nexio_base_gateway'
+
+module ActiveMerchant
+  module Billing
+    class NexioApmGateway < NexioBaseGateway
+      self.display_name = 'Nexio AMP'
+      self.base_path = '/apm/v3'
+      self.abstract_class = false
+
+      OneTimeToken = Struct.new(:token, :iframe_url, :redirect_urls, :button_urls)
+
+      def generate_token(money, options = {})
+        post = build_payload(options)
+        add_invoice(post, money, options)
+        post[:data][:paymentMethod] = options[:payment_method] if options[:payment_method].present?
+        add_order_data(post, options)
+        post[:customerRedirectUrl] = options[:callback_url] if options[:callback_url].present?
+        post[:processingOptions][:saveRecurringToken] = true if options[:save_token]
+        post[:isAuthOnly] = true if options[:is_auth_only]
+        resp = commit('token', post)
+        return unless resp.success?
+
+        OneTimeToken.new(
+          resp.params['token'],
+          resp.params['expressIFrameUrl'],
+          map_urls(resp.params['redirectUrls']),
+          map_urls(resp.params['buttonIFrameUrls'])
+        )
+      end
+
+      def purchase(money, payment, options = {})
+        post = build_payload(options)
+        add_invoice(post, money, options)
+        post[:apm] = { token: payment.is_a?(Spree::PaymentSource) ? payment.gateway_payment_profile_id : payment }
+        add_order_data(post, options)
+        post[:isAuthOnly] = true if options[:is_auth_only]
+        commit('process', post)
+      end
+
+      def authorize(money, payment, options = {})
+        purchase(money, payment, options.merge(is_auth_only: true))
+      end
+
+      private
+
+      def map_urls(list)
+        list.each_with_object({}) { |item, acc| acc[item['paymentMethod']] = item['url'] }
+      end
+    end
+  end
+end

data/lib/active_merchant/billing/gateways/{nexio.rb → nexio_base_gateway.rb}

@@ -1,59 +1,28 @@
 # frozen_string_literal: true
 
 require 'json'
+require 'nexio_activemerchant/transaction'
 
 module ActiveMerchant
   module Billing
-    class NexioGateway < Gateway
+    class NexioBaseGateway < Gateway
       self.test_url = 'https://api.nexiopaysandbox.com'
       self.live_url = 'https://api.nexiopay.com'
 
       self.supported_countries = %w[CA US]
       self.default_currency = 'USD'
       self.supported_cardtypes = %i[visa master american_express discover]
-
       self.homepage_url = 'https://nex.io'
-      self.display_name = 'Nexio'
-
-      STANDARD_ERROR_CODE_MAPPING = {}.freeze
+      self.abstract_class = true
 
-      OneTimeToken = Struct.new(:token, :expiration, :fraud_url)
+      class_attribute :base_path
+      self.base_path = ''
 
       def initialize(options = {})
         requires!(options, :merchant_id, :auth_token)
         super
       end
 
-      def generate_token(options = {})
-        post = build_payload(options)
-        post[:data][:allowedCardTypes] = %w(amex discover jcb mastercard visa)
-        add_currency(post, options)
-        add_order_data(post, options)
-        add_card_data(post, options)
-        resp = commit('token', post)
-        return unless resp.success?
-
-        token, expiration, fraud_url = resp.params.values_at('token', 'expiration', 'fraudUrl')
-        OneTimeToken.new(token, Time.parse(expiration), fraud_url)
-      end
-
-      def purchase(money, payment, options = {})
-        post = build_payload(options)
-        post[:processingOptions] ||= {}
-        post[:processingOptions][:verboseResponse] = true if test?
-        post[:processingOptions][:customerRedirectUrl] = options[:three_d_callback_url] if options.key?(:three_d_callback_url)
-        post[:processingOptions][:check3ds] = options[:three_d_secure]
-        post[:processingOptions][:paymentType] = options[:payment_type] if options.key?(:payment_type)
-        add_invoice(post, money, options)
-        add_payment(post, payment, options)
-        add_order_data(post, options)
-        commit('process', post)
-      end
-
-      def authorize(money, payment, options = {})
-        purchase(money, payment, options.merge(payload: options.fetch(:payload, {}).merge(isAuthOnly: true)))
-      end
-
       def capture(money, authorization, _options = {})
         commit('capture', { id: authorization, data: { amount: amount(money).to_f } })
       end
@@ -67,13 +36,6 @@ module ActiveMerchant
         commit('void', { id: authorization })
       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
-
       def supports_scrubbing?
         false
       end
@@ -82,28 +44,19 @@ module ActiveMerchant
         transcript
       end
 
-      def store(payment, options = {})
-        post = build_payload(options)
-        add_card_details(post, payment, options)
-        add_currency(post, options)
-        add_order_data(post, options)
-        resp = commit('saveCard', post)
-        return unless resp.success?
-
-        resp.params.fetch('token', {}).fetch('token', nil)
-      end
-
-      def set_webhooks(data)
+      def setup_webhooks(data)
         post = { merchantId: options[:merchant_id].to_s }
         if data.is_a?(String)
           post[:webhooks] = {
             TRANSACTION_AUTHORIZED: { url: data },
-            TRANSACTION_CAPTURED: { url: data }
+            TRANSACTION_CAPTURED: { url: data },
+            TRANSACTION_SETTLED: { url: data }
           }
         else
           webhooks = {}
           webhooks[:TRANSACTION_AUTHORIZED] = { url: data[:authorized] } if data.key?(:authorized)
           webhooks[:TRANSACTION_CAPTURED] = { url: data[:captured] } if data.key?(:captured)
+          webhooks[:TRANSACTION_SETTLED] = { url: data[:settled] } if data.key?(:settled)
           post[:webhooks] = webhooks
         end
         commit('webhook', post)
@@ -114,12 +67,24 @@ module ActiveMerchant
       end
 
       def get_transaction(id)
-        parse(ssl_get(action_url("/transaction/v3/paymentId/#{id}"), base_headers))
-      rescue ResponseError => e
+        data = parse(ssl_get(action_url("/transaction/v3/paymentId/#{id}"), base_headers))
+        ::NexioActivemerchant::Transaction.new(data)
+      rescue ResponseError
+        nil
       end
 
       private
 
+      def build_payload(params)
+        result = params.fetch(:payload, {}).deep_dup
+        result[:data] ||= {}
+        result[:data][:customer] ||= {}
+        result[:processingOptions] ||= {}
+        result[:processingOptions][:merchantId] ||= options[:merchant_id]
+        result[:processingOptions][:verboseResponse] = true if test?
+        result
+      end
+
       def add_invoice(post, money, options)
         post[:data][:amount] = amount(money).to_f
         add_currency(post, options)
@@ -134,11 +99,13 @@ module ActiveMerchant
           case customer
           when String
             post[:data][:customer][:email] = customer
+            post[:data][:customer][:customerRef] = customer
           when Hash
             post[:data][:customer].merge!({
                                             firstName: customer[:first_name],
                                             lastName: customer[:last_name],
-                                            email: customer[:email]
+                                            email: customer[:email],
+                                            customerRef: customer[:email]
                                           })
           end
         end
@@ -176,67 +143,10 @@ module ActiveMerchant
           AddressOne: :address1, AddressTwo: :address2, City: :city,
           Country: :country, Phone: :phone, Postal: :zip, State: :state
         }.each do |suffix, key|
-          post[:data][:customer]["#{prefix}#{suffix}"] = data[key] if data[key].present?
-        end
-      end
-
-      def add_payment(post, payment, options)
-        post[:tokenex] = token_from(payment)
-        if payment.is_a?(Spree::CreditCard)
-          post[:card] = {
-            cardHolderName: payment.name,
-            cardType: payment.brand
-          }.merge!(post.fetch(:card, {}))
-        end
-        post[:processingOptions] ||= {}
-        post[:processingOptions][:merchantId] = self.options[:merchant_id].to_s
-        post[:processingOptions][:saveCardToken] = options[:save_credit_card] if options.key?(:save_credit_card)
-      end
-
-      def token_from(payment)
-        return { token: payment } if payment.is_a?(String)
-
-        {
-          token: payment.gateway_payment_profile_id,
-          lastFour: payment.last_digits,
-          cardType: payment.brand
-        }
-      end
-
-      def add_card_data(post, options)
-        if card = options[:card]
-          post[:card] = {
-            cardHolderName: card[:name],
-            expirationMonth: card[:month],
-            expirationYear: card[:year]
-          }
-        end
-      end
-
-      def add_card_details(post, payment, _options)
-        if payment.is_a?(EncryptedNexioCard)
-          raise ArgumentError, 'The provided card is invalid' unless payment.valid?
-
-          post[:card] = {
-            cardHolderName: payment.name,
-            encryptedNumber: payment.encrypted_number,
-            expirationMonth: payment.month,
-            expirationYear: payment.short_year,
-            cardType: payment.brand,
-            securityCode: payment.verification_value
-          }
-          post[:token] = payment.one_time_token
-        else
-          raise ArgumentError, "Only #{EncryptedNexioCard} payment method is supported to store cards"
+          post[:data][:customer]["#{prefix}#{suffix}"] = data[key]
         end
       end
 
-      def parse(body)
-        JSON.parse(body)
-      rescue StandardError
-        {}
-      end
-
       def commit(action, parameters)
         payload = parse(ssl_post(commit_action_url(action, parameters), post_data(action, parameters), base_headers))
 
@@ -262,29 +172,23 @@ module ActiveMerchant
         )
       end
 
-      def response_status(action, payload)
-        case action
-        when 'process' then authorization_from(payload).present?
-        else
-          true
-        end
-      end
-
-      def authorization_from(payload)
-        payload.fetch('id', nil)
+      def post_data(_action, post = {})
+        JSON.dump(post)
       end
 
-      def post_data(_action, parameters = {})
-        { merchantId: options[:merchant_id] }.merge(parameters).to_json
+      def parse(body)
+        JSON.parse(body)
+      rescue StandardError
+        {}
       end
 
       def commit_action_url(action, _parameters)
         path = case action
-        when 'webhook' then '/webhook/v3/config'
-        when 'secret' then '/webhook/v3/secret'
-        else
-          "/pay/v3/#{action}"
-        end
+               when 'webhook' then '/webhook/v3/config'
+               when 'secret' then '/webhook/v3/secret'
+               else
+                 "#{self.class.base_path}/#{action}"
+               end
         action_url(path)
       end
 
@@ -292,6 +196,24 @@ module ActiveMerchant
         "#{test? ? test_url : live_url}#{path}"
       end
 
+      def base_headers(custom = {})
+        { Authorization: "Basic #{options[:auth_token]}" }.merge(custom)
+      end
+
+      SUCCESS_PROCESS_STATUSES = %w[authOnlyPending authorizedPending pending authOnly settled].freeze
+
+      def response_status(action, payload)
+        case action
+        when 'process' then SUCCESS_PROCESS_STATUSES.include?(payload['transactionStatus'])
+        else
+          true
+        end
+      end
+
+      def authorization_from(payload)
+        payload.fetch('id', nil)
+      end
+
       def build_avs_result(data)
         return if data.blank?
 
@@ -303,14 +225,6 @@ module ActiveMerchant
 
         CVVResult.new(data.fetch('gatewayMessage', {}).fetch('cvvresponse', nil))
       end
-
-      def build_payload(params)
-        { data: { customer: {} } }.merge!(params.fetch(:payload, {}))
-      end
-
-      def base_headers(custom = {})
-        { Authorization: "Basic #{options[:auth_token]}" }
-      end
     end
   end
 end

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

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require_relative './nexio_base_gateway'
+
+module ActiveMerchant
+  module Billing
+    class NexioGateway < NexioBaseGateway
+      self.display_name = 'Nexio'
+      self.base_path = '/pay/v3'
+      self.abstract_class = false
+
+      OneTimeToken = Struct.new(:token, :expiration, :fraud_url)
+
+      def generate_token(options = {})
+        post = build_payload(options)
+        post[:data][:allowedCardTypes] = %w[amex discover jcb mastercard visa]
+        add_currency(post, options)
+        add_order_data(post, options)
+        add_card_data(post, options)
+        resp = commit('token', post)
+        return unless resp.success?
+
+        token, expiration, fraud_url = resp.params.values_at('token', 'expiration', 'fraudUrl')
+        OneTimeToken.new(token, Time.parse(expiration), fraud_url)
+      end
+
+      def purchase(money, payment, options = {})
+        post = build_payload(options)
+        add_invoice(post, money, options)
+        add_payment(post, payment, options)
+        add_order_data(post, options)
+        commit('process', post)
+      end
+
+      def authorize(money, payment, options = {})
+        purchase(money, payment, options.merge(payload: options.fetch(:payload, {}).merge(isAuthOnly: true)))
+      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
+
+      def store(payment, options = {})
+        post = build_payload(options)
+        post[:merchantId] ||= options[:merchant_id]
+        add_card_details(post, payment, options)
+        add_currency(post, options)
+        add_order_data(post, options)
+        resp = commit('saveCard', post)
+        return unless resp.success?
+
+        resp.params.fetch('token', {}).fetch('token', nil)
+      end
+
+      private
+
+      def add_payment(post, payment, options)
+        post[:tokenex] = token_from(payment)
+        if payment.is_a?(Spree::CreditCard)
+          post[:card] = {
+            cardHolderName: payment.name,
+            cardType: payment.brand
+          }.merge!(post.fetch(:card, {}))
+        end
+        post[:processingOptions][:saveCardToken] = options[:save_credit_card] if options.key?(:save_credit_card)
+        if options[:three_d_callback_url].present?
+          post[:processingOptions][:customerRedirectUrl] = options[:three_d_callback_url]
+        end
+        post[:processingOptions][:check3ds] = options[:three_d_secure]
+        post[:processingOptions][:paymentType] = options[:payment_type] if options[:payment_type].present?
+      end
+
+      def token_from(payment)
+        return { token: payment } if payment.is_a?(String)
+
+        {
+          token: payment.gateway_payment_profile_id,
+          lastFour: payment.last_digits,
+          cardType: payment.brand
+        }
+      end
+
+      def add_card_data(post, options)
+        if card = options[:card]
+          post[:card] = {
+            cardHolderName: card[:name],
+            expirationMonth: card[:month],
+            expirationYear: card[:year]
+          }
+        end
+      end
+
+      def add_card_details(post, payment, _options)
+        if payment.is_a?(EncryptedNexioCard)
+          raise ArgumentError, 'The provided card is invalid' unless payment.valid?
+
+          post[:card] = {
+            cardHolderName: payment.name,
+            encryptedNumber: payment.encrypted_number,
+            expirationMonth: payment.month,
+            expirationYear: payment.short_year,
+            cardType: payment.brand,
+            securityCode: payment.verification_value
+          }
+          post[:token] = payment.one_time_token
+        else
+          raise ArgumentError, "Only #{EncryptedNexioCard} payment method is supported to store cards"
+        end
+      end
+    end
+  end
+end

data/lib/nexio_activemerchant/transaction.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module NexioActivemerchant
+  Transaction = Struct.new(:data) do
+    def status
+      data['transactionStatus']
+    end
+
+    def amount
+      data['amount'].to_d
+    end
+  end
+end

data/lib/nexio_activemerchant/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module NexioActivemerchant
-  VERSION = '0.2.7'
+  VERSION = '0.4.0'
 end

data/lib/nexio_activemerchant.rb

@@ -3,7 +3,8 @@
 require 'activemerchant'
 require 'active_merchant/billing/rails'
 require 'active_merchant/billing/encrypted_nexio_card'
-require 'active_merchant/billing/gateways/nexio'
+require 'active_merchant/billing/gateways/nexio_gateway'
+require 'active_merchant/billing/gateways/nexio_apm_gateway'
 require 'nexio_activemerchant/version'
 
 module NexioActivemerchant

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nexio_activemerchant
 version: !ruby/object:Gem::Version
-  version: 0.2.7
+  version: 0.4.0
 platform: ruby
 authors:
 - Whitespectre
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-10-08 00:00:00.000000000 Z
+date: 2021-11-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemerchant
@@ -57,8 +57,11 @@ files:
 - bin/console
 - bin/setup
 - lib/active_merchant/billing/encrypted_nexio_card.rb
-- lib/active_merchant/billing/gateways/nexio.rb
+- lib/active_merchant/billing/gateways/nexio_apm_gateway.rb
+- lib/active_merchant/billing/gateways/nexio_base_gateway.rb
+- lib/active_merchant/billing/gateways/nexio_gateway.rb
 - lib/nexio_activemerchant.rb
+- lib/nexio_activemerchant/transaction.rb
 - lib/nexio_activemerchant/version.rb
 - nexio_activemerchant.gemspec
 homepage: https://github.com/whitespectre/nexio_activemerchant