spree_vpago 0.1.0.pre.beta

data/lib/vpago/payway/payment_status_marker.rb

@@ -0,0 +1,84 @@
+module Vpago
+  module Payway
+    class PaymentStatusMarker
+      attr_accessor :payment, :error_message
+
+      # :status, :description, :updated_by_user_id, updated_reason
+      def initialize(payment, options = {})
+        @payment = payment
+        @options = options
+
+        @options[:status] = @options[:status] || false
+      end
+
+      def call
+        ActiveRecord::Base.transaction do
+          update_payment_source
+          update_payment_and_order
+        end
+      end
+
+      private
+
+      def update_payment_source
+        source = @payment.source
+
+        payment_status = @options[:status] ? 'success' : 'failed'
+        source.payment_status = payment_status
+        source.payment_description = @options[:description]
+
+        if @options[:status]
+          source.updated_by_user_id = @options[:updated_by_user_id]
+          source.updated_reason = @options[:updated_reason]
+          source.updated_by_user_at = Time.zone.now
+        end
+
+        return if source.save
+
+        @error_message = source.errors.full_messages.join('\n')
+      end
+
+      def update_payment_and_order
+        if @options[:status]
+          transition_to_paid!
+        else
+          transition_to_failed!
+        end
+
+        order_updater
+      end
+
+      def transition_to_paid!
+        complete_payment!
+        complete_order!
+      end
+
+      def transition_to_failed!
+        @payment.failure! unless @payment.failed?
+        @payment.order.update(state: 'payment')
+
+        notify_failed_payment
+      end
+
+      def order_updater
+        @payment.order.update_with_updater!
+      end
+
+      def complete_payment!
+        @payment.complete! unless @payment.completed?
+      end
+
+      def complete_order!
+        return if @payment.order.completed?
+
+        order = @payment.order
+        order.finalize!
+        order.update(state: 'complete', completed_at: Time.zone.now)
+      end
+
+      def notify_failed_payment
+        Rails.logger.info("Gateway error check with: #{@options[:description]} and will be marked as failed")
+      end
+    end
+  end
+end

data/lib/vpago/payway/transaction_status.rb

@@ -0,0 +1,74 @@
+require 'faraday'
+
+module Vpago
+  module Payway
+    class TransactionStatus < Base
+      attr_accessor :error_message, :result
+
+      def call
+        prepare
+        process
+      end
+
+      def prepare
+        @error_message = nil
+        @result = nil
+      end
+
+      def checker_hmac
+        data = "#{merchant_id}#{transaction_id}"
+        hash = Base64.encode64(OpenSSL::HMAC.digest(OpenSSL::Digest.new('sha512'), api_key, data))
+
+        # somehow php counter part are not able to decode if the \n present.
+        hash.delete("\n")
+      end
+
+      def check_remote_status
+        conn = Faraday::Connection.new do |faraday|
+          faraday.request :url_encoded
+        end
+
+        data = {
+          tran_id: transaction_id,
+          hash: checker_hmac
+        }
+
+        conn.post(check_transaction_url, data)
+      end
+
+      def process
+        @response = check_remote_status
+
+        if @response.status == 200
+          if json_response['status'].zero?
+            @result = json_response
+          else
+            fail!(json_response['description'])
+          end
+        else
+          fail!(@response.body)
+        end
+      end
+
+      def json_response
+        @json_response ||= JSON.parse(@response.body)
+      end
+
+      def fail!(message)
+        @error_message = message
+      end
+
+      def success?
+        @error_message.nil?
+      end
+
+      def check_transaction_url
+        if endpoint[-1] == '/'
+          "#{host}#{endpoint}check/transaction/"
+        else
+          "#{host}#{endpoint}/check/transaction/"
+        end
+      end
+    end
+  end
+end

data/lib/vpago/payway.rb

@@ -0,0 +1,13 @@
+module Vpago
+  module Payway
+    CARD_TYPE_ABAPAY = 'abapay'.freeze
+    CARD_TYPE_ABAPAY_KHQR = 'abapay_khqr'.freeze
+    CARD_TYPE_ABAPAY_KHQR_DEEPLINK = 'abapay_khqr_deeplink'.freeze
+    CARD_TYPE_CARDS = 'cards'.freeze
+    CARD_TYPE_WECHAT = 'wechat'.freeze
+    CARD_TYPE_ALIPAY = 'alipay'.freeze
+
+    CARD_TYPES = [CARD_TYPE_ABAPAY, CARD_TYPE_ABAPAY_KHQR, CARD_TYPE_ABAPAY_KHQR_DEEPLINK, CARD_TYPE_CARDS,
+                  CARD_TYPE_WECHAT, CARD_TYPE_ALIPAY].freeze
+  end
+end

data/lib/vpago/payway_v2/base.rb

@@ -0,0 +1,153 @@
+module Vpago
+  module PaywayV2
+    class Base
+      def initialize(payment, options = {})
+        @options = options
+        @payment = payment
+      end
+
+      def req_time
+        @payment.created_at.strftime('%Y%m%d%H%M%S')
+      end
+
+      def type
+        @payment.payment_method.enable_pre_auth ? 'pre-auth' : 'purchase'
+      end
+
+      def host
+        @payment.payment_method.preferences[:host]
+      end
+
+      def public_key
+        @payment.payment_method.preferences[:public_key]
+      end
+
+      def amount
+        format('%.2f', (@payment.amount + transaction_fee))
+      end
+
+      def transaction_fee_fix
+        @payment.payment_method.preferences[:transaction_fee_fix].to_f
+      end
+
+      def transaction_fee_percentage
+        @payment.payment_method.preferences[:transaction_fee_percentage].to_f
+      end
+
+      def transaction_fee
+        transaction_fee_fix + ((@payment.amount * transaction_fee_percentage) / 100)
+      end
+
+      def merchant_id
+        @payment.payment_method.preferences[:merchant_id]
+      end
+
+      def transaction_id
+        @payment.number
+      end
+
+      def email
+        @payment.order.email.presence || ENV.fetch('DEFAULT_EMAIL_FOR_PAYMENT', nil)
+      end
+
+      def first_name
+        @payment.order.billing_address.first_name.strip
+      end
+
+      def last_name
+        @payment.order.billing_address.last_name.strip
+      end
+
+      def return_url
+        uri = URI.parse(@payment.process_payment_url)
+        uri.query = nil
+
+        Base64.encode64(uri.to_s).delete("\n")
+      end
+
+      def continue_success_url
+        @payment.processing_url
+      end
+
+      # null, hosted_view, checkout, qr
+      def view_type
+        'hosted_view'
+      end
+
+      def payment_option
+        card_option = @payment.payment_method.preferences[:payment_option]
+        Vpago::Payway::CARD_TYPES.index(card_option).nil? ? Vpago::Payway::CARD_TYPE_ABAPAY : card_option
+      end
+
+      def phone_country_code
+        '+855'
+      end
+
+      def phone
+        @payment.order.billing_address.phone
+      end
+
+      def api_key
+        @payment.payment_method.preferences[:api_key]
+      end
+
+      def return_params
+        uri = URI.parse(@payment.process_payment_url)
+        query_params = Rack::Utils.parse_nested_query(uri.query)
+        query_params.to_json
+      end
+
+      def payout
+        @payout ||= begin
+          payouts = Vpago::PaywayV2::PayoutsParamsConstructor.new(@payment).call
+          payouts.empty? ? nil : Base64.strict_encode64(payouts.to_json)
+        end
+      end
+
+      # redirect to continue URL, let it handle redirecting to app.
+      # allowed override to specific app eg. from tg://t.me
+      def return_deeplink_url
+        return @options[:override_return_deeplink_url] if @options[:override_return_deeplink_url].present?
+
+        continue_success_url
+      end
+
+      def return_deeplink
+        return nil unless return_deeplink_url.present?
+
+        Base64.strict_encode64({ android_scheme: return_deeplink_url, ios_scheme: return_deeplink_url }.to_json)
+      end
+
+      def hash_hmac
+        hash = Base64.strict_encode64(OpenSSL::HMAC.digest(OpenSSL::Digest.new('sha512'), api_key, hash_data))
+
+        log_hash_data = "Hash hmac: #{hash}"
+        Rails.logger.info(log_hash_data)
+
+        hash
+      end
+
+      def hash_data
+        result = "#{req_time}#{merchant_id}#{transaction_id}#{amount}#{first_name}#{last_name}#{email}#{phone}"
+
+        result += type if type.present?
+        result += payment_option if payment_option.present?
+        result += return_url if return_url.present?
+        result += continue_success_url if continue_success_url.present?
+        result += return_deeplink if return_deeplink.present?
+        result += return_params if return_params.present?
+        result += payout if payout.present?
+
+        log_hash_data = "Hash data: #{result}"
+        Rails.logger.info(log_hash_data)
+
+        result
+      end
+
+      def order_jwt_token
+        payload = { order_number: @payment.order.number, order_id: @payment.order.id }
+        JWT.encode(payload, @payment.order.token, 'HS256')
+      end
+    end
+  end
+end

data/lib/vpago/payway_v2/checkout.rb

@@ -0,0 +1,35 @@
+module Vpago
+  module PaywayV2
+    class Checkout < Base
+      def gateway_params
+        result = {
+          req_time: req_time,
+          merchant_id: merchant_id,
+          tran_id: transaction_id,
+          amount: amount,
+          type: type,
+          firstname: first_name,
+          lastname: last_name,
+          email: email,
+          phone: phone,
+          payment_option: payment_option,
+          return_url: return_url,
+          continue_success_url: continue_success_url,
+          return_params: return_params,
+          hash: hash_hmac
+        }
+
+        result[:return_deeplink] = return_deeplink unless return_deeplink.nil?
+        result[:view_type] = view_type unless view_type.nil?
+        result[:payout] = payout unless payout.nil?
+        result
+      end
+
+      def checkout_url
+        "#{host}#{ENV.fetch('PAYWAY_CHECKOUT_PATH', nil)}"
+      end
+
+      alias action_url checkout_url
+    end
+  end
+end

data/lib/vpago/payway_v2/payment_request_updater.rb

@@ -0,0 +1,65 @@
+module Vpago
+  module PaywayV2
+    class PaymentRequestUpdater < ::Vpago::PaymentRequestUpdater
+      def call
+        return if @payment.order.paid?
+
+        if items_eligible?
+          process_payment_status
+        else
+          mark_items_as_ineligible
+        end
+      end
+
+      private
+
+      def mark_items_as_ineligible
+        @error_message = 'Items are not eligible due to insufficient stock'
+        marker_options = @options.merge(status: false, description:  @error_message)
+        marker = ::Vpago::PaymentStatusMarker.new(@payment, marker_options)
+        marker.call
+      end
+
+      def process_payment_status
+        checker = check_payway_status
+
+        if checker.success?
+          mark_payment_as_success(checker)
+        elsif checker.failed?
+          mark_payment_as_failed(checker.error_message)
+        end
+      end
+
+      def mark_payment_as_success(checker)
+        @error_message = nil
+        checker_result = {
+          status: true,
+          description: nil,
+          payway_v2_response: checker.json_response,
+          payout_total: checker.payout_total
+        }
+        marker_options = @options.merge(checker_result)
+        marker = ::Vpago::PaymentStatusMarker.new(@payment, marker_options)
+        marker.call
+      end
+
+      def mark_payment_as_failed(error_message)
+        @error_message = error_message
+        marker_options = @options.merge(status: false, description: @error_message)
+
+        marker = ::Vpago::PaymentStatusMarker.new(@payment, marker_options)
+        marker.call
+      end
+
+      def check_payway_status
+        trans_status = Vpago::PaywayV2::TransactionStatus.new(@payment)
+        trans_status.call
+        trans_status
+      end
+
+      def items_eligible?
+        @payment&.order&.line_items&.all?(&:sufficient_stock?) == true
+      end
+    end
+  end
+end

data/lib/vpago/payway_v2/payouts_params_constructor.rb

@@ -0,0 +1,47 @@
+module Vpago
+  module PaywayV2
+    class PayoutsParamsConstructor
+      attr_reader :payment, :payouts
+
+      def initialize(payment)
+        @payment = payment
+        @payouts = payment.payouts.includes(:payout_profile)
+      end
+
+      def call
+        payouts = build_payouts_from_payment
+        payouts = group_payouts(payouts)
+
+        format_payouts(payouts)
+      end
+
+      def build_payouts_from_payment
+        payouts.each_with_object([]) do |payout, payouts_hash|
+          payouts_hash << {
+            acc: payout.payout_profile.bank_account_number,
+            amt: payout.amount
+          }
+        end
+      end
+
+      # group & sum amount by acc number.
+      def group_payouts(payouts)
+        payouts.group_by { |item| item[:acc] }.map do |acc, items|
+          {
+            acc: acc,
+            amt: items.sum { |item| item[:amt] }
+          }
+        end
+      end
+
+      def format_payouts(payouts)
+        payouts.map do |payout|
+          {
+            acc: payout[:acc],
+            amt: format('%.2f', payout[:amt])
+          }
+        end
+      end
+    end
+  end
+end

data/lib/vpago/payway_v2/pre_auth_canceler.rb

@@ -0,0 +1,43 @@
+require 'faraday'
+
+module Vpago
+  module PaywayV2
+    class PreAuthCanceler < PreAuthCompleter
+      # override
+      def pre_auth_response
+        conn = Faraday::Connection.new do |faraday|
+          faraday.request :url_encoded
+        end
+
+        conn.post(cancel_url, request_data)
+      end
+
+      def request_data
+        {
+          request_time: req_time,
+          merchant_id: merchant_id,
+          merchant_auth: merchant_auth_encryption,
+          hash: hash_data
+        }
+      end
+
+      # override
+      def hash_data
+        data = "#{merchant_id}#{merchant_auth_encryption}#{req_time}"
+        Base64.strict_encode64(OpenSSL::HMAC.digest(OpenSSL::Digest.new('sha512'), api_key, data))
+      end
+
+      # override
+      def merchant_auth
+        {
+          'mc_id' => merchant_id,
+          'tran_id' => transaction_id
+        }.to_json
+      end
+
+      def cancel_url
+        "#{host}#{ENV.fetch('PAYWAY_V2_PRE_AUTH_CANCEL_PATH')}"
+      end
+    end
+  end
+end

data/lib/vpago/payway_v2/pre_auth_completer.rb

@@ -0,0 +1,76 @@
+require 'faraday'
+
+module Vpago
+  module PaywayV2
+    class PreAuthCompleter < Base
+      def call
+        return if completed? || cancelled?
+
+        @response = pre_auth_response
+        save_response if success?
+      end
+
+      def completed? = @payment.pre_auth_response['transaction_status'] == 'COMPLETED'
+      def cancelled? = @payment.pre_auth_response['transaction_status'] == 'CANCELLED'
+
+      def save_response
+        @payment.update(pre_auth_response: json_response)
+      end
+
+      def pre_auth_response
+        conn = Faraday::Connection.new do |faraday|
+          faraday.request :url_encoded
+        end
+
+        conn.post(complete_url, request_data)
+      end
+
+      def request_data
+        {
+          request_time: req_time,
+          merchant_id: merchant_id,
+          merchant_auth: merchant_auth_encryption,
+          hash: hash_data
+        }
+      end
+
+      def hash_data
+        data = "#{merchant_auth_encryption}#{req_time}#{merchant_id}"
+        Base64.strict_encode64(OpenSSL::HMAC.digest(OpenSSL::Digest.new('sha512'), api_key, data))
+      end
+
+      def merchant_auth
+        {
+          'mc_id' => merchant_id,
+          'tran_id' => transaction_id,
+          'complete_amount' => amount.to_s
+        }.to_json
+      end
+
+      def merchant_auth_encryption
+        @merchant_auth_encryption ||= Vpago::PayoutProfiles::Payway::OpenSslEncrypter.new(
+          content: merchant_auth,
+          rsa_public_key: public_key
+        ).call
+      end
+
+      def complete_url
+        "#{host}#{ENV.fetch('PAYWAY_V2_PRE_AUTH_COMPLETE_PATH')}"
+      end
+
+      def success?
+        json_response['status']['code'] == '00'
+      end
+
+      def json_response
+        return @payment.pre_auth_response if @payment.pre_auth_response.present?
+
+        @json_response ||= begin
+          JSON.parse(@response.body)
+        rescue JSON::ParserError
+          {}
+        end
+      end
+    end
+  end
+end

data/lib/vpago/payway_v2/transaction_status.rb

@@ -0,0 +1,85 @@
+require 'faraday'
+
+module Vpago
+  module PaywayV2
+    class TransactionStatus < Base
+      # status:
+      # 0 – Approved, PRE_AUTH, PREAUTH_APPROVED
+      # 1 – Created
+      # 2 – Pending
+      # 3 – Declined
+      # 4 – Refunded
+      # 5 – Wrong Hash
+      # 7 - Cancelled
+      # 11 – Other Server-side Error
+      def call
+        @response = check_remote_status
+      end
+
+      def status
+        json_response['status']&.to_s
+      end
+
+      def success?
+        status == '0'
+      end
+
+      # request failed does not mean payment failed.
+      # but it failed when status is failed.
+      def pending?
+        %w[1 2].include?(status)
+      end
+
+      def failed?
+        %w[3 4 5 7].include?(status)
+      end
+
+      def check_remote_status
+        conn = Faraday::Connection.new do |faraday|
+          faraday.request :url_encoded
+        end
+
+        data = {
+          req_time: req_time,
+          merchant_id: merchant_id,
+          tran_id: transaction_id,
+          hash: checker_hmac
+        }
+
+        conn.post(check_transaction_url, data)
+      end
+
+      def payout_total
+        payouts_response = json_response['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
+
+      def error_message
+        json_response['description'].presence
+      end
+
+      def json_response
+        @json_response ||= begin
+          JSON.parse(@response.body)
+        rescue JSON::ParserError
+          {}
+        end
+      end
+
+      def checker_hmac
+        data = "#{req_time}#{merchant_id}#{transaction_id}"
+        hash = Base64.encode64(OpenSSL::HMAC.digest(OpenSSL::Digest.new('sha512'), api_key, data))
+
+        # somehow php counter part are not able to decode if the \n present.
+        hash.delete("\n")
+      end
+
+      def check_transaction_url
+        "#{host}#{ENV.fetch('PAYWAY_CHECK_TRANSACTION_PATH', nil)}"
+      end
+    end
+  end
+end