spree_vpago 0.1.0.pre.beta

data/app/controllers/spree/vpago_payments_controller.rb

@@ -0,0 +1,71 @@
+module Spree
+  class VpagoPaymentsController < ApplicationController
+    layout 'vpago_payments'
+    helper 'vpago/vpago_payments'
+
+    skip_before_action :verify_authenticity_token, only: [:process_payment]
+
+    rescue_from ActiveRecord::RecordNotFound, with: :record_not_found
+    rescue_from CanCan::AccessDenied, with: :access_denied
+
+    # GET
+    def checkout
+      @payment = Vpago::PaymentFinder.new(params.permit!.to_h).find_and_verify
+      raise ActiveRecord::RecordNotFound unless @payment.present?
+
+      return redirect_to @payment.processing_url, allow_other_host: true unless @payment.checkout?
+
+      @order = @payment.order
+    end
+
+    # GET
+    def processing
+      @payment = Vpago::PaymentFinder.new(params.permit!.to_h).find_and_verify
+      raise ActiveRecord::RecordNotFound unless @payment.present?
+
+      @order = @payment.order
+    end
+
+    # GET
+    def success
+      @payment = Vpago::PaymentFinder.new(params.permit!.to_h).find_and_verify
+      raise ActiveRecord::RecordNotFound unless @payment.present?
+
+      @order = @payment.order
+      raise CanCan::AccessDenied unless @order.completed?
+    end
+
+    # POST
+    def process_payment
+      return render json: { status: :ok }, status: :ok if request.method != 'POST'
+
+      @payment = Vpago::PaymentFinder.new(params.permit!.to_h).find_and_verify
+      return render_not_found unless @payment.present?
+
+      unless @payment.order.paid?
+        Vpago::PaymentProcessorJob.perform_later(
+          payment_number: @payment.number
+        )
+      end
+
+      render json: { status: :ok }, status: :ok
+    rescue StandardError => e
+      Rails.logger.error("Failed to enqueued payment processor job: #{params} #{e.message}")
+      render json: { status: :internal_server_error, message: 'Failed to enqueue payment processor job' }, status: :internal_server_error
+    end
+
+    def record_not_found
+      respond_to do |format|
+        format.html { render file: Rails.public_path.join('404.html'), status: :not_found, layout: false }
+        format.json { render json: { status: :not_found }, status: :not_found }
+      end
+    end
+
+    def access_denied
+      respond_to do |format|
+        format.html { render file: Rails.public_path.join('422.html'), status: :not_found, layout: false }
+        format.json { render json: { status: :unauthorized }, status: :unauthorized }
+      end
+    end
+  end
+end

data/app/controllers/spree/webhook/acleda_mobiles_controller.rb

@@ -0,0 +1,88 @@
+module Spree
+  module Webhook
+    class AcledaMobilesController < BaseController
+      skip_before_action :verify_authenticity_token
+      before_action :find_payment, only: [:return]
+
+      # {
+      #   "TransactionId": "16de81d4-b5ef-ef59-16de-81d4b5efef59",
+      #   "PaymentTokenId": "REF0361472663", VTENH payment number
+      #   "TxnAmount": "30",
+      #   "SenderName": "Test User",
+      #   "SignedHash": "c5b9be690bde7dc8a0abebb1a45c0850359540a4977aecd4cdf13e15a2edfe79"
+      #   }
+      def return
+        request_updater = ::Vpago::AcledaMobile::PaymentRequestUpdater.new(@payment)
+        request_updater.call
+
+        order = @payment.order
+        order = order.reload
+
+        if order.paid? || @payment.pending?
+          render_success
+        else
+          render_failed
+        end
+      end
+
+      private
+
+      def find_payment
+        options = params.slice(:TransactionId, :PaymentTokenId, :TxnAmount, :SenderName, :SignedHash)
+
+        service = Vpago::AcledaMobile::PaymentRetriever.new(options)
+        service.call
+
+        return render_hashing_error unless service.data_valid?
+
+        @payment = service.payment
+        return render_payment_not_found if @payment.blank?
+      end
+
+      def render_success
+        status_code = 200
+        response_data = acleda_mobile_response_data('Success', status_code)
+
+        acleda_mobile_response(response_data, status_code)
+      end
+
+      def render_failed
+        status_code = 201
+        response_data = acleda_mobile_response_data('Failed', status_code)
+
+        acleda_mobile_response(response_data, status_code)
+      end
+
+      def render_payment_not_found
+        status_code = 203
+        response_data = acleda_mobile_response_data('Payment not found', status_code)
+
+        acleda_mobile_response(response_data, status_code)
+      end
+
+      def render_hashing_error
+        status_code = 403
+        response_data = acleda_mobile_response_data('Invalid SignedHash', status_code)
+
+        acleda_mobile_response(response_data, status_code)
+      end
+
+      def acleda_mobile_response(response_data, status_code)
+        render json: response_data, status: status_code
+      end
+
+      def acleda_mobile_response_data(message, code)
+        {
+          status: {
+            code: code,
+            message: message
+          },
+          data: {
+            TransactionId: params[:TransactionId],
+            PaymentTokenId: params[:PaymentTokenId]
+          }
+        }
+      end
+    end
+  end
+end

data/app/controllers/spree/webhook/acledas_controller.rb

@@ -0,0 +1,80 @@
+module Spree
+  module Webhook
+    class AcledasController < BaseController
+      skip_before_action :verify_authenticity_token, only: [:return]
+
+      before_action :find_payment, only: %i[success error return]
+
+      rescue_from ::ActiveRecord::RecordNotFound, with: :record_not_found
+
+      ## call back after transaction complete at acleda system
+      ## {"amount": "15.0", "_transactionid"=>"PJ9ETZD4", "_paymentresult"=>"SUCCESS", "_paymenttokenid"=>"lVqWKcLHVk6s0rIgk/T8Vdbzsg0=", "_resultCode"=>"0"}
+      def return
+        render_plain = true
+        check_and_redirect(render_plain)
+      end
+
+      ## success
+      ## {"_arNo"=>"PJ9ETZD4", "_transactionid"=>"PJ9ETZD4", "_paymentresult"=>"SUCCESS", "_paymenttokenid"=>"lVqWKcLHVk6s0rIgk/T8Vdbzsg0=", "_resultCode"=>"0", "controller"=>"spree/webhook/acledas", "action"=>"success"}
+      def success
+        check_and_redirect
+      end
+
+      def error
+        order = @payment.order
+
+        if order.paid?
+          flash[:order_completed] = '1' # required by order_just_completed for purchase tracking
+        end
+
+        pending_or_paid = order.paid? || @payment.pending?
+        if params[:app_checkout].to_s == '1'
+          redirect_to pending_or_paid ? success_payway_results_path : failed_payway_results_path
+        else
+          redirect_to pending_or_paid ? order_path(order) : checkout_state_path(:payment)
+        end
+      end
+
+      private
+
+      def check_and_redirect(render_plain: false)
+        request_updater = ::Vpago::Acleda::PaymentRequestUpdater.new(@payment)
+        request_updater.call
+
+        order = @payment.order
+        order = order.reload
+
+        if render_plain
+          order.paid? || @payment.pending? ? render(plain: :success) : render(plain: :failed, status: 400)
+        else
+          redirect_order(order)
+        end
+      end
+
+      def redirect_order(order)
+        pending_or_paid = order.paid? || @payment.pending?
+
+        if params[:app_checkout].to_s == '1'
+          redirect_to pending_or_paid ? success_payway_results_path : failed_payway_results_path
+        else
+          flash[:order_completed] = '1' if order.paid? # required by order_just_completed for purchase tracking
+          redirect_to pending_or_paid ? order_path(order) : checkout_state_path(:payment)
+        end
+      end
+
+      def find_payment
+        @payment = nil
+        raise ::ActiveRecord::RecordNotFound if params[:_paymenttokenid].blank?
+
+        payment_source = Spree::VpagoPaymentSource.find_by(transaction_id: params[:_paymenttokenid])
+        raise ::ActiveRecord::RecordNotFound if payment_source.blank?
+
+        @payment = payment_source.payment
+      end
+
+      def record_not_found
+        render(plain: :payment_not_found, status: 404)
+      end
+    end
+  end
+end

data/app/controllers/spree/webhook/base_controller.rb

@@ -0,0 +1,6 @@
+module Spree
+  module Webhook
+    class BaseController < ::ApplicationController
+    end
+  end
+end

data/app/controllers/spree/webhook/payways_controller.rb

@@ -0,0 +1,77 @@
+module Spree
+  module Webhook
+    class PaywaysController < BaseController
+      skip_before_action :verify_authenticity_token, only: %i[return v2_return continue v2_continue]
+
+      # match via: [:get, :post]
+      # {"response"=>"{\"tran_id\":\"PE13LXT1\",\"status\":0"}"}
+      def v2_return
+        handler_service = v2_request_updater_service
+
+        return_callback_handler(handler_service)
+      end
+
+      def return
+        handler_service = request_updater_service
+
+        return_callback_handler(handler_service)
+      end
+
+      # https://vtenh.herokuapp.com/payways/continue?tran_id=P2W2S1LB
+      def v2_continue
+        continue_callback_handler
+      end
+
+      def continue
+        continue_callback_handler
+      end
+
+      private
+
+      def v2_request_updater_service
+        ::Vpago::PaywayV2::PaymentRequestUpdater
+      end
+
+      def request_updater_service
+        ::Vpago::Payway::PaymentRequestUpdater
+      end
+
+      # the callback invoke by PAYWAY in case of success
+      def return_callback_handler(handler_service)
+        # pawway send get request with nothing
+        return render plain: :ok if request.method == 'GET'
+
+        builder = Vpago::PaywayReturnOptionsBuilder.new(params: params)
+        payment = builder.payment
+
+        request_updater = handler_service.new(payment)
+        request_updater.call
+
+        order = payment.order
+        order = order.reload
+
+        if order.paid? || payment.pending?
+          render plain: :success
+        else
+          render plain: :failed, status: 400
+        end
+      end
+
+      def continue_callback_handler
+        payment = Spree::Payment.find_by number: params[:tran_id]
+        order = payment.order
+
+        if order.paid?
+          flash[:order_completed] = '1' # required by order_just_completed for purchase tracking
+        end
+
+        pending_or_paid = order.paid? || payment.pending?
+        if params[:app_checkout] == 'yes'
+          redirect_to pending_or_paid ? success_payway_results_path : failed_payway_results_path
+        else
+          redirect_to pending_or_paid ? order_path(order) : checkout_state_path(:payment)
+        end
+      end
+    end
+  end
+end

data/app/controllers/spree/webhook/wings_controller.rb

@@ -0,0 +1,63 @@
+module Spree
+  module Webhook
+    class WingsController < BaseController
+      skip_before_action :verify_authenticity_token, only: %i[return continue create]
+
+      before_action :retrive_payment, only: [:create]
+      before_action :find_payment, only: %i[return continue]
+
+      def create
+        render_plain = true
+        check_and_redirect(render_plain)
+      end
+
+      ## click on button Done: POST { wing_id: payment_number, response: {"remark"=>"PNRE5V5E", "amount"=>" USD 30.00", "total"=>" USD 30.00", "transaction_id"=>"ONL031157", "customer_name"=>"Wing Testing WCX-USD", "biller_name"=>"VTENH"}}
+      ## click on button Back: GET  { wing_id: payment_number }
+      def return
+        check_and_redirect
+      end
+
+      private
+
+      def find_payment
+        @payment = ::Spree::Payment.find_by(number: params[:wing_id])
+      end
+
+      def retrive_payment
+        wing_payment_method = Spree::PaymentMethod.find_by(type: Spree::PaymentMethod::TYPE_WINGSDK)
+        rest_api_key = wing_payment_method.preferences[:rest_api_key]
+        wing_response = params[:contents]
+
+        payment_retriever = ::Vpago::WingSdk::PaymentRetriever.new(rest_api_key, wing_response)
+        payment_retriever.call
+
+        @payment = payment_retriever.payment
+      end
+
+      def check_and_redirect(render_plain: false)
+        request_updater = ::Vpago::WingSdk::PaymentRequestUpdater.new(@payment)
+        request_updater.call
+
+        order = @payment.order
+        order = order.reload
+
+        pending_or_paid = order.paid? || @payment.pending?
+        if render_plain
+          pending_or_paid ? render(plain: :success) : render(plain: :failed, status: 400)
+        else
+          redirect_order(order)
+        end
+      end
+
+      def redirect_order(order)
+        pending_or_paid = order.paid? || @payment.pending?
+        if params[:app_checkout] == 'yes'
+          redirect_to pending_or_paid ? success_payway_results_path : failed_payway_results_path
+        else
+          flash[:order_completed] = '1' if order.paid? # required by order_just_completed for purchase tracking
+          redirect_to pending_or_paid ? order_path(order) : checkout_state_path(:payment)
+        end
+      end
+    end
+  end
+end

data/app/controllers/spree/wing/base_controller.rb

@@ -0,0 +1,29 @@
+module Spree
+  module Wing
+    class BaseController < ::ApplicationController
+      before_action :wing_http_authenticate!
+
+      rescue_from ActiveRecord::RecordNotFound, with: :not_found
+
+      def wing_http_authenticate!
+        wing_payment_method = Spree::PaymentMethod.find_by(type: Spree::PaymentMethod::TYPE_WINGSDK)
+
+        authenticate_or_request_with_http_basic do |username, password|
+          return false unless wing_payment_method.present?
+
+          if wing_payment_method.preferred_basic_auth_username.blank? ||
+             wing_payment_method.preferred_basic_auth_password.blank?
+            return false
+          end
+
+          username == wing_payment_method.preferred_basic_auth_username &&
+            password == wing_payment_method.preferred_basic_auth_password
+        end
+      end
+
+      def not_found
+        render json: { response_code: 404, response_msg: I18n.t(:resource_not_found, scope: 'spree.api') }, status: 404
+      end
+    end
+  end
+end

data/app/controllers/spree/wing/transactions_controller.rb

@@ -0,0 +1,27 @@
+module Spree
+  module Wing
+    class TransactionsController < BaseController
+      before_action :load_payment_source
+      def show
+        @transaction_status_response = Vpago::WingSdk::TransactionStatusResponse.new(@payment_source)
+        @transaction_status_response.call
+
+        render_result
+      end
+
+      private
+
+      def load_payment_source
+        @payment_source = ::Spree::VpagoPaymentSource.find_by!(transaction_id: params[:id])
+      end
+
+      def render_result
+        if @transaction_status_response.success?
+          render json: @transaction_status_response.result, status: 200
+        else
+          render json: { response_code: 422, response_msg: 'Unable to load response from wing' }, status: 422
+        end
+      end
+    end
+  end
+end

data/app/controllers/spree/wing_redirects_controller.rb

@@ -0,0 +1,20 @@
+module Spree
+  class WingRedirectsController < ApplicationController
+    layout 'wing'
+    before_action :load_payment, only: [:show]
+
+    def show
+      if @payment.present?
+        options = {
+          app_checkout: true
+        }
+
+        @client_redirect = ::Vpago::WingSdk::Checkout.new(@payment, options)
+      end
+    end
+
+    def load_payment
+      @payment = ::Spree::Payment.find_by(number: params[:payment_number])
+    end
+  end
+end

data/app/helpers/vpago/admin/base_helper_decorator.rb

@@ -0,0 +1,40 @@
+module Vpago
+  module Admin
+    module BaseHelperDecorator
+      def acleda_payment_card_options
+        { '0 - XPAY': 0, '1 - Visa, Master Card, etc.': 1 }
+      end
+
+      # frontend should implement these in UI
+      def available_payment_icons
+        %w[
+          payway_abapay_khqr
+          payway_abapay
+          payway_alipay
+          payway_wechat
+          acleda
+          acleda_khqr
+          acleda_cards
+          cheque
+          payway_cards
+          wingpay
+        ]
+      end
+
+      def preference_field_for(form, field, options)
+        case field
+        when 'preferred_acleda_type'
+          return form.select(:preferred_acleda_type, form.object.class::TYPES, {}, class: 'fullwidth select2')
+        when 'preferred_acleda_payment_card'
+          return form.select(:preferred_acleda_payment_card, acleda_payment_card_options, {},
+                             class: 'fullwidth select2')
+        when 'preferred_icon_name'
+          return form.select(:preferred_icon_name, available_payment_icons, {}, class: 'fullwidth select2')
+        end
+        super
+      end
+    end
+  end
+end
+
+Spree::Admin::BaseHelper.prepend(Vpago::Admin::BaseHelperDecorator)

data/app/helpers/vpago/vpago_payments_helper.rb

@@ -0,0 +1,12 @@
+module Vpago
+  module VpagoPaymentsHelper
+    def user_informer
+      'firebase'
+    end
+
+    # eg. forms/spree/gateway/payway_v2
+    def render_form
+      render partial: "spree/vpago_payments/forms/#{@payment.payment_method.class.to_s.underscore}"
+    end
+  end
+end

data/app/javascripts/vpago/vpago_payments/user_informers/firebase.js

@@ -0,0 +1,62 @@
+import { initializeApp } from "firebase/app";
+import { getFirestore, doc, onSnapshot, setDoc } from "firebase/firestore";
+
+async function listenToProcessingState({
+  firebaseConfigs,
+  orderNumber,
+  onPaymentIsProcessing,
+  onOrderIsProcessing,
+  onOrderIsCompleted,
+  onOrderProcessFailed,
+  onPaymentIsRefunded,
+  onPaymentProcessFailed,
+  onCompleted,
+}) {
+  const app = initializeApp(firebaseConfigs);
+  const db = getFirestore(app);
+
+  const currentDate = new Date().toISOString().split("T")[0];
+
+  const documentRef = doc(db, "statuses", "cart", currentDate, orderNumber);
+  await setDoc(documentRef, { listening: true }, { merge: true });
+
+  onSnapshot(documentRef, (doc) => {
+    let documentData = doc.data();
+
+    let orderState = documentData["order_state"];
+    let paymentState = documentData["payment_state"];
+    let messageCode = documentData["message_code"];
+    let logMessage = documentData["log_message"];
+
+    let orderCompleted = orderState === "complete";
+    if (orderCompleted) {
+      onCompleted(orderState, paymentState);
+      return;
+    }
+
+    switch (messageCode) {
+      case "payment_is_processing":
+        onPaymentIsProcessing(orderState, paymentState, logMessage);
+        break;
+      case "order_is_processing":
+        onOrderIsProcessing(orderState, paymentState, logMessage);
+        break;
+      case "order_is_completed":
+        onOrderIsCompleted(orderState, paymentState, logMessage);
+        break;
+      case "order_process_failed":
+        onOrderProcessFailed(orderState, paymentState, logMessage);
+        break;
+      case "payment_is_refunded":
+        onPaymentIsRefunded(orderState, paymentState, logMessage);
+        break;
+      case "payment_process_failed":
+        onPaymentProcessFailed(orderState, paymentState, logMessage);
+        break;
+      default:
+        break;
+    }
+  });
+}
+
+window.listenToProcessingState = listenToProcessingState;

data/app/jobs/application_unique_job.rb

@@ -0,0 +1 @@
+class ApplicationUniqueJob < ActiveJob::Base; end

data/app/jobs/vpago/payment_processor_job.rb

@@ -0,0 +1,8 @@
+module Vpago
+  class PaymentProcessorJob < ::ApplicationUniqueJob
+    def perform(options)
+      payment = Spree::Payment.find_by(number: options[:payment_number])
+      Vpago::PaymentProcessor.new(payment: payment).call
+    end
+  end
+end

data/app/models/concerns/vpago/payoutable.rb

@@ -0,0 +1,11 @@
+module Vpago
+  module Payoutable
+    extend ActiveSupport::Concern
+
+    included do
+      has_many :payouts, class_name: 'Spree::Payout', as: :payoutable
+      has_many :confirmed_payouts_for_vendor, -> { confirmed.where(default: false) },
+               class_name: 'Spree::Payout', as: :payoutable
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+module Spree
+  class Gateway::Acleda < PaymentMethod
+    preference :payment_expiry_time_in_mn, :integer
+    preference :host, :string
+    preference :login_id, :string
+    preference :password, :string
+    preference :merchant_id, :string
+    preference :merchant_name, :string
+    preference :signature, :string
+    preference :deeplink_partner_id, :string
+    preference :deeplink_data_encryption_key, :string
+    preference :success_url, :string
+    preference :error_url, :string
+    preference :other_url, :string
+    preference :acleda_company_name, :string
+    preference :acleda_payment_card, :integer
+
+    TYPES = %w[KHQR XPAY-MPGS].freeze
+    preference :acleda_type, :string
+
+    def xpay_mpgs?
+      preferred_acleda_type == 'XPAY-MPGS'
+    end
+
+    def khqr?
+      preferred_acleda_type == 'KHQR'
+    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 order has been cancelled.')
+    end
+  end
+end