spree_cm_commissioner 2.13.4 → 2.13.7

data/app/models/spree_cm_commissioner/notification.rb

@@ -20,6 +20,14 @@ module SpreeCmCommissioner
           ticket_transfer_completed_notification
           ticket_transfer_rejected_notification
           ticket_transfer_expired_notification
+          reschedule_requested_notification
+          reschedule_approved_notification
+          reschedule_completed_notification
+          reschedule_rejected_notification
+          reschedule_cancelled_notification
+          reschedule_expired_notification
+          reschedule_failed_notification
+          reschedule_payment_reminder_notification
         ]
       )
     }

data/app/models/spree_cm_commissioner/order_decorator.rb

@@ -11,6 +11,7 @@ module SpreeCmCommissioner
       base.include SpreeCmCommissioner::OrderScopes
       base.include SpreeCmCommissioner::TicketTransferable
       base.include SpreeCmCommissioner::OrderQrCodeable
+      base.include SpreeCmCommissioner::OrderPrepaidPayment
 
       base.before_create :link_by_phone_number
       base.before_create :associate_customer
@@ -21,7 +22,7 @@ module SpreeCmCommissioner
       base.store_private_metadata :preload_main_trip_ids, :array, default: []
       base.store_public_metadata :order_options, :array, default: []
 
-      base.money_methods :service_fee_total
+      base.money_methods :service_fee_total, :payment_fee_total
 
       base.validates :promo_total, base::MONEY_VALIDATION
       base.validates :phone_number, presence: true, if: :require_phone_number
@@ -40,6 +41,9 @@ module SpreeCmCommissioner
       base.has_many :vendors, through: :products, class_name: 'Spree::Vendor'
       base.has_many :taxons, through: :products, class_name: 'Spree::Taxon'
       base.has_many :guests, through: :line_items, class_name: 'SpreeCmCommissioner::Guest'
+      base.has_many :reschedule_requests,
+                    class_name: 'SpreeCmCommissioner::RescheduleRequest',
+                    foreign_key: :order_id
 
       base.has_many :saved_guests,
                     -> { reorder(nil).distinct },
@@ -51,6 +55,7 @@ module SpreeCmCommissioner
       base.has_many :reserved_blocks, through: :guests, class_name: 'SpreeCmCommissioner::ReservedBlock'
       base.has_many :guest_card_classes, class_name: 'SpreeCmCommissioner::GuestCardClass', through: :variants
       base.has_many :product_completion_steps, class_name: 'SpreeCmCommissioner::ProductCompletionStep', through: :line_items
+      base.has_many :audit_events, class_name: 'SpreeCmCommissioner::AuditEvent', as: :auditable
 
       base.delegate :customer, to: :user, allow_nil: true
 
@@ -166,6 +171,17 @@ module SpreeCmCommissioner
       SpreeCmCommissioner::ServiceFeeRule.adjust(self, line_items)
     end
 
+    # A payment fee is only correct for the total it was computed on, so one left over from an
+    # earlier payment attempt is dropped whenever checkout steps re-run. Skipped once a gateway
+    # payment exists: its amount already includes the fee, and clearing it would make the order
+    # total smaller than what that payment charges.
+    def clear_stale_payment_fee!
+      return unless adjustments.payment_fee.exists?
+      return if payments.valid.any? { |payment| !payment.store_credit? }
+
+      SpreeCmCommissioner::PaymentFees::Clear.call(order: self)
+    end
+
     # overrided
     def payment_required?
       return false if need_confirmation?
@@ -221,12 +237,18 @@ module SpreeCmCommissioner
     def create_default_payment_if_eligble
       return unless subscription?
 
-      if covered_by_store_credit
+      # `covered_by_store_credit` checks the total across the user's store-default-currency
+      # credit, so re-scope to this order's own store/currency here -- a user with credit in
+      # more than one currency (e.g. USD and KHR) must have the source credit match the order's
+      # currency, or Spree::StoreCredit#authorize rejects it as a currency_mismatch.
+      store_credit = covered_by_store_credit && user.store_credits.for_store(store).where(currency: currency).order_by_priority.first
+
+      if store_credit
         payment_method = Spree::PaymentMethod::StoreCredit.available_on_back_end.first_or_create! do |method|
           method.name ||= 'StoreCredit'
           method.stores = [Spree::Store.default] if method.stores.empty?
         end
-        source_id = user.store_credit_ids.last
+        source_id = store_credit.id
         source_type = 'Spree::StoreCredit'
       else
         payment_method = Spree::PaymentMethod::Check.available_on_back_end.first_or_create! do |method|
@@ -247,6 +269,12 @@ module SpreeCmCommissioner
       subscription.present?
     end
 
+    # A top-up order carries only the virtual `prepaid_top_up` product -- never mixed with
+    # real products. See docs/concepts/store-credit-wallet-system.md Section 4.1.
+    def prepaid_top_up_order?
+      line_items.present? && products.all?(&:prepaid_top_up?)
+    end
+
     # Returns true when the order was created under a tenant context.
     def purchased_from_tenant?
       !tenant_id.nil?

data/app/models/spree_cm_commissioner/order_updater_decorator.rb

@@ -12,10 +12,14 @@ module SpreeCmCommissioner
     def update_adjustment_total
       super
       order.service_fee_total = line_items.sum(:service_fee_total)
+
+      # Order-level adjustments (see PaymentFees::Apply) are already in adjustment_total via
+      # core's `adjustments.eligible.sum(:amount)`; this is the display-only breakdown.
+      order.payment_fee_total = adjustments.payment_fee.eligible.sum(:amount)
     end
 
     # Duplicates Spree::OrderUpdater#persist_totals' update_columns call (spree_core 4.5.3)
-    # rather than calling super + a second update_columns for service_fee_total, to keep this
+    # rather than calling super + a second update_columns for the fee totals, to keep this
     # to a single UPDATE per order -- with read replicas/connection pooling in front of this,
     # a second round-trip per persist_totals call isn't free. Must be kept in sync if core ever
     # changes that column list.
@@ -33,6 +37,7 @@ module SpreeCmCommissioner
         promo_total: order.promo_total,
         total: order.total,
         service_fee_total: order.service_fee_total,
+        payment_fee_total: order.payment_fee_total,
         updated_at: Time.current
       )
     end

data/app/models/spree_cm_commissioner/payment_decorator.rb

@@ -33,6 +33,22 @@ module SpreeCmCommissioner
       payment_method.is_a?(Spree::PaymentMethod::Check)
     end
 
+    # Reschedule linkage. CollectPayment stamps the owning request's id into
+    # private_metadata so the completed-payment hook, the expiry guard, and the
+    # stale-payment sweep can all find "the payment for this reschedule" without
+    # re-deriving the metadata key in each place.
+    def reschedule_request_id
+      private_metadata.to_h['reschedule_request_id']
+    end
+
+    def reschedule_request_id=(value)
+      self.private_metadata = private_metadata.to_h.merge('reschedule_request_id' => value)
+    end
+
+    def for_reschedule_request?(request)
+      reschedule_request_id.to_s == request.id.to_s
+    end
+
     # @override Spree::Payment#after_completed
     # Runs inside the transition to :completed, so completing the transfer stays
     # atomic with the payment. Payment completion is the single trigger for
@@ -40,6 +56,7 @@ module SpreeCmCommissioner
     def after_completed
       super
       order.complete_ticket_transfer_if_ready
+      execute_reschedule_if_completable
       order.run_order_complete_alerts
     end
 
@@ -56,6 +73,8 @@ module SpreeCmCommissioner
     private
 
     def lock_holds_for_payment
+      return if reschedule_request_id.present?
+
       order.lock_order_holds_for_payment
     end
 
@@ -67,6 +86,18 @@ module SpreeCmCommissioner
         .set(wait: delay)
         .perform_later(order_id: order.id)
     end
+
+    def execute_reschedule_if_completable
+      return unless completed?
+
+      request_id = reschedule_request_id
+      return if request_id.blank?
+
+      request = SpreeCmCommissioner::RescheduleRequest.find_by(id: request_id, state: 'pending_payment')
+      return if request.nil?
+
+      SpreeCmCommissioner::RescheduleRequests::ExecuteJob.perform_later(reschedule_request_id: request.id)
+    end
   end
 end
 

data/app/models/spree_cm_commissioner/payment_fee_rule.rb

@@ -0,0 +1,97 @@
+module SpreeCmCommissioner
+  class PaymentFeeRule < SpreeCmCommissioner::Base
+    include SpreeCmCommissioner::ScopedFeeRule
+    include Spree::AdjustmentSource
+    include Spree::CalculatedAdjustments
+
+    # Same reason as ServiceFeeRule: without class_name Rails looks for
+    # SpreeCmCommissioner::Adjustment.
+    has_many :adjustments, as: :source, class_name: 'Spree::Adjustment'
+
+    # optional: false spelled out because Spree turns off belongs_to_required_by_default; without
+    # it a blank admin form reaches the NOT NULL column and raises instead of showing a form error.
+    belongs_to :payment_method, class_name: 'Spree::PaymentMethod', optional: false
+
+    # One rule per (payment method, scope, currency), active or not: `active` is an on/off switch,
+    # not a way to keep old versions around. A duplicate is pointed at the existing rule instead
+    # (see #duplicate_rule and the admin form).
+    validates :currency,
+              uniqueness: {
+                scope: %i[payment_method_id ruleable_type ruleable_id tenant_id],
+                case_sensitive: false,
+                message: lambda { |object, _data|
+                  I18n.t('payment_fee.rules.rule_already_exists_for_scope',
+                         payment_method: object.payment_method&.name,
+                         scope_type: object.ruleable_type_label,
+                         currency: object.currency
+                        )
+                }
+              }
+
+    scope :for_payment_method, -> (payment_method) { where(payment_method_id: payment_method) }
+
+    def duplicate_rule
+      self.class.where.not(id: id).find_by(
+        payment_method_id: payment_method_id, ruleable_type: ruleable_type, ruleable_id: ruleable_id,
+        tenant_id: tenant_id, currency: currency
+      )
+    end
+
+    # Caches on the payment method whether any active rule exists for it, at any scope, so the
+    # catalog can serialize fee_configured without a query. Coarser than "could reach this vendor"
+    # (a shared store method is flagged for every vendor once one vendor has a fee), but `false`
+    # still guarantees no fee, which is all the client relies on.
+    after_commit :sync_payment_method_fee_configured!
+
+    def self.resolve_for(line_item:, payment_method:, currency:)
+      resolve_scoped(line_item: line_item, currency: currency, relation: for_payment_method(payment_method))
+    end
+
+    def self.available_calculator_types
+      [SpreeCmCommissioner::Calculators::PaymentFeePercent, SpreeCmCommissioner::Calculators::PaymentFeeFlatAmount]
+    end
+
+    # Required by Spree::AdjustmentSource, but PaymentFees::Apply never goes through it: it stores
+    # the amounts PaymentFees::Preview computed, as closed adjustments, so this is only reached if
+    # something reopens one. Recomputing here would need the whole order's gateway split, so keep
+    # whatever was stored.
+    def compute_amount(adjustable)
+      adjustments.find_by(adjustable: adjustable)&.amount || 0
+    end
+
+    def fee_description
+      return Spree.t(:service_fee_rule_not_configured) if calculator.nil?
+      return Spree.t(:payment_fee_mode_none) if no_fee?
+
+      calculator.fee_description(currency: currency)
+    end
+
+    # An explicit zero rule: how a narrower scope opts out of a broader rule's fee.
+    def no_fee?
+      case calculator
+      when Calculators::PaymentFeePercent
+        calculator.preferred_percent.to_d.zero? && calculator.preferred_flat_amount.to_d.zero?
+      when Calculators::PaymentFeeFlatAmount
+        calculator.preferred_flat_amount.to_d.zero?
+      else
+        true
+      end
+    end
+
+    def label
+      Spree.t(:payment_fee)
+    end
+
+    private
+
+    # Also re-syncs the previous method when a rule moves to another one.
+    def sync_payment_method_fee_configured!
+      ids = [payment_method_id, payment_method_id_previously_was].compact.uniq
+
+      Spree::PaymentMethod.where(id: ids).find_each do |payment_method|
+        payment_method.preload_fee_configured = self.class.active_rules.exists?(payment_method_id: payment_method.id)
+        payment_method.save! if payment_method.changed?
+      end
+    end
+  end
+end

data/app/models/spree_cm_commissioner/payment_method_decorator.rb

@@ -7,6 +7,11 @@ module SpreeCmCommissioner
 
       base.whitelisted_ransackable_attributes = %w[name]
 
+      base.include SpreeCmCommissioner::StoreMetadata
+      # Kept in sync by PaymentFeeRule#sync_payment_method_fee_configured!, so the cached payment
+      # methods catalog can say whether to ask for fee previews without a rules query per request.
+      base.store_private_metadata :preload_fee_configured, :boolean, default: false
+
       # Expose a dedicated class helper so services can call Spree::PaymentMethod.ticket_transfer
       # instead of duplicating lookup/creation logic.
       base.define_singleton_method(:ticket_transfer) do

data/app/models/spree_cm_commissioner/payment_method_store_credit_decorator.rb

@@ -0,0 +1,81 @@
+module SpreeCmCommissioner
+  module PaymentMethodStoreCreditDecorator
+    # Forced false, not left as a per-store admin toggle: OrderStateMachine#
+    # capture_authorized_store_credit_payments! is the only thing that ever captures a store-credit
+    # payment, deferring it until stock is confirmed cut inside the same DB transaction as order
+    # completion (see docs/concepts/store-credit-wallet-system.md Section 5). If a store's own
+    # PaymentMethod::StoreCredit#auto_capture column were left/set true, process_payments! would
+    # capture (spend) the wallet balance immediately, before stock is cut -- reintroducing the
+    # "captured, then stock fails, needs a manual refund" case this design exists to avoid.
+    def auto_capture?
+      false
+    end
+
+    # Reuses the payment's own pre-generated response_code as this authorize event's
+    # authorization_code, instead of letting Spree::StoreCredit#authorize mint a fresh one.
+    # Spree::StoreCreditEvent#order (core) resolves by matching authorization_code back to
+    # Payment#response_code -- if authorize generates its own code, that match fails until
+    # Payment::Processing#handle_response updates response_code afterward, which happens too
+    # late for StoreCreditEventDecorator's after_create ledger mirror (PrepaidTransaction#order
+    # comes back nil). Reusing the code the payment already carries closes that gap
+    # unconditionally, including for an authorization that's later voided or never captured --
+    # exactly the case where a customer would most want their wallet history to still point back
+    # at the order.
+    #
+    # started_processing! (Payment::Processing#process_authorization) already stamps state:
+    # 'processing' before this method is ever reached, and store_credit.with_lock (inside
+    # handle_action_call, below) serializes concurrent authorize attempts on the same
+    # store_credit -- so at most one payment can genuinely be 'processing' against this source
+    # at a time.
+    #
+    # Duplicates core's Spree::PaymentMethod::StoreCredit#authorize body (rather than calling
+    # super) because the only way to change what's passed to Spree::StoreCredit#authorize is to
+    # rebuild the lambda that calls it -- core exposes no hook to inject an extra keyword arg.
+    def authorize(amount_in_cents, store_credit, gateway_options = {})
+      return super if store_credit.nil?
+
+      payment = Spree::Payment.find_by(source: store_credit, payment_method: self, state: 'processing')
+
+      action = lambda do |sc|
+        sc.authorize(
+          amount_in_cents / 100.0.to_d,
+          gateway_options[:currency],
+          action_originator: gateway_options[:originator],
+          action_authorization_code: payment&.response_code
+        )
+      end
+      handle_action_call(store_credit, action, :authorize)
+    end
+
+    # Core's own #cancel (called by Spree::Order#after_cancel -> Payment#cancel! for every
+    # *completed* payment on a canceled order -- this is the path that reverses a captured
+    # store-credit payment when the order itself gets canceled, not the top-up wallet reversal in
+    # Prepaid::ReverseOrderTopUp, which is a separate ledger entirely) calls `store_credit.credit`
+    # with zero options -- no gateway_options, no originator -- so the mirrored PrepaidTransaction
+    # this produces (StoreCreditEventDecorator#mirror_to_prepaid_ledger) always came out with a
+    # blank Note, with no way to tell it apart from a manual admin credit after the fact.
+    #
+    # Passing the payment itself as originator gives mirrored_reason something concrete to point
+    # at (the order), even though this is a genuine Spree::Payment, not a Spree::Refund -- core
+    # only ever reads `originator` back through polymorphic association, it never assumes a type.
+    #
+    # Duplicates core's #cancel body (rather than calling super) for the same reason #authorize
+    # above does: the only way to add an option to the store_credit.credit call is to rebuild the
+    # lambda that makes it.
+    def cancel(auth_code, payment = nil)
+      store_credit_event = Spree::StoreCreditEvent.find_by(authorization_code: auth_code, action: Spree::StoreCredit::CAPTURE_ACTION)
+      store_credit = store_credit_event.try(:store_credit)
+
+      return super if !store_credit_event || !store_credit
+
+      action = lambda do |sc|
+        sc.credit(store_credit_event.amount, auth_code, sc.currency, action_originator: payment)
+      end
+      handle_action(action, :cancel, auth_code)
+    end
+  end
+end
+
+unless Spree::PaymentMethod::StoreCredit.included_modules.include?(SpreeCmCommissioner::PaymentMethodStoreCreditDecorator)
+  Spree::PaymentMethod::StoreCredit.prepend SpreeCmCommissioner::PaymentMethodStoreCreditDecorator
+end

data/app/models/spree_cm_commissioner/place.rb

@@ -1,5 +1,7 @@
 module SpreeCmCommissioner
   class Place < Base
+    include SpreeCmCommissioner::Integrations::IntegrationMappable
+
     acts_as_nested_set
 
     validates :reference, presence: true, if: :validate_reference?

data/app/models/spree_cm_commissioner/prepaid_config.rb

@@ -0,0 +1,59 @@
+module SpreeCmCommissioner
+  # Presenter-shaped value object for GET prepaid/config -- reads the same platform-wide
+  # Spree::Store.default currency settings that Prepaid::TopUp already enforces
+  # (docs/concepts/store-credit-wallet-system.md Section 8), plus the fraud/velocity limits from
+  # SpreeCmCommissioner::Configuration. `id` is a fixed string since this isn't a database-backed
+  # resource; jsonapi-serializer requires one.
+  #
+  # supported_currencies/preferred_currency/currency_limits ARE tenant-aware, though: pass
+  # `tenant:` (from Spree::Api::V2::Tenant::BaseController#require_tenant) to resolve
+  # Tenant#supported_currencies_list/#preferred_currency_or_default instead of the platform
+  # ceiling -- these are the exact same values POST draft_orders/topup and GET account/prepaid
+  # already validate/default `?currency=` against (Tenant::BaseController#
+  # resolve_requested_currency), just finally made discoverable by the client instead of only
+  # enforced after the fact on submit.
+  PrepaidConfig = Struct.new(
+    :id, :daily_topup_count, :supported_currencies, :preferred_currency, :currency_limits,
+    keyword_init: true
+  ) do
+    def self.resolve(tenant: nil)
+      config = SpreeCmCommissioner::Configuration.new
+      store = Spree::Store.default
+      preferred_currency = tenant ? tenant.preferred_currency_or_default : store.default_currency
+      supported_currencies = order_preferred_first(
+        tenant ? tenant.supported_currencies_list : store.supported_currency_codes, preferred_currency
+      )
+
+      new(
+        id: 'prepaid_config',
+        daily_topup_count: config.prepaid_max_topup_count_daily,
+        supported_currencies: supported_currencies,
+        preferred_currency: preferred_currency,
+        currency_limits: build_currency_limits(config, supported_currencies)
+      )
+    end
+
+    # Preferred currency first, so the client's currency picker (and the currency_limits hash
+    # key order below, which Ruby/JSON preserves) both default to it without the client having
+    # to know which entry is preferred and reorder it themselves.
+    def self.order_preferred_first(currencies, preferred_currency)
+      currencies.sort_by { |currency| currency == preferred_currency ? 0 : 1 }
+    end
+
+    # Scales the base limits into each supported currency via Configuration#prepaid_currency_rates.
+    # A currency missing a configured rate is omitted rather than shown unconverted.
+    def self.build_currency_limits(config, supported_currencies)
+      supported_currencies.each_with_object({}) do |currency, limits|
+        rate = config.prepaid_currency_rates[currency]
+        next unless rate
+
+        limits[currency] = {
+          min_topup_amount: (config.prepaid_topup_min_amount * rate).round(2),
+          max_topup_amount: (config.prepaid_topup_max_amount * rate).round(2),
+          daily_topup_amount: (config.prepaid_daily_topup_limit * rate).round(2),
+          max_balance: (config.prepaid_max_balance * rate).round(2)
+        }
+      end
+    end
+  end
+end

data/app/models/spree_cm_commissioner/prepaid_transaction.rb

@@ -0,0 +1,102 @@
+module SpreeCmCommissioner
+  class PrepaidTransaction < Base
+    include SpreeCmCommissioner::StoreMetadata
+
+    TRANSACTION_TYPES = %w[
+      top_up admin_credit authorize capture void credit reverse_top_up freeze unfreeze
+    ].freeze
+
+    STATUSES = %w[pending completed failed reversed].freeze
+
+    # English fallback label for every TRANSACTION_TYPES value -- covers capture/reverse_top_up
+    # too, even though neither is customer-facing (see CUSTOMER_FACING_TYPES below), because the
+    # admin dashboard/per-user transactions tabs show every type with no allowlist filter; without
+    # an entry here those rows would display the raw, un-friendly type string instead of a label.
+    DISPLAY_TYPES = {
+      'top_up' => 'Top Up',
+      'admin_credit' => 'Admin Credit',
+      'authorize' => 'Purchase',
+      'capture' => 'Capture',
+      'void' => 'Canceled',
+      'credit' => 'Refund',
+      'reverse_top_up' => 'Reversal',
+      'freeze' => 'Freeze',
+      'unfreeze' => 'Unfreeze'
+    }.freeze
+
+    # Which types ever reach the customer-facing storefront/tenant API (see
+    # PrepaidTransactionsController::DISPLAYED_TRANSACTION_TYPES). Excludes `capture` (always
+    # amount: 0, a bookkeeping-only row that never changes the balance) and `freeze`/`unfreeze`
+    # (also amount: 0 -- a status change, not a transaction; nothing useful to show in a money
+    # list, and no client currently renders them).
+    #
+    # reverse_top_up IS included, even though it's admin-initiated: Prepaid::ReverseTopUp
+    # actually reduces the credit's real amount, so hiding it would leave an admin_credit/top_up
+    # row permanently visible with no visible transaction explaining why that money is gone --
+    # exactly the "I see a transaction but the balance doesn't match" confusion this list exists
+    # to prevent. Kept as its own list rather than derived from DISPLAY_TYPES.keys, so expanding
+    # DISPLAY_TYPES for the admin UI's sake can't silently widen what customers are shown.
+    CUSTOMER_FACING_TYPES = %w[top_up admin_credit authorize void credit reverse_top_up].freeze
+
+    belongs_to :user, class_name: 'Spree::User'
+    belongs_to :store_credit, class_name: 'Spree::StoreCredit'
+    belongs_to :tenant, class_name: 'SpreeCmCommissioner::Tenant', optional: true
+    belongs_to :order, class_name: 'Spree::Order', optional: true
+    # The admin who performed an admin-initiated action (admin_credit, reverse_top_up, freeze,
+    # unfreeze) -- a real column, not a metadata key, since "who did this" is audit-critical,
+    # queryable identity data (see the migration adding this column for the full reasoning).
+    # nil for non-admin-initiated types (top_up, authorize, capture, void, credit).
+    belongs_to :admin, class_name: 'Spree::User', optional: true
+
+    # Internal/audit detail that's never exposed to a customer via an API serializer -- freeze
+    # metadata isn't identity data (unlike admin_id above) and doesn't need to be queried on, so
+    # it doesn't need its own column. requested_amount/reversed_amount (reverse_top_up) are
+    # written directly into private_metadata without a typed accessor below -- StoreMetadata has
+    # no :decimal type, and these are money amounts where losing precision through a lossy type
+    # cast isn't acceptable.
+    store_private_metadata :reason, :text
+    store_private_metadata :level, :string
+    store_private_metadata :until_at, :datetime
+    store_private_metadata :prior_frozen_by_id, :integer
+    store_private_metadata :prior_freeze_reason, :text
+    store_private_metadata :prior_freeze_level, :string
+
+    # Spree::Money-formatted display_amount/display_balance_after, same display_* convention as
+    # products/orders/store credits (Spree::DisplayMoney). Negative on authorize rows (a hold) --
+    # Spree::Money formats the sign as-is, no special-casing needed here.
+    extend Spree::DisplayMoney
+    money_methods :amount, :balance_after
+
+    validates :transaction_type, presence: true
+    validates :amount, :balance_after, numericality: true
+    validates :currency, presence: true
+    validates :idempotency_key, presence: true
+    validates :status, inclusion: { in: STATUSES }
+
+    scope :for_tenant, -> (tenant_id) { where(tenant_id: tenant_id) }
+    scope :completed, -> { where(status: 'completed') }
+
+    def self.ransackable_attributes(_auth_object = nil)
+      %w[transaction_type status currency tenant_id user_id store_credit_id admin_id created_at]
+    end
+
+    # user/order let the admin wallet transactions search filter by user_email_cont/
+    # order_number_cont without exposing every association on the model.
+    self.whitelisted_ransackable_associations = %w[user order]
+
+    def readonly?
+      persisted? && status_was == 'completed'
+    end
+
+    # Client-facing label for `transaction_type` ("Top Up" / "Purchase"), localized to the
+    # current request's locale -- DISPLAY_TYPES only supplies the English fallback; the actual
+    # string comes from locale files, so a Khmer-speaking client doesn't get English baked into
+    # the API response. See CUSTOMER_FACING_TYPES for which types customers are ever shown.
+    def display_type
+      I18n.t(
+        "spree_cm_commissioner.prepaid_transaction.display_type.#{transaction_type}",
+        default: DISPLAY_TYPES.fetch(transaction_type, transaction_type)
+      )
+    end
+  end
+end

data/app/models/spree_cm_commissioner/product_decorator.rb

@@ -37,6 +37,12 @@ module SpreeCmCommissioner
       base.has_one :default_state, through: :vendor
       base.has_one :google_wallet, class_name: 'SpreeCmCommissioner::GoogleWallet', dependent: :destroy
 
+      base.has_one :reschedule_policy_assignment, as: :policyable,
+                                                  class_name: 'SpreeCmCommissioner::ReschedulePolicyAssignment',
+                                                  dependent: :destroy
+      base.has_one :reschedule_policy, through: :reschedule_policy_assignment,
+                                       class_name: 'SpreeCmCommissioner::ReschedulePolicy'
+
       base.has_many :complete_line_items, through: :classifications, source: :line_items
       base.has_many :inventory_items, through: :variants
       base.has_many :guests, through: :line_items

data/app/models/spree_cm_commissioner/redis_stock/cached_inventory_items_builder.rb

@@ -49,13 +49,15 @@ module SpreeCmCommissioner
           quantity_locked_on_hold: cache_inventory(locked_hold_keys[index], item, item.quantity_locked_on_hold, locked_hold[index]),
           max_capacity: item.max_capacity,
           inventory_item_id: item.id,
-          variant_id: item.variant_id
+          variant_id: item.variant_id,
+          closed: item.closed
         )
       end
 
       def cache_inventory(key, inventory_item, db_value, count_in_redis)
+        # Past dates are warmed too: InventoryItem#adjust_quantity! relies on this to seed the key before
+        # applying its delta, and an admin can still edit a past date's stock.
         return count_in_redis.to_i if count_in_redis.present?
-        return db_value unless inventory_item.active?
 
         # Use atomic SET NX to prevent race condition where multiple concurrent reads
         # initialize cache with stale values. Only the first thread wins.