add possibility to preview applied_credits application

Author: annvelents

app/services/credits/applied_prepaid_credits_service.rb

@@ -2,8 +2,9 @@
 
 module Credits
   class AppliedPrepaidCreditsService < BaseService
-    def initialize(invoice:)
+    def initialize(invoice:, preview: false)
       @invoice = invoice
+      @preview = preview
 
       super(nil)
     end
@@ -20,50 +21,21 @@ def call
 
       ActiveRecord::Base.transaction do
         Customers::LockService.call(customer:, scope: :prepaid_credit) do
-          ordered_remaining_amounts = calculate_amounts_for_fees_by_type_and_bm
-          remaining_invoice_amount = invoice.total_amount_cents
-
-          wallets.each do |wallet|
-            wallet.reload
-            wallet_fee_transactions = []
-            wallet_targets_array = wallet.wallet_targets.map do |wt|
-              if wt&.billable_metric_id
-                ["charge", wt.billable_metric_id]
-              end
-            end
-            wallet_types_array = wallet.allowed_fee_types
-
-            ordered_remaining_amounts.each do |fee_key, remaining_amount|
-              next if remaining_amount <= 0
-
-              next unless applicable_fee?(fee_key:, targets: wallet_targets_array, types: wallet_types_array, wallet:)
-
-              used_amount = wallet_fee_transactions.sum { |t| t[:amount_cents] }
-              remaining_wallet_balance = wallet.balance_cents - used_amount
-              next if remaining_wallet_balance <= 0
-
-              transaction_amount = [remaining_amount, remaining_wallet_balance, remaining_invoice_amount].min
-              next if transaction_amount <= 0
-
-              ordered_remaining_amounts[fee_key] -= transaction_amount
-              remaining_invoice_amount -= transaction_amount
-              wallet_fee_transactions << {
-                fee_key: fee_key,
-                amount_cents: transaction_amount
-              }
-            end
-            total_amount_cents = wallet_fee_transactions.sum { |t| t[:amount_cents] }
-            next if total_amount_cents <= 0
+          # per each wallet we create a single wallet transaction. wallets_transactions is a hash with wallet and total transaction amount
+          wallets_transactions = calculate_wallet_transactions
+          if preview
+            result.wallet_transactions = wallets_transactions
+            return result
+          end
 
-            wallet_transaction = create_wallet_transaction(wallet, total_amount_cents)
+          wallets_transactions.each do |wallet, amount_cents|
+            wallet_transaction = create_wallet_transaction(wallet, amount_cents)
+            result.wallet_transactions << wallet_transaction
 
             if wallet.traceable?
               WalletTransactions::TrackConsumptionService.call!(outbound_wallet_transaction: wallet_transaction)
             end
-
             Wallets::Balance::DecreaseService.call(wallet:, wallet_transaction:, skip_refresh: true)
-
-            result.wallet_transactions << wallet_transaction
           end
 
           update_prepaid_credit_amounts(result.wallet_transactions)
@@ -80,10 +52,53 @@ def call
 
     private
 
-    attr_accessor :invoice
+    attr_accessor :invoice, :preview
 
     delegate :customer, to: :invoice
 
+    def calculate_wallet_transactions
+      ordered_remaining_amounts = calculate_amounts_for_fees_by_type_and_bm
+      remaining_invoice_amount = invoice.total_amount_cents
+      wallets_transactions = {}
+
+      wallets.each do |wallet|
+        wallet.reload
+        wallet_fee_transactions = []
+        wallet_targets_array = wallet.wallet_targets.map do |wt|
+          if wt&.billable_metric_id
+            ["charge", wt.billable_metric_id]
+          end
+        end
+        wallet_types_array = wallet.allowed_fee_types
+        byebug
+
+        ordered_remaining_amounts.each do |fee_key, remaining_amount|
+          next if remaining_amount <= 0
+          byebug
+
+          next unless applicable_fee?(fee_key:, targets: wallet_targets_array, types: wallet_types_array, wallet:)
+
+          used_amount = wallet_fee_transactions.sum { |t| t[:amount_cents] }
+          remaining_wallet_balance = wallet.balance_cents - used_amount
+          next if remaining_wallet_balance <= 0
+
+          transaction_amount = [remaining_amount, remaining_wallet_balance, remaining_invoice_amount].min
+          next if transaction_amount <= 0
+
+          ordered_remaining_amounts[fee_key] -= transaction_amount
+          remaining_invoice_amount -= transaction_amount
+          wallet_fee_transactions << {
+            fee_key: fee_key,
+            amount_cents: transaction_amount
+          }
+        end
+        total_amount_cents = wallet_fee_transactions.sum { |t| t[:amount_cents] }
+        next if total_amount_cents <= 0
+        wallets_transactions[wallet] = total_amount_cents
+      end
+      wallets_transactions
+    end
+
     def schedule_webhook_notifications(wallet_transactions)
       wallet_transactions.each do |wt|
         Utils::ActivityLog.produce_after_commit(wt, "wallet_transaction.created")
@@ -125,8 +140,9 @@ def calculate_prepaid_credit_breakdown(wallet_transactions)
 
     def calculate_amounts_for_fees_by_type_and_bm
       remaining = Hash.new(0)
+      fees = invoice.persisted? ? invoice.fees.includes(:charge) : invoice.fees
 
-      invoice.fees.includes(:charge).find_each do |fee|
+      fees.each do |fee|
         next if fee.sub_total_excluding_taxes_amount_cents == 0
 
         cap = fee.sub_total_excluding_taxes_amount_cents +
@@ -162,6 +178,7 @@ def reconcile_remaining_amounts(ordered_remaining_amounts)
 
     def wallets_already_applied?
       return false unless invoice
+      return false unless invoice.persisted?
 
       WalletTransaction.exists?(invoice_id: invoice.id, wallet_id: wallets.map(&:id))
     end

app/services/invoices/preview_service.rb

@@ -264,23 +264,14 @@ def create_credit_note_credits
 
     def create_applied_prepaid_credits
       return unless customer.persisted?
-      return unless wallet
       return unless invoice.total_amount_cents&.positive?
-      return unless wallet.balance.positive?
 
-      amount_cents = if wallet.balance_cents <= invoice.total_amount_cents
-        wallet.balance_cents
-      else
-        invoice.total_amount_cents
-      end
-      invoice.prepaid_credit_amount_cents += amount_cents
-      invoice.total_amount_cents -= amount_cents
-    end
+      wallets_transactions = Credits::AppliedPrepaidCreditsService.call!(invoice:, preview: true).wallet_transactions
+      amount_cents = wallets_transactions.sum {|_k, v| v }
 
-    def wallet
-      return @wallet if defined? @wallet
 
-      @wallet = customer.wallets.active.first
+      invoice.prepaid_credit_amount_cents += amount_cents
+      invoice.total_amount_cents -= amount_cents
     end
 
     def apply_taxes

spec/scenarios/invoices/preview_spec.rb

@@ -81,4 +81,78 @@
       end
     end
   end
+
+  context "when wallet has allowed_fee_types restriction" do
+    let(:customer) { create(:customer, organization:) }
+    let(:plan) { create(:plan, organization:, amount_cents: 2_000) }
+
+    let(:preview_params) do
+      {
+        customer: {external_id: customer.external_id},
+        plan_code: plan.code,
+        billing_time: "calendar"
+      }
+    end
+
+    context "and the preview invoice contains only subscription fees" do
+      before do
+        create(
+          :wallet,
+          :with_inbound_transaction,
+          customer:,
+          organization:,
+          balance_cents: 500,
+          credits_balance: 5.0,
+          allowed_fee_types: %w[charge]
+        )
+      end
+
+      it "does not apply wallet credit to subscription fees" do
+        travel_to(DateTime.parse("2026-03-01 12:00:00")) do
+          post_with_token(organization, "/api/v1/invoices/preview", preview_params)
+
+          expect(response).to have_http_status(:success)
+          expect(json[:invoice]).to include(
+            fees_amount_cents: 2_000,
+            prepaid_credit_amount_cents: 0,
+            total_amount_cents: 2_000
+          )
+        end
+      end
+    end
+
+    context "and the preview invoice contains a mix of matching and non-matching fees" do
+      before do
+        create(:fixed_charge, plan:, units: 1, charge_model: "standard", properties: {amount: "3"})
+
+        create(
+          :wallet,
+          :with_inbound_transaction,
+          customer:,
+          organization:,
+          balance_cents: 500,
+          credits_balance: 5.0,
+          allowed_fee_types: %w[fixed_charge]
+        )
+      end
+
+      it "applies wallet credit only to matching fee types, capped at the fee amount" do
+        travel_to(DateTime.parse("2026-03-01 12:00:00")) do
+          # subscription fee = 2000 cents (full March, calendar billing)
+          # fixed_charge fee = 1 unit * 3 EUR = 300 cents
+          # wallet 500 cents is restricted to fixed_charge fees,
+          # so it can only consume against the 300 cents fixed_charge fee
+          # prepaid_credit_amount_cents = 300, NOT 500
+          post_with_token(organization, "/api/v1/invoices/preview", preview_params)
+
+          expect(response).to have_http_status(:success)
+          expect(json[:invoice]).to include(
+            fees_amount_cents: 2_300,
+            prepaid_credit_amount_cents: 300,
+            total_amount_cents: 2_000
+          )
+        end
+      end
+    end
+  end
 end