spree_vpago 0.1.0.pre.beta → 2.0.4.pre.beta1

data/app/controllers/spree/admin/payment_methods_controller_decorator.rb

@@ -3,7 +3,15 @@ module Spree
     module PaymentMethodsControllerDecorator
       def scope
         scope = current_store.payment_methods_including_vendor.accessible_by(current_ability, :index)
-        scope = scope.where.not(vendor_id: nil) if params[:tab] == 'vendors'
+
+        if params[:tab] == 'vendors'
+          scope = scope.where.not(vendor_id: nil)
+        elsif params[:tab] == 'tenants'
+          scope = scope.joins(:vendor)
+                       .where.not(vendor_id: nil)
+                       .where.not(spree_vendors: { tenant_id: nil })
+        end
+
         scope
       end
 

data/app/controllers/spree/vpago_payments_controller.rb

@@ -39,7 +39,8 @@ module Spree
     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_params = sanitize_return_params
+      @payment = Vpago::PaymentFinder.new(return_params).find_and_verify
       return render_not_found unless @payment.present?
 
       unless @payment.order.paid?
@@ -54,7 +55,16 @@ module Spree
       render json: { status: :internal_server_error, message: 'Failed to enqueue payment processor job' }, status: :internal_server_error
     end
 
-    def record_not_found
+    def sanitize_return_params
+      sanitized_params = params.permit!.to_h
+
+      # In ABA case, it returns params in side return params.
+      sanitized_params.merge!(JSON.parse(sanitized_params.delete(:return_params))) if sanitized_params[:return_params].present?
+
+      sanitized_params
+    end
+
+    def render_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 }

data/app/javascripts/queue_processor.js

@@ -0,0 +1,33 @@
+export default class QueueProcessor {
+  constructor() {
+    this.queues = [];
+    this.processing = false;
+  }
+
+  queueStateChange({ callback, minDelayInMs = 1000 }) {
+    this.queues.push({ callback, minDelayInMs });
+    if (!this.processing) this.#processQueue();
+  }
+
+  async #processQueue() {
+    if (this.queues.length === 0) {
+      this.processing = false;
+      return;
+    }
+
+    this.processing = true;
+    const { callback, minDelayInMs } = this.queues.shift();
+    const startTime = Date.now();
+
+    await callback();
+
+    const elapsedTime = Date.now() - startTime;
+    if (elapsedTime < minDelayInMs) {
+      await new Promise((resolve) =>
+        setTimeout(resolve, minDelayInMs - elapsedTime)
+      );
+    }
+
+    this.#processQueue();
+  }
+}

data/app/javascripts/queue_processor.test.js

@@ -0,0 +1,88 @@
+import { expect } from "chai";
+import QueueProcessor from "./queue_processor.js";
+
+describe("QueueProcessor", () => {
+  let queueProcessor;
+  let minDelayInMs = 100;
+
+  beforeEach(() => {
+    queueProcessor = new QueueProcessor();
+  });
+
+  it("should initially have an empty queue and not be processing", () => {
+    expect(queueProcessor.queues).to.have.lengthOf(0);
+    expect(queueProcessor.processing).to.equal(false);
+  });
+
+  it("should run queue 1 by 1 while keep min delay 100", async () => {
+    let timeToProcess = 50;
+
+    const mockCallback = () =>
+      new Promise((resolve) => setTimeout(resolve, timeToProcess));
+
+    queueProcessor.queueStateChange({
+      callback: mockCallback,
+      minDelayInMs: minDelayInMs,
+    });
+
+    queueProcessor.queueStateChange({
+      callback: mockCallback,
+      minDelayInMs: minDelayInMs,
+    });
+
+    queueProcessor.queueStateChange({
+      callback: mockCallback,
+      minDelayInMs: minDelayInMs,
+    });
+
+    expect(queueProcessor.queues).to.have.lengthOf(2);
+    expect(queueProcessor.processing).to.equal(true);
+
+    await new Promise((resolve) => setTimeout(resolve, minDelayInMs * 3 + 4)); // +4ms for buffer
+
+    expect(queueProcessor.queues).to.have.lengthOf(0);
+    expect(queueProcessor.processing).to.equal(false);
+  });
+
+  describe("when process take less than the delay", () => {
+    it("should process and wait for remaining delay", async () => {
+      let timeToProcess = 50;
+
+      const mockCallback = () =>
+        new Promise((resolve) => setTimeout(resolve, timeToProcess));
+
+      queueProcessor.queueStateChange({
+        callback: mockCallback,
+        minDelayInMs: minDelayInMs,
+      });
+
+      expect(queueProcessor.queues).to.have.lengthOf(0);
+      expect(queueProcessor.processing).to.equal(true);
+
+      await new Promise((resolve) => setTimeout(resolve, minDelayInMs + 1)); // +1ms for buffer
+
+      expect(queueProcessor.queues).to.have.lengthOf(0);
+      expect(queueProcessor.processing).to.equal(false);
+    });
+  });
+
+  describe("when process take longer than the delay", () => {
+    it("should process and not wait for delay", async () => {
+      let timeToProcess = 200;
+
+      const mockCallback = () =>
+        new Promise((resolve) => setTimeout(resolve, timeToProcess));
+
+      queueProcessor.queueStateChange({
+        callback: mockCallback,
+        minDelayInMs: minDelayInMs,
+      });
+
+      expect(queueProcessor.queues).to.have.lengthOf(0);
+      expect(queueProcessor.processing).to.equal(true);
+
+      await new Promise((resolve) => setTimeout(resolve, timeToProcess + 1)); // +1ms for buffer
+      expect(queueProcessor.processing).to.equal(false);
+    });
+  });
+});

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

@@ -1,9 +1,10 @@
 import { initializeApp } from "firebase/app";
 import { getFirestore, doc, onSnapshot, setDoc } from "firebase/firestore";
+import QueueProcessor from "../../../queue_processor.js";
 
 async function listenToProcessingState({
   firebaseConfigs,
-  orderNumber,
+  documentReferencePath,
   onPaymentIsProcessing,
   onOrderIsProcessing,
   onOrderIsCompleted,
@@ -15,43 +16,121 @@ async function listenToProcessingState({
   const app = initializeApp(firebaseConfigs);
   const db = getFirestore(app);
 
-  const currentDate = new Date().toISOString().split("T")[0];
-
-  const documentRef = doc(db, "statuses", "cart", currentDate, orderNumber);
+  const documentRef = doc(db, documentReferencePath);
   await setDoc(documentRef, { listening: true }, { merge: true });
 
+  const queueProcessor = new QueueProcessor();
+
   onSnapshot(documentRef, (doc) => {
     let documentData = doc.data();
 
+    let messageCode = documentData["message_code"];
     let orderState = documentData["order_state"];
     let paymentState = documentData["payment_state"];
-    let messageCode = documentData["message_code"];
-    let logMessage = documentData["log_message"];
+    let processing = documentData["processing"] === true;
+    let reasonCode = documentData["reason_code"];
+    let reasonMessage = documentData["reason_message"];
 
     let orderCompleted = orderState === "complete";
     if (orderCompleted) {
-      onCompleted(orderState, paymentState);
+      queueProcessor.queueStateChange({
+        minDelayInMs: 1500,
+        callback: async () => {
+          await onCompleted(
+            orderState,
+            paymentState,
+            reasonCode,
+            reasonMessage
+          );
+        },
+      });
       return;
     }
 
     switch (messageCode) {
       case "payment_is_processing":
-        onPaymentIsProcessing(orderState, paymentState, logMessage);
+        queueProcessor.queueStateChange({
+          minDelayInMs: 1500,
+          callback: async () => {
+            await onPaymentIsProcessing(
+              orderState,
+              paymentState,
+              processing,
+              reasonCode,
+              reasonMessage
+            );
+          },
+        });
         break;
       case "order_is_processing":
-        onOrderIsProcessing(orderState, paymentState, logMessage);
+        queueProcessor.queueStateChange({
+          minDelayInMs: 1500,
+          callback: async () => {
+            await onOrderIsProcessing(
+              orderState,
+              paymentState,
+              processing,
+              reasonCode,
+              reasonMessage
+            );
+          },
+        });
         break;
       case "order_is_completed":
-        onOrderIsCompleted(orderState, paymentState, logMessage);
+        queueProcessor.queueStateChange({
+          minDelayInMs: 1500,
+          callback: async () => {
+            await onOrderIsCompleted(
+              orderState,
+              paymentState,
+              processing,
+              reasonCode,
+              reasonMessage
+            );
+          },
+        });
         break;
       case "order_process_failed":
-        onOrderProcessFailed(orderState, paymentState, logMessage);
+        queueProcessor.queueStateChange({
+          minDelayInMs: 1500,
+          callback: async () => {
+            await onOrderProcessFailed(
+              orderState,
+              paymentState,
+              processing,
+              reasonCode,
+              reasonMessage
+            );
+          },
+        });
         break;
       case "payment_is_refunded":
-        onPaymentIsRefunded(orderState, paymentState, logMessage);
+        queueProcessor.queueStateChange({
+          minDelayInMs: 1500,
+          callback: async () => {
+            await onPaymentIsRefunded(
+              orderState,
+              paymentState,
+              processing,
+              reasonCode,
+              reasonMessage
+            );
+          },
+        });
         break;
       case "payment_process_failed":
-        onPaymentProcessFailed(orderState, paymentState, logMessage);
+        queueProcessor.queueStateChange({
+          minDelayInMs: 1500,
+          callback: async () => {
+            await onPaymentProcessFailed(
+              orderState,
+              paymentState,
+              processing,
+              reasonCode,
+              reasonMessage
+            );
+          },
+        });
         break;
       default:
         break;

data/app/jobs/vpago/payment_capturer_job.rb

@@ -0,0 +1,11 @@
+# Put :payment_processing at a higher priority in your project: config/sidekiq.yml
+module Vpago
+  class PaymentCapturerJob < ::ApplicationUniqueJob
+    queue_as :payment_processing
+
+    def perform(payment_id)
+      payment = Spree::Payment.find(payment_id)
+      payment.capture! if payment.pending?
+    end
+  end
+end

data/app/jobs/vpago/payment_processor_job.rb

@@ -1,5 +1,8 @@
+# Put :payment_processing at a higher priority in your project: config/sidekiq.yml
 module Vpago
   class PaymentProcessorJob < ::ApplicationUniqueJob
+    queue_as :payment_processing
+
     def perform(options)
       payment = Spree::Payment.find_by(number: options[:payment_number])
       Vpago::PaymentProcessor.new(payment: payment).call

data/app/models/vpago/address_decorator.rb

@@ -0,0 +1,10 @@
+module Vpago
+  module AddressDecorator
+    # override
+    def require_phone?
+      false
+    end
+  end
+end
+
+Spree::Address.prepend(Vpago::AddressDecorator) unless Spree::Address.included_modules.include?(Vpago::AddressDecorator)

data/app/models/vpago/order_decorator.rb

@@ -48,7 +48,9 @@ module Vpago
 
     # override
     def available_payment_methods(store = nil)
-      payment_methods = if vendor_payment_methods.any?
+      payment_methods = if respond_to?(:tenant) && tenant.present?
+                          tenant_payment_methods
+                        elsif vendor_payment_methods.any?
                           vendor_payment_methods
                         else
                           collect_payment_methods(store)
@@ -61,6 +63,10 @@ module Vpago
                                      end
     end
 
+    def tenant_payment_methods
+      tenant.tenant_payment_methods
+    end
+
     def line_items_count
       line_items.size
     end
@@ -72,6 +78,12 @@ module Vpago
     def order_adjustment_total
       adjustments.eligible.sum(:amount)
     end
+
+    # override this method if you want flexibility
+    # for example, host per payment method or tenant
+    def payment_host
+      ENV.fetch('DEFAULT_URL_HOST')
+    end
   end
 end
 

data/app/models/vpago/payment_decorator.rb

@@ -11,13 +11,30 @@ module Vpago
                     to: :url_constructor
     end
 
+    # override:
+    # to give payment another chance to re-process, even if it failed.
     def process!
-      # give payment another chance to re-process, even if it failed.
       update!(state: :checkout) if processing? || send(:has_invalid_state?)
 
       super
     end
 
+    # override:
+    # to allow capture faraday connection error. gateway_error method already write rails log for this.
+    def protect_from_connection_error
+      yield
+    rescue ActiveMerchant::ConnectionError => e
+      failure!
+      gateway_error(e)
+    rescue Faraday::ConnectionFailed, Faraday::TimeoutError => e
+      failure!
+      gateway_error(ActiveMerchant::ConnectionError.new(e.message, e))
+    end
+
+    def user_informer
+      @user_informer ||= ::Vpago::UserInformers::Firebase.new(order)
+    end
+
     def url_constructor
       @url_constructor ||= Vpago::PaymentUrlConstructor.new(self)
     end

data/app/overrides/spree/admin/payment_methods/index/payment_methods_tabs.html.erb.deface

@@ -4,6 +4,12 @@
 
 <% if params[:tab] == 'vendors' %>
   <div class="alert alert-info mb-3">
-    <%= svg_icon name: "info-circle.svg", classes: 'mr-2', width: '16', height: '16' %> Payment methods for each vendor. Once set, only those payment methods will be displayed to user.
+    <%= svg_icon name: "info-circle.svg", classes: 'mr-2', width: '16', height: '16' %> 
+    Payment methods for each vendor. Once set, only those payment methods will be displayed to users.
+  </div>
+<% elsif params[:tab] == 'tenants' %>
+  <div class="alert alert-info mb-3">
+    <%= svg_icon name: "info-circle.svg", classes: 'mr-2', width: '16', height: '16' %> 
+    Payment methods for each tenant. Once set, only those payment methods will be displayed to users.
   </div>
 <% end %>

data/app/overrides/spree/admin/payment_methods/index/tenant_body.html.erb.deface

@@ -0,0 +1,5 @@
+<!-- insert_before "[data-hook='admin_payment_methods_index_row_actions']" -->
+
+<% if params[:tab] == 'tenants' %>
+  <td class="text-center"><%= method.vendor&.name || 'N/A' %></td>
+<% end %>

data/app/overrides/spree/admin/payment_methods/index/tenant_header.html.erb.deface

@@ -0,0 +1,5 @@
+<!-- insert_before "[data-hook='admin_payment_methods_index_header_actions']" -->
+
+<% if params[:tab] == 'tenants' %>
+  <th class="text-center"><%= Spree.t(:tenant) %></th>
+<% end %>

data/app/serializers/spree/v2/storefront/payment_serializer_decorator.rb

@@ -3,7 +3,7 @@ module Spree
     module Storefront
       module PaymentSerializerDecorator
         def self.prepended(base)
-          base.attributes :pre_auth_status, :checkout_url
+          base.attributes :pre_auth_status, :checkout_url, :process_payment_url
         end
       end
     end

data/app/services/vpago/payment_processable.rb

@@ -0,0 +1,54 @@
+module Vpago
+  module PaymentProcessable
+    def cancel_pre_auth(reason_code, reason_message)
+      log_process('cancel_pre_auth') do
+        @payment.void_transaction!
+        user_informer.payment_is_refunded(
+          processing: false,
+          reason_code: reason_code,
+          reason_message: reason_message
+        )
+      end
+    end
+
+    # Allows canceling pre-authorization if:
+    # 1. The payment is pending or authorized.
+    # 2. Pre-auth is enabled, ensuring funds can be released to user if processing fails.
+    #    PaymentProcessor is usually called after payment is made, so canceling pre-auth typically works.
+    def can_cancel_pre_auth?
+      @payment.pending? || @payment.payment_method.enable_pre_auth?
+    end
+
+    def extract_completer_failure_reason_code(error)
+      return :some_line_items_are_out_of_stock if error.respond_to?(:to_h) && error.to_h[:base]&.include?(Spree.t(:insufficient_stock_lines_present))
+      return :some_variants_are_discontinued if error.respond_to?(:to_h) && error.to_h[:base]&.include?(Spree.t(:discontinued_variants_present))
+
+      :unable_to_complete_order
+    end
+
+    # example.
+    # Started Vpago::PaymentProcessor#process_payment! for payment_number: PX81YZX with args: {}
+    # Completed Vpago::PaymentProcessor#process_payment! for payment_number: PX81YZX in 2000ms
+    def log_process(method, *args)
+      start_time = Time.now
+      Rails.logger.error("Started #{self.class}##{method} for payment_number: #{@payment.number} with args: #{args}")
+
+      yield
+
+      duration_ms = (Time.now - start_time) * 1000
+      Rails.logger.error("Completed #{self.class}##{method} for payment_number: #{@payment.number} in #{duration_ms}ms")
+    end
+
+    def user_informer
+      @user_informer ||= ::Vpago::UserInformers::Firebase.new(@payment.order)
+    end
+
+    def success?
+      @error.nil?
+    end
+
+    def failure(error)
+      @error = error
+    end
+  end
+end

data/app/services/vpago/payment_processor.rb

@@ -1,6 +1,13 @@
+# Error reason code:
+# - :some_line_items_are_out_of_stock
+# - :some_variants_are_discontinued
+# - :unable_to_complete_order
+# - :invalid_state_machine_transition
+# - :unable_to_connect_to_gateway
+# - :gateway_error
 module Vpago
   class PaymentProcessor
-    attr_accessor :payment, :error
+    include PaymentProcessable
 
     def initialize(payment:)
       @payment = payment
@@ -8,65 +15,75 @@ module Vpago
     end
 
     def call
+      log_process('call!') { call! }
+    end
+
+    def call!
       process_payment!
-      return process_order if payment.completed? || payment.pending?
+      process_order! if @payment.completed? || @payment.pending?
+    rescue Spree::Core::GatewayError => e
+      return handle_payment_failure(:unable_to_connect_to_gateway, e.message) if e.message == Spree.t(:unable_to_connect_to_gateway)
 
-      mark_payment_process_failed
-    rescue Spree::Core::GatewayError, StateMachines::InvalidTransition => e
-      mark_payment_process_failed(e.message)
+      handle_payment_failure(:gateway_error, e.message)
+    rescue StateMachines::InvalidTransition => e
+      handle_payment_failure(:invalid_state_machine_transition, e.message)
     end
 
     private
 
+    # payment.process! will throw GatewayError if not success.
     def process_payment!
-      user_informer.payment_is_processing(processing: true)
-      payment.process!
-    end
-
-    def process_order
-      user_informer.order_is_processing(processing: true)
-      completer = Spree::Checkout::Complete.new.call(order: payment.order)
-
-      if completer.success?
-        mark_order_process_completed
-      else
-        mark_order_process_failed(completer.error.to_s)
+      log_process('process_payment!') do
+        user_informer.payment_is_processing(processing: true)
+        @payment.process!
       end
     end
 
-    def mark_order_process_completed
-      payment.capture! if payment.pending?
-      user_informer.order_is_completed(processing: false)
+    def process_order!
+      log_process('process_order!') do
+        user_informer.order_is_processing(processing: true)
+        completer = Spree::Checkout::Complete.new.call(order: @payment.order)
+
+        if completer.success?
+          handle_order_process_completed
+        else
+          reason_code = extract_completer_failure_reason_code(completer.error)
+          handle_order_process_failure(reason_code, completer.error.to_s)
+        end
+      end
     end
 
-    def mark_order_process_failed(message)
-      user_informer.order_process_failed(processing: payment.pending?, log_message: message)
-
-      if payment.pending?
-        payment.void_transaction!
-        user_informer.payment_is_refunded(processing: false)
+    def handle_order_process_completed
+      log_process('handle_order_process_completed') do
+        Vpago::PaymentCapturerJob.perform_now(@payment.id) if @payment.pending?
+        user_informer.order_is_completed(processing: false)
       end
-
-      failure(message)
     end
 
-    def mark_payment_process_failed(message = nil)
-      message ||= Spree.t(:payment_process_failed)
-
-      user_informer.payment_process_failed(processing: false, log_message: message)
-      failure(message)
-    end
+    def handle_order_process_failure(reason_code, reason_message = nil)
+      log_process('handle_order_process_failure', reason_code, reason_message) do
+        user_informer.order_process_failed(
+          processing: can_cancel_pre_auth?,
+          reason_code: reason_code,
+          reason_message: reason_message
+        )
 
-    def user_informer
-      @user_informer ||= ::Vpago::UserInformers::Firebase.new(payment.order)
+        cancel_pre_auth(reason_code, reason_message) if can_cancel_pre_auth?
+        failure(reason_message)
+      end
     end
 
-    def success?
-      @error.nil?
-    end
+    def handle_payment_failure(reason_code, reason_message)
+      log_process('handle_payment_failure', reason_code, reason_message) do
+        user_informer.payment_process_failed(
+          processing: can_cancel_pre_auth?,
+          reason_code: reason_code,
+          reason_message: reason_message
+        )
 
-    def failure(error)
-      @error = error
+        cancel_pre_auth(reason_code, reason_message) if can_cancel_pre_auth?
+        failure(reason_message)
+      end
     end
   end
 end

data/app/services/vpago/payment_url_constructor.rb

@@ -21,7 +21,7 @@ module Vpago
     private
 
     def base_url
-      ENV.fetch('DEFAULT_URL_HOST')
+      order.payment_host
     end
 
     def order_jwt_token