spree_emerchantpay_genesis 0.1.3

data/app/helpers/spree_emerchantpay_genesis/transaction_helper.rb

@@ -0,0 +1,200 @@
+module SpreeEmerchantpayGenesis
+  # Helper methods used in the transaction processing
+  class TransactionHelper # rubocop:disable Metrics/ClassLength
+
+    TRANSACTION_ID_PREFIX = 'sp-'.freeze
+    CAPTURE_ACTION        = 'capture'.freeze
+    REFUND_ACTION         = 'refund'.freeze
+    VOID_ACTION           = 'void'.freeze
+
+    class << self
+
+      include Spree::Core::Engine.routes.url_helpers
+
+      # Generate Transaction Id
+      def generate_transaction_id
+        "#{TRANSACTION_ID_PREFIX}#{SecureRandom.uuid[TRANSACTION_ID_PREFIX.length..]}"[0..32].downcase
+      end
+
+      # Checks if the given request is asynchronous or not
+      def asyn?(genesis_request)
+        genesis_request.instance_of?(GenesisRuby::Api::Requests::Financial::Cards::Authorize3d) ||
+          genesis_request.instance_of?(GenesisRuby::Api::Requests::Financial::Cards::Sale3d)
+      end
+
+      # Check given response for success result
+      def success_result?(response)
+        response.approved? || async_result?(response)
+      end
+
+      # Check given response for asynchronous execution
+      def async_result?(response)
+        response.pending? || response.pending_async? || response.in_progress? || response.pending_hold?
+      end
+
+      # Check given response for Method Continue parameters
+      def threeds_secure?(response)
+        TransactionHelper.async_result?(response) && response.response_object&.key?(:threeds_method_url)
+      end
+
+      # Check given response for failure
+      def failure_result?(response)
+        response.error? || response.declined?
+      end
+
+      # Generate Spree Response from Gateway action
+      def generate_spree_response(gateway_response)
+        return build_spree_response gateway_response if gateway_response.instance_of? GenesisRuby::Api::Response
+        return build_failure_error gateway_response if gateway_response.is_a? StandardError
+
+        gateway_response
+      end
+
+      # Build message from the given response
+      def build_message(response)
+        result  = response.response_object
+        message = ''
+
+        message = result[:message] unless result[:message].nil?
+        message = "#{message} (#{result[:technical_message]})" unless result[:technical_message].nil?
+
+        message
+      end
+
+      # Fetch the given string with Genesis Ruby transaction class
+      def fetch_genesis_transaction_class(transaction_type)
+        request_class = Mappers::Transaction.for transaction_type
+
+        raise "Invalid transaction type given for #{self.class}" if request_class.nil?
+
+        request_class
+      end
+
+      # Check if the given Genesis Response can be stored
+      def can_save_genesis_response?(response)
+        response_object = response.response_object
+
+        !(
+          response_object[:transaction_id].nil? ||
+            response_object[:transaction_type].nil? ||
+            response_object[:mode].nil?
+        )
+      end
+
+      # Fetch genesis_request_type from plugin options
+      def init_genesis_req(configuration, transaction_type)
+        request_class = TransactionHelper.fetch_genesis_transaction_class(transaction_type)
+
+        request_class&.new configuration
+      end
+
+      # Initialize Genesis client based on the action
+      def init_reference_req(action, configuration, transaction_type)
+        genesis_request = __send__("initialize_#{action}_client", configuration, transaction_type)
+
+        unless genesis_request
+          raise(GenesisRuby::Error, "Invalid #{action.capitalize} action for #{transaction_type.capitalize}")
+        end
+
+        genesis_request
+      end
+
+      # Init Notification object
+      def init_notification(configuration, params)
+        GenesisRuby::Api::Notification.new configuration, params
+      end
+
+      # Initialize Method Continue Transaction Request
+      def init_method_continue_req(configuration)
+        GenesisRuby::Api::Requests::Financial::Cards::Threeds::V2::MethodContinue.new configuration
+      end
+
+      # Fetch Redirect Url from Genesis Response
+      def fetch_redirect_url(options, response)
+        url = ''
+        url = options[:return_success_url] if TransactionHelper.success_result? response
+        url = options[:return_failure_url] if TransactionHelper.failure_result? response
+        url = response.response_object[:redirect_url] if response.response_object&.key? :redirect_url
+        url = build_threeds_secure_endpoint options, response if TransactionHelper.threeds_secure? response
+
+        { redirect_url: url }
+      end
+
+      # Generate Checksum from the response object
+      def generate_checksum(response_object)
+        Digest::MD5.hexdigest(
+          "#{response_object[:unique_id]}#{response_object[:amount]}#{response_object[:currency]}"
+        )
+      end
+
+      private
+
+      # Build Success or Failure Spree Response
+      def build_spree_response(response)
+        return build_success_response response if success_result? response
+
+        build_failure_response response
+      end
+
+      # Build Success Spree Response from GenesisRuby::Api::Response
+      def build_success_response(response)
+        ActiveMerchant::Billing::Response.new true, build_message(response), test: test_mode?(response)
+      end
+
+      # Build Failure Spree Response from GenesisRuby::Api:Response
+      def build_failure_response(response)
+        ActiveMerchant::Billing::Response.new false, build_message(response), test: test_mode?(response)
+      end
+
+      # Build Failure Spree Response from GenesisRuby::Error
+      def build_failure_error(error)
+        ActiveMerchant::Billing::Response.new false, error.message
+      end
+
+      # Check the given Genesis Response mode (test/production)
+      def test_mode?(response)
+        response&.response_object&.[](:mode) == 'test'
+      end
+
+      # Initialize Genesis Client with Capture request
+      def initialize_capture_client(configuration, payment_type)
+        return nil unless GenesisRuby::Utils::Transactions::References::CapturableTypes.allowed_reference? payment_type
+
+        init_genesis_req(
+          configuration,
+          GenesisRuby::Utils::Transactions::References::CapturableTypes.fetch_reference(payment_type)
+        )
+      end
+
+      # Initialize Genesis Client with Refund request
+      def initialize_refund_client(configuration, payment_type)
+        return nil unless GenesisRuby::Utils::Transactions::References::RefundableTypes.allowed_reference? payment_type
+
+        init_genesis_req(
+          configuration,
+          GenesisRuby::Utils::Transactions::References::RefundableTypes.fetch_reference(payment_type)
+        )
+      end
+
+      # Initialize Genesis with Void request
+      def initialize_void_client(configuration, payment_type)
+        return nil unless GenesisRuby::Utils::Transactions::References::VoidableTypes.allowed_reference? payment_type
+
+        init_genesis_req(
+          configuration,
+          GenesisRuby::Utils::Transactions::References::VoidableTypes.fetch_reference(payment_type)
+        )
+      end
+
+      # Build 3DSv2 Method Continue endpoint
+      def build_threeds_secure_endpoint(options, response)
+        response_object = response.response_object
+        checksum        = generate_checksum response_object
+
+        "#{options[:hostname]}#{emerchantpay_threeds_form_path(response_object[:unique_id], checksum)}"
+      end
+
+    end
+
+  end
+end

data/app/models/spree/gateway/emerchantpay_direct.rb

@@ -0,0 +1,66 @@
+module Spree
+  # Emerchantpay Direct Payment Method
+  class Gateway::EmerchantpayDirect < SpreeEmerchantpayGenesis::Base::Gateway # rubocop:disable Style/ClassAndModuleChildren
+
+    preference :token, :string
+
+    delegate :load_data, :load_source, :load_payment, to: :provider
+
+    def method_type
+      'emerchantpay_direct'
+    end
+
+    def provider_class
+      SpreeEmerchantpayGenesis::GenesisProvider
+    end
+
+    def provider
+      @provider = provider_class.new options if @provider.nil?
+
+      @provider
+    end
+
+    def purchase(_money_in_cents, source, gateway_options)
+      order, payment = order_data_from_options gateway_options
+      user           = order.user
+
+      prepare_provider(
+        SpreeEmerchantpayGenesis::Mappers::Order.prepare_data(order, user, gateway_options),
+        source,
+        payment
+      )
+
+      provider.purchase
+    end
+
+    def authorize(money_in_cents, source, gateway_options)
+      purchase money_in_cents, source, gateway_options
+    end
+
+    def supports?(_source)
+      true
+    end
+
+    def source_required?
+      true
+    end
+
+    def payment_source_class
+      CreditCard
+    end
+
+    def auto_capture?
+      !GenesisRuby::Utils::Transactions::References::CapturableTypes.all.include? options[:transaction_types]
+    end
+
+    private
+
+    # Prepare provider
+    def prepare_provider(data, source, payment)
+      load_data SpreeEmerchantpayGenesis::Mappers::Order.for data
+      load_source source
+      load_payment payment
+    end
+
+  end
+end

data/app/models/spree/payment_decorator.rb

@@ -0,0 +1,13 @@
+module Spree
+  # Spree Payment Decorator
+  module PaymentDecorator
+
+    # Query all Genesis Gateway Payments
+    def emerchantpay_payments
+      SpreeEmerchantpayGenesis::EmerchantpayPaymentsRepository.find_all_by_order_and_payment order.number, number
+    end
+
+  end
+end
+
+::Spree::Payment.prepend(Spree::PaymentDecorator)

data/app/models/spree/payment_processing_decorator.rb

@@ -0,0 +1,28 @@
+module Spree
+  # Emerchantpay Payment Processing decorator
+  module PaymentProcessingDecorator
+
+    def gateway_action(source, action, success_state)
+      protect_from_connection_error do
+        response      = payment_method.__send__ action, money.money.cents, source, gateway_options
+        success_state = fetch_state success_state, response, action
+        result        = SpreeEmerchantpayGenesis::TransactionHelper.generate_spree_response response
+        handle_response(result, success_state, :failure)
+      end
+    end
+
+    private
+
+    # Provide Spree success event method that will be executed
+    def fetch_state(current_state, response, action)
+      return current_state unless %w(purchase authorize).include? action.to_s
+      return current_state unless response.instance_of? GenesisRuby::Api::Response
+      return 'started_processing' if SpreeEmerchantpayGenesis::TransactionHelper.async_result?(response)
+
+      current_state
+    end
+
+  end
+end
+
+::Spree::Payment.prepend(Spree::PaymentProcessingDecorator)

data/app/models/spree_emerchantpay_genesis/base/data.rb

@@ -0,0 +1,33 @@
+module SpreeEmerchantpayGenesis
+  module Base
+    # Simple key value hash object
+    # Usage: ConfigurableOptions.<name>=, ConfigurableOptions.<name>
+    class Data < Hash
+
+      def []=(key, value)
+        super(key.to_sym, value)
+      end
+
+      def [](key)
+        super(key.to_sym)
+      end
+
+      # Dynamic accessors for the hash[keys]
+      def method_missing(name, *args)
+        name_string = name.to_s
+        if name_string.chomp!('=')
+          self[name_string] = args.first
+        else
+          self[name_string]
+        end
+      end
+
+      # Define ConfigurableOptions.method("<method>") call
+      # If we dont have defined hash key we will raise exception
+      def respond_to_missing?(name, include_private = false)
+        method_missing(name) || super
+      end
+
+    end
+  end
+end

data/app/models/spree_emerchantpay_genesis/base/gateway.rb

@@ -0,0 +1,65 @@
+module SpreeEmerchantpayGenesis
+  module Base
+    # Base Gateway object
+    class Gateway < Spree::Gateway
+
+      preference :username, :string
+      preference :password, :string
+      preference :transaction_types, :select,  default: -> { { values: [:authorize, :authorize3d, :sale, :sale3d] } }
+      preference :return_success_url, :string, default: 'http://localhost:4000/orders/|:ORDER:|'
+      preference :return_failure_url, :string, default: 'http://localhost:4000/checkout/payment?order_number=|:ORDER:|'
+      preference :threeds_allowed, :boolean_select, default: true
+      preference :challenge_indicator, :select, default: lambda {
+        { values: [:no_preference, :no_challenge_requested, :preference, :mandate] }
+      }
+      preference :hostname, :string, default: 'http://127.0.0.1:4000'
+      preference :test_mode, :boolean_select, default: true
+
+      # Capture authorized payment
+      def capture(amount, transaction_id, gateway_options)
+        order, payment = order_data_from_options gateway_options
+
+        prepare_provider order.attributes.symbolize_keys.merge(gateway_options), payment.source, payment
+
+        transaction = SpreeEmerchantpayGenesis::EmerchantpayPaymentsRepository.find_by_transaction_id transaction_id
+
+        provider.capture GenesisRuby::Utils::MoneyFormat.exponent_to_amount(amount, order.currency), transaction
+      end
+
+      # Undo a payment
+      def void(transaction_id, gateway_options)
+        order, payment = order_data_from_options gateway_options
+
+        prepare_provider order.attributes.symbolize_keys.merge(gateway_options), payment.source, payment
+
+        transaction = SpreeEmerchantpayGenesis::EmerchantpayPaymentsRepository.find_final_transaction transaction_id
+
+        provider.void transaction
+      end
+
+      # Refund a payment
+      def credit(credit_cents, transaction_id, refund_object)
+        payment = refund_object[:originator].payment
+        order   = refund_object[:originator].payment.order
+
+        prepare_provider order.attributes.symbolize_keys, payment.source, payment
+
+        transaction = SpreeEmerchantpayGenesis::EmerchantpayPaymentsRepository.find_final_transaction transaction_id
+
+        provider.refund GenesisRuby::Utils::MoneyFormat.exponent_to_amount(credit_cents, order.currency), transaction
+      end
+
+      def payment_profiles_supported?
+        false
+      end
+
+      def order_data_from_options(options)
+        order_number, payment_number = options[:order_id].split('-')
+        order = Spree::Order.find_by(number: order_number)
+        payment = order.payments.find_by(number: payment_number)
+        [order, payment]
+      end
+
+    end
+  end
+end

data/app/models/spree_emerchantpay_genesis/data/address.rb

@@ -0,0 +1,23 @@
+module SpreeEmerchantpayGenesis
+  module Data
+    # Billing and Shipping Address data
+    class Address < Base::Data
+
+      # Override the default zip method behaviour
+      def zip
+        self[:zip]
+      end
+
+      # Split name into first and last names
+      def name=(value)
+        names = value.nil? ? [] : value.split
+
+        self[:first_name] = names.first
+        self[:last_name]  = names.last
+
+        self[:name] = value
+      end
+
+    end
+  end
+end

data/app/models/spree_emerchantpay_genesis/data/provider.rb

@@ -0,0 +1,23 @@
+module SpreeEmerchantpayGenesis
+  module Data
+    # Provider data
+    class Provider < Base::Data
+
+      # Predefine Amount accessor (BigDecimal.to_s)
+      def amount
+        return total.to_s unless total.nil?
+
+        total
+      end
+
+      # Override default ip accessor
+      # Requests via Spree API causing ip = nil
+      def ip
+        return '127.0.0.1' if self[:ip].nil?
+
+        self[:ip]
+      end
+
+    end
+  end
+end

data/app/models/spree_emerchantpay_genesis/data/user.rb

@@ -0,0 +1,32 @@
+module SpreeEmerchantpayGenesis
+  module Data
+    # User data
+    class User < Base::Data
+
+      # Provide formatted Create At
+      def created_at_formatted
+        self[:created_at].strftime(GenesisRuby::Api::Constants::DateTimeFormats::YYYY_MM_DD_ISO_8601)
+      end
+
+      # Provide formatted Updated At
+      def updated_at_formatted
+        self[:updated_at].strftime(GenesisRuby::Api::Constants::DateTimeFormats::YYYY_MM_DD_ISO_8601)
+      end
+
+      # Billing Address object
+      def billing_address
+        return nil if self[:bill_address_id].nil?
+
+        Spree::Address.find_by(id: self[:bill_address_id])
+      end
+
+      # Shipping Address object
+      def shipping_address
+        return nil if self[:ship_address_id].nil?
+
+        Spree::Address.find_by(id: self[:ship_address_id])
+      end
+
+    end
+  end
+end

data/app/models/spree_emerchantpay_genesis/db/application_record.rb

@@ -0,0 +1,10 @@
+module SpreeEmerchantpayGenesis
+  module Db
+    # Application Record
+    class ApplicationRecord < ActiveRecord::Base
+
+      self.abstract_class = true
+
+    end
+  end
+end

data/app/models/spree_emerchantpay_genesis/db/emerchantpay_payment.rb

@@ -0,0 +1,35 @@
+module SpreeEmerchantpayGenesis
+  module Db
+    # EmerchantpayPayments DB model
+    class EmerchantpayPayment < ApplicationRecord
+
+      DATE_TIME_FORMAT = '%Y-%m-%d %H:%M'.freeze
+
+      store :request, coder: JSON
+      store :response, coder: JSON
+
+      # Get amount formatted in major currency
+      def major_amount
+        GenesisRuby::Utils::MoneyFormat.exponent_to_amount amount, currency
+      end
+
+      # Get created_at formatted
+      def formatted_created_at
+        created_at.strftime DATE_TIME_FORMAT
+      end
+
+      # Get updated_at formatted
+      def formatted_updated_at
+        updated_at.strftime DATE_TIME_FORMAT
+      end
+
+      # Get formatted Response Timestamp
+      def zulu_response_timestamp
+        DateTime.parse(response[:timestamp]).strftime(
+          GenesisRuby::Api::Constants::DateTimeFormats::YYYY_MM_DD_H_I_S_ZULU
+        )
+      end
+
+    end
+  end
+end