spree_vpago 0.1.0.pre.beta

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

@@ -0,0 +1,46 @@
+module Spree
+  class Gateway::AcledaMobile < PaymentMethod
+    preference :partner_id, :string
+    preference :data_encryption_key, :string
+    preference :app_url, :string
+
+    # partial to render the gateway.
+    def method_type
+      'acleda_mobile'
+    end
+
+    def payment_source_class
+      Spree::VpagoPaymentSource
+    end
+
+    def payment_profiles_supported?
+      false
+    end
+
+    # Custom PaymentMethod/Gateway can redefine this method to check method
+    # availability for concrete order.
+    def available_for_order?(_order)
+      true
+    end
+
+    # force to purchase instead of authorize
+    def auto_capture?
+      true
+    end
+
+    def process(_money, _source, gateway_options)
+      Rails.logger.debug { "About to create payment for order #{gateway_options[:order_id]}" }
+      # First of all, invalidate all previous tranx orders to prevent multiple paid orders
+      # source.save!
+      ActiveMerchant::Billing::Response.new(true, 'Order created')
+    end
+
+    def cancel(_response_code)
+      # we can use this to send request to payment gateway api to cancel the payment ( void )
+      # currently Payway does not support to cancel the gateway
+
+      # in our case don't do anything
+      ActiveMerchant::Billing::Response.new(true, 'Acleda Mobile order has been cancelled.')
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+module Spree
+  class Gateway::Payway < PaymentMethod
+    # 'abapay', 'cards'
+    preference :endpoint, :string
+    preference :host, :string
+    preference :api_key, :string
+    preference :merchant_id, :string
+    preference :return_url, :string
+    preference :continue_success_url, :string
+    preference :payment_option, :string
+    preference :transaction_fee_fix, :string
+    preference :transaction_fee_percentage, :string
+
+    # Only enable one-click payments if spree_auth_devise is installed
+    # def self.allow_one_click_payments?
+    #   Gem.loaded_specs.key?('spree_auth_devise')
+    # end
+
+    def payment_source_class
+      Spree::VpagoPaymentSource
+    end
+
+    def payment_profiles_supported?
+      false
+    end
+
+    def card_type
+      if Vpago::Payway::CARD_TYPES.index(preferences[:payment_option]).nil?
+        Vpago::Payway::CARD_TYPE_ABAPAY
+      else
+        preferences[:payment_option]
+      end
+    end
+
+    # partial to render the gateway.
+    def method_type
+      'payment_payway'
+    end
+
+    # Custom PaymentMethod/Gateway can redefine this method to check method
+    # availability for concrete order.
+    def available_for_order?(_order)
+      true
+    end
+
+    # force to purchase instead of authorize
+    def auto_capture?
+      true
+    end
+
+    def process(_money, _source, gateway_options)
+      Rails.logger.debug { "About to create payment for order #{gateway_options[:order_id]}" }
+      # First of all, invalidate all previous tranx orders to prevent multiple paid orders
+      # source.save!
+      ActiveMerchant::Billing::Response.new(true, 'Order created')
+    end
+
+    def cancel(_response_code, _gateway_options)
+      # we can use this to send request to payment gateway api to cancel the payment ( void )
+      # currently Payway does not support to cancel the gateway
+
+      # in our case don't do anything
+      ActiveMerchant::Billing::Response.new(true, 'Payway order has been cancelled.')
+    end
+  end
+end

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

@@ -0,0 +1,174 @@
+module Spree
+  class Gateway::PaywayV2 < PaymentMethod
+    preference :host, :string
+    preference :api_key, :string
+    preference :merchant_id, :string
+    preference :payment_option, :string # 'abapay', 'cards', 'abapay_deeplink'
+    preference :transaction_fee_fix, :string
+    preference :transaction_fee_percentage, :string
+    preference :public_key, :text
+
+    validates :preferred_public_key, presence: true, if: :enable_pre_auth?
+
+    # override: partial to render in admin
+    def method_type
+      'payway_v2'
+    end
+
+    # override
+    def default_payout_profile
+      Spree::PayoutProfiles::PaywayV2.default
+    end
+
+    # override
+    def payment_source_class
+      Spree::VpagoPaymentSource
+    end
+
+    # override
+    def support_payout? = true
+
+    # override
+    def support_pre_auth? = true
+
+    # override
+    def enable_payout?
+      default_payout_profile.present? && default_payout_profile.receivable?
+    end
+
+    # override
+    def enable_pre_auth?
+      self[:enable_pre_auth]
+    end
+
+    # override
+    # authorize payment if pre-auth is enabled, otherwise purchase / complete immediately.
+    def auto_capture?
+      !enable_pre_auth?
+    end
+
+    # override
+    # authorize is used when pre auth enabled
+    def authorize(_amount, _source, gateway_options = {})
+      _, payment_number = gateway_options[:order_id].split('-')
+      payment = Spree::Payment.find_by(number: payment_number)
+
+      checker = check_transaction(payment)
+      payment.update(transaction_response: checker.json_response)
+
+      if checker.success?
+        ActiveMerchant::Billing::Response.new(true, 'Payway Gateway: Authorized')
+      else
+        ActiveMerchant::Billing::Response.new(false, 'Payway Gateway: Authorization Failed')
+      end
+    end
+
+    # override
+    # purchase is used when pre auth disabled
+    def purchase(_amount, _source, gateway_options = {})
+      _, payment_number = gateway_options[:order_id].split('-')
+      payment = Spree::Payment.find_by(number: payment_number)
+
+      checker = check_transaction(payment)
+      payment.update(transaction_response: checker.json_response)
+
+      success = checker.success?
+      params = {}
+
+      success, params[:payout] = confirm_payouts(payment) if success && payout_total_from_response(payment).present?
+
+      if success
+        ActiveMerchant::Billing::Response.new(true, 'Payway Gateway: Purchased', params)
+      else
+        ActiveMerchant::Billing::Response.new(false, 'Payway Gateway: Purchasing Failed', params)
+      end
+    end
+
+    # override
+    def capture(_amount, _response_code, gateway_options)
+      _, payment_number = gateway_options[:order_id].split('-')
+      payment = Spree::Payment.find_by(number: payment_number)
+
+      success = true
+      params = {}
+
+      success, params[:pre_auth] = complete_pre_auth(payment) if enable_pre_auth?
+      success, params[:payout] = confirm_payouts(payment) if success && payout_total_from_response(payment).present?
+
+      if success
+        ActiveMerchant::Billing::Response.new(true, 'Payway Gateway: Captured', params)
+      else
+        ActiveMerchant::Billing::Response.new(false, 'Payway Gateway: Capture Failed', params)
+      end
+    end
+
+    # override
+    def void(_response_code, gateway_options)
+      _, payment_number = gateway_options[:order_id].split('-')
+      payment = Spree::Payment.find_by(number: payment_number)
+
+      if enable_pre_auth?
+        params = {}
+        success, params[:pre_auth] = cancel_pre_auth(payment)
+
+        if success
+          ActiveMerchant::Billing::Response.new(true, 'Payway Gateway: Pre-authorization successfully canceled.', params)
+        else
+          ActiveMerchant::Billing::Response.new(false, 'Payway Gateway: Failed to cancel pre-authorization.', params)
+        end
+      else
+        ActiveMerchant::Billing::Response.new(true, 'Payway Gateway: Payment has been voided.')
+      end
+    end
+
+    # override
+    def cancel(_response_code, _payment)
+      ActiveMerchant::Billing::Response.new(true, 'Payway Gateway: Payment has been canceled.')
+    end
+
+    private
+
+    def check_transaction(payment)
+      checker = Vpago::PaywayV2::TransactionStatus.new(payment)
+      checker.call
+      checker
+    end
+
+    def cancel_pre_auth(payment)
+      canceler = Vpago::PaywayV2::PreAuthCanceler.new(payment)
+      canceler.call
+
+      [canceler.success?, canceler.request_data]
+    end
+
+    def complete_pre_auth(payment)
+      completer = Vpago::PaywayV2::PreAuthCompleter.new(payment)
+
+      completer.call
+      [completer.success?, completer.request_data]
+    end
+
+    def confirm_payouts(payment)
+      expect_payout_total = payment.payouts.sum(:amount)
+      payout_total = payout_total_from_response(payment)
+
+      confirmed = false
+
+      if payout_total == expect_payout_total
+        payment.payouts.find_each { |payout| payout.update!(state: :confirmed) }
+        confirmed = true
+      end
+
+      payout_params = { payout_total: payout_total, expect_payout_total: expect_payout_total }
+      [confirmed, payout_params]
+    end
+
+    def payout_total_from_response(payment)
+      payouts_response = payment.transaction_response&.dig('payout')
+
+      return nil if payouts_response.nil? || !payouts_response.is_a?(Array) || payouts_response.empty?
+
+      payouts_response.map { |payout| payout['amt'].to_f || 0 }.sum
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+module Spree
+  class Gateway::WingSdk < PaymentMethod
+    preference :username, :string
+    preference :biller_code, :string
+    preference :rest_api_key, :string
+    preference :sandbox, :boolean
+    preference :host, :string
+    preference :return_url, :string
+    preference :transaction_fee_fix, :string
+    preference :transaction_fee_percentage, :string
+    preference :merchant_name, :string
+
+    ## for basic authentication on checking transaction on vtenh
+    preference :basic_auth_username, :string
+    preference :basic_auth_password, :string
+
+    def payment_source_class
+      Spree::VpagoPaymentSource
+    end
+
+    def payment_profiles_supported?
+      false
+    end
+
+    # Custom PaymentMethod/Gateway can redefine this method to check method
+    # availability for concrete order.
+    def available_for_order?(_order)
+      true
+    end
+
+    # force to purchase instead of authorize
+    def auto_capture?
+      true
+    end
+
+    def process(_money, _source, gateway_options)
+      Rails.logger.debug { "About to create payment for order #{gateway_options[:order_id]}" }
+      # First of all, invalidate all previous tranx orders to prevent multiple paid orders
+      # source.save!
+      ActiveMerchant::Billing::Response.new(true, 'Order created')
+    end
+
+    def cancel(_response_code)
+      # we can use this to send request to payment gateway api to cancel the payment ( void )
+      # currently Payway does not support to cancel the gateway
+
+      # in our case don't do anything
+      ActiveMerchant::Billing::Response.new(true, 'Wing Sdk order has been cancelled.')
+    end
+  end
+end

data/app/models/spree/payout.rb

@@ -0,0 +1,23 @@
+module Spree
+  class Payout < Base
+    include Metadata
+
+    belongs_to :payout_profile, class_name: 'Spree::PayoutProfile', required: true, inverse_of: :payouts
+    belongs_to :payoutable, required: false, inverse_of: :payouts, polymorphic: true
+    belongs_to :payment, class_name: 'Spree::Payment', required: true, inverse_of: :payouts
+
+    enum state: { created: 0, confirmed: 1 }
+
+    validates :payout_profile_id, uniqueness: { scope: %i[payoutable_type payoutable_id payment_id] }
+
+    delegate :currency, to: :payment
+
+    extend DisplayMoney
+    money_methods :amount, :outstanding_amount,
+                  :amount_owed_to_vendor
+
+    def amount_owed_to_vendor
+      private_metadata&.dig('amount_owed_to_vendor')&.to_f
+    end
+  end
+end

data/app/models/spree/payout_profile.rb

@@ -0,0 +1,107 @@
+module Spree
+  class PayoutProfile < Base
+    acts_as_paranoid
+
+    has_many :payouts, class_name: 'Spree::Payout', inverse_of: :payout_profile
+    has_many :payout_profile_products, class_name: 'Spree::PayoutProfileProduct', inverse_of: :payout_profile
+    has_many :products, class_name: 'Spree::Product', through: :payout_profile_products
+
+    has_many :payout_profile_shipping_methods,
+             class_name: 'Spree::PayoutProfileShippingMethod',
+             inverse_of: :payout_profile
+
+    has_many :shipping_methods, class_name: 'Spree::ShippingMethod', through: :payout_profile_shipping_methods
+
+    belongs_to :vendor, class_name: 'Spree::Vendor', optional: true, inverse_of: :payout_profiles
+
+    validates :type, presence: true
+    validates :name, presence: true
+    validates :bank_account_number, presence: true, uniqueness: { scope: %i[type vendor_id] }
+
+    scope :payway, -> { where(type: 'Spree::PayoutProfiles::PaywayV2') }
+    scope :verified, -> { where.not(verified_at: nil) }
+    scope :active, -> { where(active: true) }
+
+    before_save :ensure_default_exists_and_clear_vendor
+    before_destroy :confirm_destroyable
+
+    after_update :clear_default_cache, if: :default?
+
+    self.whitelisted_ransackable_attributes = %w[name vendor_id]
+
+    def self.default
+      Rails.cache.fetch("default_payout_account/#{name.underscore}") do
+        find_by(type: name, default: true)
+      end
+    end
+
+    def clear_default_cache
+      Rails.cache.delete("default_payout_account/#{self.class.name.underscore}")
+    end
+
+    def bank_name
+      'None'
+    end
+
+    def display_name
+      display_name = name
+
+      bank_info = [bank_name, bank_account_number].compact.join(' - ')
+      display_name += " (#{bank_info})" unless bank_info.empty?
+
+      display_name
+    end
+
+    def verified?
+      verified_at.present?
+    end
+
+    def receivable?
+      verified? && active?
+    end
+
+    def registered_in_bank?
+      true
+    end
+
+    def allow_to_verify_with_bank?
+      true
+    end
+
+    def verify!(response_data)
+      update_columns(
+        verified_at: DateTime.current,
+        response_data: response_data
+      )
+    end
+
+    def reset_verification!
+      update_columns(
+        verified_at: nil
+      )
+    end
+
+    def can_be_deleted?
+      self.class.where.not(id: id, type: type).any?
+    end
+
+    private
+
+    def ensure_default_exists_and_clear_vendor
+      if default?
+        self.class.where.not(id: id, type: type).update_all(default: false)
+        self.vendor_id = nil
+      elsif self.class.where(default: true, type: type).count.zero?
+        self.default = true
+        self.vendor_id = nil
+      end
+    end
+
+    def confirm_destroyable
+      return if can_be_deleted?
+
+      errors.add(:base, :cannot_destroy_only_payout_profile)
+      throw(:abort)
+    end
+  end
+end

data/app/models/spree/payout_profile_product.rb

@@ -0,0 +1,14 @@
+module Spree
+  class PayoutProfileProduct < Base
+    scope :required, -> { where(optional: false) }
+    scope :optional, -> { where(optional: true) }
+
+    belongs_to :payout_profile, class_name: 'Spree::PayoutProfile', inverse_of: :payout_profile_products
+    belongs_to :product, class_name: 'Spree::Product', inverse_of: :payout_profile_products
+
+    validates :payout_profile, presence: true
+    validates :product, presence: true
+
+    validates :payout_profile_id, uniqueness: { scope: :product_id }
+  end
+end

data/app/models/spree/payout_profile_shipping_method.rb

@@ -0,0 +1,14 @@
+module Spree
+  class PayoutProfileShippingMethod < Base
+    scope :required, -> { where(optional: false) }
+    scope :optional, -> { where(optional: true) }
+
+    belongs_to :payout_profile, class_name: 'Spree::PayoutProfile', inverse_of: :payout_profile_shipping_methods
+    belongs_to :shipping_method, class_name: 'Spree::ShippingMethod', inverse_of: :payout_profile_shipping_methods
+
+    validates :payout_profile, presence: true
+    validates :shipping_method, presence: true
+
+    validates :payout_profile_id, uniqueness: { scope: :shipping_method_id }
+  end
+end

data/app/models/spree/payout_profiles/payway_v2.rb

@@ -0,0 +1,40 @@
+module Spree
+  module PayoutProfiles
+    class PaywayV2 < Spree::PayoutProfile
+      preference :base_url, :string
+      preference :payee, :string
+      preference :merchant_id, :string
+      preference :api_key, :string
+      preference :rsa_public_key, :text
+
+      before_validation -> { self.preferred_payee = bank_account_number }
+
+      # override
+      def set_default_preferences
+        self.preferred_base_url ||= self.class.default&.preferred_base_url
+        self.preferred_merchant_id ||= self.class.default&.preferred_merchant_id
+        self.preferred_api_key ||= self.class.default&.preferred_api_key
+        self.preferred_rsa_public_key ||= self.class.default&.preferred_rsa_public_key
+      end
+
+      # override
+      def registered_in_bank?
+        response_data['payee'].present?
+      end
+
+      # override
+      def allow_to_verify_with_bank?
+        preferred_base_url.present? &&
+          preferred_payee.present? &&
+          preferred_merchant_id.present? &&
+          preferred_api_key.present? &&
+          preferred_rsa_public_key.present?
+      end
+
+      # override
+      def bank_name
+        'ABA'
+      end
+    end
+  end
+end

data/app/models/spree/vpago_payment_source.rb

@@ -0,0 +1,21 @@
+class Spree::VpagoPaymentSource < Spree::Base
+  preference :wing_response, :hash
+  preference :acleda_response, :hash
+  preference :payway_v2_response, :hash
+
+  belongs_to :payment_method
+  belongs_to :user, class_name: 'Spree::User'
+  belongs_to :updated_by_user, class_name: 'Spree::User'
+
+  has_one :payment, as: :source
+
+  # validates :updated_reason, presence: true, on: :update
+
+  def actions
+    actions = []
+    actions << 'open_checkout' if payment.checkout?
+    actions << 'process' if payment.processing? || payment.checkout? || payment.send(:has_invalid_state?)
+    actions << 'capture' if payment.pending?
+    actions
+  end
+end

data/app/models/vpago/adjustment_decorator.rb

@@ -0,0 +1,28 @@
+module Vpago
+  module AdjustmentDecorator
+    def self.prepended(base)
+      base.enum handle_by: { store: 0, vendor: 1 }, _prefix: true
+
+      base.scope :handle_by_vendor, -> { eligible.where(handle_by: :vendor) }
+      base.scope :handle_by_store, -> { eligible.where(handle_by: :store) }
+
+      base.before_save :set_handle_by
+
+      def base.total
+        sum(:amount) || 0
+      end
+    end
+
+    private
+
+    def set_handle_by
+      if source.is_a?(::Spree::PromotionAction)
+        self.handle_by = source.run_by
+      elsif source.is_a?(::Spree::TaxRate)
+        self.handle_by = source.tax_category.collect_by
+      end
+    end
+  end
+end
+
+Spree::Adjustment.prepend(Vpago::AdjustmentDecorator) unless Spree::Adjustment.included_modules.include?(Vpago::AdjustmentDecorator)

data/app/models/vpago/line_item_decorator.rb

@@ -0,0 +1,75 @@
+module Vpago
+  module LineItemDecorator
+    def self.prepended(base)
+      base.include ::Vpago::Payoutable
+
+      base.has_many :payout_profiles, class_name: 'Spree::PayoutProfile', through: :product
+      base.has_many :active_payout_profiles, class_name: 'Spree::PayoutProfile', through: :product
+      base.has_many :active_payway_payout_profiles, class_name: 'Spree::PayoutProfile', through: :product
+
+      base.has_many :required_active_payout_profiles, class_name: 'Spree::PayoutProfile', through: :product
+
+      base.has_one :vendor, through: :variant
+      base.has_many :vendor_payment_methods, class_name: 'Spree::PaymentMethod', through: :variant
+    end
+
+    # considred required when there are any required profiles.
+    def required_payway_payout?
+      required_active_payout_profiles.payway.exists?
+    end
+
+    def commission_rate
+      product_commission_rate = product.respond_to?(:commission_rate) ? product.commission_rate : nil
+      product_commission_rate || vendor&.commission_rate || 0
+    end
+
+    def commission_amount
+      vendor_pre_tax_amount * commission_rate / 100.0
+    end
+
+    # amount expected to receive by vendor
+    def pre_commission_amount
+      vendor_pre_tax_amount - commission_amount + vendor_tax_total
+    end
+
+    def vendor_pre_tax_amount
+      subtotal + vendor_adjustments_total_excluding_tax
+    end
+
+    def vendor_tax_total
+      adjustments.tax.handle_by_vendor.total
+    end
+
+    def vendor_adjustments_total_excluding_tax
+      vendor_adjustment = adjustments.non_tax.handle_by_vendor.total
+      order_vendor_adjustment = if order.line_items_count.positive?
+                                  order.adjustments.non_tax.handle_by_vendor.total / order.line_items_count
+                                else
+                                  0
+                                end
+
+      order_vendor_adjustment + vendor_adjustment
+    end
+
+    def latest_private_metadata
+      private_metadata ||= {}
+
+      private_metadata[:subtotal] = subtotal.to_f
+      private_metadata[:commission_rate] = commission_rate.to_f
+      private_metadata[:commission_amount] = commission_amount.to_f
+      private_metadata[:vendor_pre_tax_amount] = vendor_pre_tax_amount.to_f
+      private_metadata[:pre_commission_amount] = pre_commission_amount.to_f
+      private_metadata[:vendor_tax_total] = vendor_tax_total.to_f
+      private_metadata[:vendor_adjustments_total_excluding_tax] = vendor_adjustments_total_excluding_tax.to_f
+
+      private_metadata
+    end
+
+    # generate metadata for financial reports.
+    def update_total_metadata
+      update_column(:private_metadata, latest_private_metadata)
+    end
+  end
+end
+
+Spree::LineItem.prepend(Vpago::LineItemDecorator) if Spree::LineItem.included_modules.exclude?(Vpago::LineItemDecorator)