nexio_activemerchant 0.2.8 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b4be2109f95bb02681d52e4eba82df056b917147789135cddd63a9c824305e20
-  data.tar.gz: d12fb306b4071d6b6edace569875566da64a4aee4e639e8d8bca21ea80656f7f
+  metadata.gz: bdff69e02a5eb6fe1375f42e86dac022aa561861d4c2f8191d1a873c01c0883e
+  data.tar.gz: 29dc4a0b999a16d10187c652cb29aa994fe4842771af4fe15933dcf54feb8cc2
 SHA512:
-  metadata.gz: bc116a66f2c7365cbcd784fd81219b33566356bd558746048d47a5edad75f15467530eb80ed8052b7d601e629400a2740b5321a4c77570620918bc9b0cbf6e47
-  data.tar.gz: e96a8b271d7a9d95dc545e91cd03a09b7cf91f3e242840236ae5dd1bd54a8f3dc945de117b02fe5bf3f59fcf0bd4cad34dab683e8500d7ee54841c4ab3dd35db
+  metadata.gz: 02f2accd48380497c5f74a274d95ee4cbdff355d99867b561fafbdd6f26ca1ac2e9e2f9ff8432430dcd99554ce0fc791e439ca48ede54e9f2777b414a2dca9fa
+  data.tar.gz: 9ade7bb542af8389190b715b70c1e06512bbd06a828b697964aba05c136fa262e87dcabbec67210133962bcbba7a966064e181f2fadec1da041b9b8129f10ccb

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

@@ -0,0 +1,51 @@
+# 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]
+        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)
+        if payment.is_a?(Spree::PaymentSource)
+          post[:apm] = { token: payment.gateway_payment_profile_id }
+        else
+          post[:apm] = { token: payment }
+        end
+        add_order_data(post, options)
+        commit('process', post)
+      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}

@@ -4,56 +4,24 @@ require 'json'
 
 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 +35,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 +43,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)
         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)
@@ -113,13 +65,18 @@ module ActiveMerchant
         commit('secret', { merchantId: options[:merchant_id].to_s }).params['secret']
       end
 
-      def get_transaction(id)
-        parse(ssl_get(action_url("/transaction/v3/paymentId/#{id}"), base_headers))
-      rescue ResponseError => e
-      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 +91,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 +135,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].to_s
-        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,20 +164,14 @@ 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)
@@ -283,7 +179,7 @@ module ActiveMerchant
         when 'webhook' then '/webhook/v3/config'
         when 'secret' then '/webhook/v3/secret'
         else
-          "/pay/v3/#{action}"
+          "#{self.class.base_path}/#{action}"
         end
         action_url(path)
       end
@@ -292,6 +188,22 @@ module ActiveMerchant
         "#{test? ? test_url : live_url}#{path}"
       end
 
+      def base_headers(custom = {})
+        { Authorization: "Basic #{options[:auth_token]}" }
+      end
+
+      def response_status(action, payload)
+        case action
+        when 'process' then %w(authOnlyPending authorizedPending pending authOnly settled).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 +215,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,118 @@
+# 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
+
+      def get_transaction(id)
+        parse(ssl_get(action_url("/transaction/v3/paymentId/#{id}"), base_headers))
+      rescue ResponseError => e
+      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)
+        post[:processingOptions][:customerRedirectUrl] = options[:three_d_callback_url] if options[:three_d_callback_url].present?
+        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/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module NexioActivemerchant
-  VERSION = '0.2.8'
+  VERSION = '0.3.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.8
+  version: 0.3.0
 platform: ruby
 authors:
 - Whitespectre
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-10-08 00:00:00.000000000 Z
+date: 2021-11-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemerchant
@@ -57,7 +57,9 @@ 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/version.rb
 - nexio_activemerchant.gemspec