spree_cm_commissioner 2.13.4 → 2.13.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 565fc705e24c32c2f3bd35aad88607d80d7f26b1bab3ff62dc64e2890202ed9a
-  data.tar.gz: b6647ca2838265f710f999389157765f24ba1baf92369521aab95a711779a0d9
+  metadata.gz: c83a53b69842100120ae6f6edea538c4a7335fc9859e52765f4be45ad2506b0c
+  data.tar.gz: 61cd2bea3a4a011a385ad636c6f3330bc44e04085eb39ea22c64c96f86c59978
 SHA512:
-  metadata.gz: 36a8d1f75f387fb33ab1d394ee91e61ce6c1179bbf2323352f1d56e3bbb303942d57af72933910e8017f184dcf0a24174a12f70ec4a69e42309cbec47fe9cdd7
-  data.tar.gz: d7dc21e3383b9784c9b0cef12c354f4a3d4d3535fe122b666b8abdd3b4e4fea4660f321ada830e83fdb409ebd8d2d91ed9fa6295b1801371d803475334431860
+  metadata.gz: 18012dec394174123a5fefcb459c369aab56bf075cabb068e695ab42eac92c1f487468047d6201bee6dc2f1f8730147260ec7d4b4dbfa1b4c0f5c98c31720508
+  data.tar.gz: 5dae3a462226fe008f4c17d43231d315d45e24a415fd07fe8c564f61694821ba70e037b311f8f653766df763a009e00b2ccf0d8f7bbbaf712e858a50b0cbdf43

data/.env.example

@@ -86,3 +86,8 @@ PAYMENT_INCOMPLETE_NOTIFICATION_DELAY_IN_MINUTES=5  # Delay before notifying a c
 
 # See: app/jobs/spree_cm_commissioner/telegram_alerts/order_integrity_check_job.rb
 ORDER_INTEGRITY_TELEGRAM_ALERT_ENABLED="no"  # Set to yes to enable the order integrity Telegram alert job (off by default to avoid flooding Telegram rate limits during traffic spikes)
+
+# See: app/models/concerns/spree_cm_commissioner/product_type.rb
+PRE_INVENTORY_DAYS_TRANSIT=180  # How many days ahead inventory items are pre-generated for transit variants
+PRE_INVENTORY_DAYS_ACCOMMODATION=365  # How many days ahead inventory items are pre-generated for accommodation variants
+PRE_INVENTORY_DAYS_SERVICE=180  # How many days ahead inventory items are pre-generated for service variants

data/Gemfile.lock

@@ -34,7 +34,7 @@ GIT
 PATH
   remote: .
   specs:
-    spree_cm_commissioner (2.13.4)
+    spree_cm_commissioner (2.13.7)
       activerecord-multi-tenant
       activerecord_json_validator (~> 2.1, >= 2.1.3)
       aws-sdk-cloudfront

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

@@ -1,6 +1,10 @@
 module Spree
   module Admin
     module BaseControllerDecorator
+      def self.prepended(base)
+        base.before_action :set_prepaid_current_actor
+      end
+
       # even db in read only mode, authorizor still need to run Warden callbacks which will write to db
       # this include update tracked fields such as sign_in_count, last_sign_in_at, etc.
       def authorize!(*args)
@@ -40,6 +44,16 @@ module Spree
 
         redirect_back fallback_location: admin_root_path
       end
+
+      private
+
+      # See SpreeCmCommissioner::Current#actor -- lets StoreCreditEventDecorator's after_create
+      # mirror attribute an admin-triggered authorize/capture/void/credit event (refunds, voids)
+      # to whoever is signed in, without threading current_user through Spree core's own
+      # Payment/Refund/StoreCredit call chain.
+      def set_prepaid_current_actor
+        SpreeCmCommissioner::Current.actor = try_spree_current_user
+      end
     end
   end
 end

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

@@ -2,7 +2,22 @@ module Spree
   module Admin
     class CustomerNotificationsController < Spree::Admin::ResourceController
       def index
-        @notifications = SpreeCmCommissioner::CustomerNotification.all
+        @search = model_class.ransack(params[:q])
+        @search.sorts = 'created_at desc' if @search.sorts.empty?
+        @notifications = @search.result.page(params[:page]).per(params[:per_page] || 25)
+      end
+
+      # POST /admin/customer_notifications/:id/clone
+      def clone
+        result = SpreeCmCommissioner::CustomerNotifications::Clone.call(customer_notification: @object)
+
+        if result.success?
+          flash[:success] = Spree.t(:customer_notification_cloned)
+          redirect_to edit_admin_customer_notification_url(result.value)
+        else
+          flash[:error] = Spree.t(:customer_notification_not_cloned, error: result.error.to_s)
+          redirect_to admin_customer_notifications_url
+        end
       end
 
       def model_class

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

@@ -59,6 +59,17 @@ module Spree
         redirect_back fallback_location: admin_product_stock_managements_path(@product)
       end
 
+      # PATCH /products/:slug/inventory_items/bulk_update_closed
+      #
+      # Ids travel in the form body, not the query string: a range across a year can be hundreds of ids.
+      def bulk_update_closed
+        closed = ActiveModel::Type::Boolean.new.cast(params[:closed])
+        count = @product.inventory_items.where(id: params[:inventory_item_ids]).update_all(closed: closed, updated_at: Time.current) # rubocop:disable Rails/SkipsModelValidations
+
+        flash[:success] = "#{closed ? 'Closed' : 'Reopened'} #{count} inventory items for sale"
+        redirect_back fallback_location: admin_product_stock_managements_path(@product)
+      end
+
       # PATCH /products/:slug/inventory_items/bulk_reset?inventory_item_ids=1,2,3
       def bulk_reset
         inventory_item_ids = params[:inventory_item_ids]

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

@@ -0,0 +1,76 @@
+module Spree
+  module Admin
+    # Same CRUD as ServiceFeeRulesController (scope picker, tenant dropdown, calculator partial),
+    # plus the payment method a rule applies to.
+    class PaymentFeeRulesController < Spree::Admin::ResourceController
+      helper SpreeCmCommissioner::Admin::FeeRulesHelper
+      helper_method :selected_tenant
+
+      before_action :load_data
+
+      def index
+        @search = model_class.ransack(params[:q])
+        @status = %w[active inactive].include?(params[:status]) ? params[:status] : 'all'
+
+        scope = @search.result.includes(:payment_method, :ruleable, :calculator, :tenant)
+        scope = scope.where(active: true) if @status == 'active'
+        scope = scope.where(active: false) if @status == 'inactive'
+        # Same tenant semantics as ServiceFeeRulesController#index.
+        scope = scope.where(tenant_id: selected_tenant&.id)
+
+        @payment_fee_rules = scope.order(ruleable_type: :asc, ruleable_id: :asc, payment_method_id: :asc, currency: :asc)
+                                  .page(params[:page])
+                                  .per(25)
+      end
+
+      # See ServiceFeeRulesController#build_resource: tenant_id comes from the URL only.
+      def build_resource
+        model_class.new(tenant_id: params[:tenant_id].presence)
+      end
+
+      private
+
+      def load_data
+        @calculators = model_class.available_calculator_types.sort_by(&:name)
+        @tenants ||= SpreeCmCommissioner::Tenant.order(:name)
+        @payment_methods = Spree::PaymentMethod.includes(:vendor).order(:name)
+        @currencies = (current_store.supported_currencies_list.map(&:iso_code) | [@object&.currency]).compact.sort
+      end
+
+      def selected_tenant
+        return @selected_tenant if defined?(@selected_tenant)
+
+        @selected_tenant = params[:tenant_id].presence && SpreeCmCommissioner::Tenant.find_by(id: params[:tenant_id])
+      end
+
+      def model_class
+        SpreeCmCommissioner::PaymentFeeRule
+      end
+
+      def object_name
+        'spree_cm_commissioner_payment_fee_rule'
+      end
+
+      def collection_url
+        admin_payment_fee_rules_url
+      end
+
+      def location_after_save
+        edit_admin_payment_fee_rule_path(@object)
+      end
+
+      # tenant_id is deliberately excluded -- see build_resource.
+      def permitted_resource_params
+        params.require(:spree_cm_commissioner_payment_fee_rule).permit(
+          :payment_method_id,
+          :ruleable_type,
+          :ruleable_id,
+          :active,
+          :currency,
+          :calculator_type,
+          calculator_attributes: %i[id preferred_percent preferred_flat_amount]
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+module Spree
+  module Admin
+    # Two read-only views over the prepaid ledger:
+    # - #index: platform-wide filterable browse (GET /admin/store_credit/transactions).
+    # - #show: a single ledger row's full detail (GET /admin/store_credit/transactions/:id),
+    #   reached from both #index's row links and the per-user store_credits Transactions tab.
+    #   Not nested under a user/store_credit -- PrepaidTransaction has a global id, and one
+    #   detail page reached from two different listings is simpler than two near-identical ones.
+    #   Currency, balance, admin, and reason/freeze metadata live here rather than cluttering
+    #   either listing table.
+    class PrepaidTransactionsController < Spree::Admin::BaseController
+      TRANSACTIONS_PER_PAGE = 25
+
+      before_action :load_transaction, only: :show
+
+      # GET /admin/store_credit/transactions -- the admin/store_credit dashboard's own
+      # platform-wide ledger browse (see Spree::Admin::StoreCreditAdminController's other tabs and
+      # store_credit_admin/_tabs.html.erb), but its own route/controller rather than a #show?
+      # tab=transactions query param, so filters/pagination live in a real URL.
+      def index
+        @current_tab = 'transactions'
+        @tenants = SpreeCmCommissioner::Tenant.order(:name)
+        @current_tenant_id = params[:tenant_id].presence&.to_i
+        @store = Spree::Store.default
+        build_transactions_search
+      end
+
+      def show; end
+
+      private
+
+      def load_transaction
+        @transaction = SpreeCmCommissioner::PrepaidTransaction.find(params[:id])
+        @user = @transaction.user
+        @store_credit = @transaction.store_credit
+        @reversed = SpreeCmCommissioner::PrepaidTransaction
+                    .exists?(user: @user, transaction_type: 'reverse_top_up', idempotency_key: "admin_reverse:#{@transaction.id}")
+        @return_to = safe_return_to
+      end
+
+      # So the back link on the detail page returns to the exact filtered/paginated Transactions
+      # tab state the admin came from, not a bare reset to page 1 -- only same-admin-namespace
+      # paths are honored, since this is attacker-controllable input (an admin could be tricked
+      # into following a crafted link) and open-redirecting out of /admin would be a phishing vector.
+      def safe_return_to
+        candidate = params[:return_to]
+        candidate if candidate.present? && candidate.start_with?('/admin/')
+      end
+
+      # Individual ledger row search/browse -- scoped to whichever tenant the dashboard's own
+      # tenant selector has picked (tenant_id: nil => platform-issued, same convention as
+      # StoreCreditOverviewQuery), further filtered via Ransack (q[user_email_cont],
+      # q[currency_eq], q[transaction_type_eq], q[created_at_gteq]/[created_at_lteq], ...).
+      def build_transactions_search
+        params[:q] = {} if params[:q].blank?
+        @transactions_search = SpreeCmCommissioner::PrepaidTransaction.where(tenant_id: @current_tenant_id).ransack(params[:q])
+        @transactions = @transactions_search.result
+                                            .includes(:user, :order, :tenant, :admin, :store_credit)
+                                            .order(created_at: :desc)
+                                            .page(params[:page])
+                                            .per(TRANSACTIONS_PER_PAGE)
+      end
+
+      def model_class
+        SpreeCmCommissioner::PrepaidTransaction
+      end
+    end
+  end
+end

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

@@ -14,6 +14,7 @@ module Spree
       # partial reads these ivars — without this a rejected save is a 500 instead of a form.
       before_action :load_stock_rows, only: %i[edit update]
       before_action :load_assignable_roles, only: %i[new create edit update]
+      before_action :load_offline_product_ids, only: %i[new create edit update]
 
       # GET /admin/private_sales
       def index
@@ -45,6 +46,11 @@ module Spree
         @assignable_roles = Spree::Role.non_vendor.order(:name)
       end
 
+      # The product search only returns `name`, so the form labels offline products from this list.
+      def load_offline_product_ids
+        @offline_product_ids = Spree::Product.where(offline: true).pluck(:id)
+      end
+
       def location_after_save
         edit_admin_private_sale_path(@private_sale)
       end

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

@@ -42,7 +42,8 @@ module Spree
 
       def commission_for(product)
         commission_rate = product.commission_rate || product.vendor&.commission_rate || 0
-        product.price * commission_rate / 100
+        # A product can have no price in the store currency yet (e.g. a freshly created ticket).
+        (product.price || 0) * commission_rate / 100
       end
 
       # override

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

@@ -0,0 +1,148 @@
+module Spree
+  module Admin
+    # Platform-admin management of reschedule policies, built like the Payment
+    # Methods page: a scoped tab bar (Store / Vendors / Tenants) over the shared
+    # ReschedulePolicy table.
+    #
+    # - Store tab (default): platform policies (vendor_id nil). Full CRUD.
+    # - Vendors tab: every vendor policy, read-only.
+    # - Tenants tab: vendor policies whose vendor belongs to a tenant, read-only.
+    #
+    # Create/Update delegate to the existing ReschedulePolicies services (with
+    # vendor: nil), which own calculator building, typed rules, and the
+    # one-default-per-scope rule.
+    class ReschedulePoliciesController < BaseController
+      # Only these tabs switch the page into read-only vendor/tenant mode; any
+      # other value falls back to the store tab, in the controller and the view
+      # alike (see `current_tab`).
+      TABS = %w[vendors tenants].freeze
+
+      before_action :load_policy, only: %i[edit update destroy set_default]
+
+      helper_method :current_tab
+
+      def index
+        authorize! :manage, SpreeCmCommissioner::ReschedulePolicy
+
+        @search = collection.ransack(params[:q])
+        @reschedule_policies = @search.result
+                                      .order(default: :desc, name: :asc)
+                                      .page(params[:page])
+                                      .per(params[:per_page] || 20)
+      end
+
+      def new
+        authorize! :manage, SpreeCmCommissioner::ReschedulePolicy
+        @reschedule_policy = SpreeCmCommissioner::ReschedulePolicy.new(status: :active)
+        # Seed a calculator so the fee fields render; the form/services can swap it.
+        @reschedule_policy.calculator_type = 'Spree::Calculator::FlatRate'
+      end
+
+      def create
+        authorize! :manage, SpreeCmCommissioner::ReschedulePolicy
+
+        result = SpreeCmCommissioner::ReschedulePolicies::Create.call(vendor: nil, options: policy_params)
+        if result.success?
+          flash[:success] = Spree.t(:successfully_created, resource: reschedule_policy_name)
+          redirect_to admin_reschedule_policies_path
+        else
+          @reschedule_policy = result.value || SpreeCmCommissioner::ReschedulePolicy.new
+          flash.now[:error] = result.error&.value
+          render :new, status: :unprocessable_entity
+        end
+      end
+
+      def update
+        result = SpreeCmCommissioner::ReschedulePolicies::Update.call(policy: @reschedule_policy, options: policy_params)
+        if result.success?
+          flash[:success] = Spree.t(:successfully_updated, resource: reschedule_policy_name)
+          redirect_to admin_reschedule_policies_path
+        else
+          flash.now[:error] = result.error&.value
+          render :edit, status: :unprocessable_entity
+        end
+      end
+
+      def destroy
+        if @reschedule_policy.active?
+          # The reschedule flow resolves the store policy from the *active*
+          # store policies, so deleting this one would reject every reschedule.
+          flash[:error] = Spree.t('admin.reschedule_policies.cannot_delete_active')
+        elsif @reschedule_policy.destroy
+          flash[:success] = Spree.t(:successfully_removed, resource: reschedule_policy_name)
+        else
+          flash[:error] = @reschedule_policy.errors.full_messages.to_sentence
+        end
+
+        redirect_to admin_reschedule_policies_path
+      end
+
+      # Promote this store policy to the active default; the Update service
+      # demotes the current default in the same scope first.
+      def set_default
+        result = SpreeCmCommissioner::ReschedulePolicies::Update.call(
+          policy: @reschedule_policy, options: { default: true, status: :active }
+        )
+        flash[:success] = Spree.t(:successfully_updated, resource: reschedule_policy_name) if result.success?
+        flash[:error] = result.error&.value if result.failure?
+        redirect_to admin_reschedule_policies_path
+      end
+
+      private
+
+      # nil for the store tab (including unknown/blank `tab` values), otherwise
+      # the recognised tab name.
+      def current_tab
+        params[:tab] if TABS.include?(params[:tab])
+      end
+
+      # All statuses are shown (draft/inactive included) so the admin can manage
+      # them, so the raw vendor_id/tenant_id filters are used, not the
+      # active-only `store_policies` / `vendor_policies` scopes.
+      def collection
+        base = SpreeCmCommissioner::ReschedulePolicy
+        case current_tab
+        when 'vendors'
+          base.where.not(vendor_id: nil).includes(:vendor)
+        when 'tenants'
+          base.where.not(vendor_id: nil).where.not(tenant_id: nil).includes(vendor: :tenant)
+        else
+          base.where(vendor_id: nil)
+        end
+      end
+
+      def load_policy
+        authorize! :manage, SpreeCmCommissioner::ReschedulePolicy
+        # Edits apply to store policies only; vendor/tenant policies are read-only here.
+        @reschedule_policy = SpreeCmCommissioner::ReschedulePolicy.where(vendor_id: nil).find(params[:id])
+      end
+
+      # Store policies only carry a fee calculator; the typed reschedule rules
+      # (cutoff, max-per-booking, vendor approval, ...) belong to vendor policies
+      # and are managed elsewhere, so they are not collected here.
+      def policy_params
+        params.require(:spree_cm_commissioner_reschedule_policy).permit(
+          :name,
+          :description,
+          :status,
+          :default,
+          :calculator_type,
+          calculator_attributes: calculator_attribute_keys
+        )
+      end
+
+      # Only the preferences of the selected (whitelisted) calculator subclass
+      # are permitted, so preferences never land on the wrong calculator type.
+      def calculator_attribute_keys
+        type = params.dig(:spree_cm_commissioner_reschedule_policy, :calculator_type)
+        return [] unless %w[Spree::Calculator::FlatRate Spree::Calculator::PercentOnLineItem].include?(type)
+
+        type.constantize.new.defined_preferences.map { |preference| "preferred_#{preference}" }
+      end
+
+      def reschedule_policy_name
+        SpreeCmCommissioner::ReschedulePolicy.model_name.human
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+module Spree
+  module Admin
+    class RescheduleRequestsController < Spree::Admin::ResourceController
+      helper Spree::Admin::RescheduleRequestsHelper
+
+      def index
+        @search = model_class.includes(:order, :user, :vendor, :vendor_policy).ransack(params[:q])
+        @reschedule_requests = @search.result
+                                      .order(created_at: :desc)
+                                      .page(params[:page])
+                                      .per(params[:per_page] || Spree::Backend::Config[:admin_orders_per_page])
+      end
+
+      def show
+        @reschedule_request = load_request
+      end
+
+      def state_changes
+        @reschedule_request = model_class.find(params[:id])
+        @state_changes = @reschedule_request.state_changes.includes(:user).order(created_at: :desc)
+      end
+
+      def approve
+        run_service(
+          SpreeCmCommissioner::RescheduleRequests::Vendors::Approve,
+          approved_by: try_spree_current_user,
+          success_key: 'approved'
+        )
+      end
+
+      def reject
+        run_service(
+          SpreeCmCommissioner::RescheduleRequests::Vendors::Reject,
+          rejected_by: try_spree_current_user,
+          success_key: 'rejected'
+        )
+      end
+
+      def cancel
+        run_service(
+          SpreeCmCommissioner::RescheduleRequests::Cancel,
+          cancelled_by: try_spree_current_user,
+          reason: params[:cancellation_reason].presence,
+          success_key: 'cancelled'
+        )
+      end
+
+      private
+
+      # Each service takes the acting admin so audit rows record who acted
+      # rather than the request's customer.
+      def run_service(service, success_key:, **)
+        @reschedule_request = model_class.find(params[:id])
+
+        result = service.call(reschedule_request: @reschedule_request, **)
+        if result.success?
+          flash[:success] = t("spree.admin.reschedule_requests.#{success_key}")
+        else
+          flash[:error] = result.error&.value
+        end
+
+        redirect_to admin_reschedule_request_path(@reschedule_request)
+      end
+
+      def load_request
+        model_class.includes(
+          :order, :user, :vendor, :tenant, :vendor_policy, :store_policy,
+          previous_request_snapshots: %i[variant line_item],
+          new_request_snapshots: %i[variant line_item]
+        ).find(params[:id])
+      end
+
+      def model_class
+        SpreeCmCommissioner::RescheduleRequest
+      end
+
+      def object_name
+        'spree_cm_commissioner_reschedule_request'
+      end
+    end
+  end
+end

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

@@ -1,6 +1,7 @@
 module Spree
   module Admin
     class ServiceFeeRulesController < Spree::Admin::ResourceController
+      helper SpreeCmCommissioner::Admin::FeeRulesHelper
       helper_method :selected_tenant
 
       before_action :load_data

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

@@ -0,0 +1,122 @@
+module Spree
+  module Admin
+    class StoreCreditAdminController < Spree::Admin::BaseController
+      TABS = %w[overview frozen_store_credits settings].freeze
+
+      def show
+        @current_tab = TABS.include?(params[:tab]) ? params[:tab] : 'overview'
+        @tenants = SpreeCmCommissioner::Tenant.order(:name)
+        @current_tenant_id = params[:tenant_id].presence&.to_i
+        store_credit_overview = SpreeCmCommissioner::StoreCreditOverviewQuery.new(issuer_tenant_id: @current_tenant_id)
+        @summary = store_credit_overview.call
+        @frozen_store_credits = store_credit_overview.frozen_store_credits
+        @config = SpreeCmCommissioner::Configuration.new
+        @store = Spree::Store.default
+      end
+
+      # Covers every prepaid_* Configuration preference editable from the Settings tab -- the
+      # currency rate table (keyed by Spree::Store.default#supported_currency_codes -- edit the
+      # currency list itself on the store's own admin settings page, not here) and the
+      # fraud/velocity limits (Configuration's comment on prepaid_max_topups_per_hour and
+      # friends). One form/action since nothing here is ever meaningfully saved independently.
+      SETTINGS_KEYS = %i[
+        prepaid_currency_rates prepaid_topup_min_amount prepaid_topup_max_amount
+        prepaid_max_topups_per_hour prepaid_max_topup_count_daily prepaid_daily_topup_limit
+        prepaid_max_balance
+      ].freeze
+
+      def update_settings
+        config = SpreeCmCommissioner::Configuration.new
+        new_values = {
+          prepaid_currency_rates: permitted_currency_rates(config),
+          prepaid_topup_min_amount: params[:prepaid_topup_min_amount].to_d,
+          prepaid_topup_max_amount: params[:prepaid_topup_max_amount].to_d,
+          prepaid_max_topups_per_hour: params[:prepaid_max_topups_per_hour].to_i,
+          prepaid_max_topup_count_daily: params[:prepaid_max_topup_count_daily].to_i,
+          prepaid_daily_topup_limit: params[:prepaid_daily_topup_limit].to_d,
+          prepaid_max_balance: params[:prepaid_max_balance].to_d
+        }
+
+        error = invalid_settings_reason(new_values)
+        if error
+          flash[:error] = error
+          return redirect_to admin_store_credit_path(tab: 'settings')
+        end
+
+        old_values = SETTINGS_KEYS.index_with { |key| config[key] }
+        SETTINGS_KEYS.each { |key| config[key] = new_values[key] }
+
+        log_settings_change(old_values, new_values)
+
+        flash[:success] = I18n.t('spree_cm_commissioner.store_credit_admin.settings_updated')
+        redirect_to admin_store_credit_path(tab: 'settings')
+      end
+
+      def run_reconciliation
+        report = SpreeCmCommissioner::PrepaidReconciliationService.run_daily
+
+        if report.drift_count.zero?
+          flash[:success] = I18n.t('spree_cm_commissioner.store_credit_admin.reconciliation_success', checked_count: report.checked_count)
+        else
+          flash[:error] = I18n.t(
+            'spree_cm_commissioner.store_credit_admin.reconciliation_drift',
+            checked_count: report.checked_count, drift_count: report.drift_count
+          )
+        end
+
+        redirect_back fallback_location: admin_store_credit_path
+      end
+
+      private
+
+      # Keyed by the store's current supported-currencies list, so a dropped currency's rate
+      # doesn't linger and a new one gets an explicit (fallback 1.0) entry.
+      def permitted_currency_rates(config)
+        currency_codes = Spree::Store.default.supported_currency_codes
+        submitted = params[:prepaid_currency_rates]
+        submitted = submitted.is_a?(ActionController::Parameters) ? submitted.permit(*currency_codes) : {}
+
+        currency_codes.index_with do |currency|
+          submitted[currency].presence&.to_f || config.prepaid_currency_rates[currency] || 1.0
+        end
+      end
+
+      # These preferences are the only fraud/velocity ceiling enforced on store credit money-in
+      # (Prepaid::CheckTopUpLimits, Prepaid::TopUp) -- a negative value would be silently treated
+      # as "no limit" by comparisons like `amount > limit`, and a non-positive currency rate would
+      # corrupt every cross-currency conversion built on it.
+      def invalid_settings_reason(values)
+        %i[
+          prepaid_topup_min_amount prepaid_topup_max_amount prepaid_max_topups_per_hour
+          prepaid_max_topup_count_daily prepaid_daily_topup_limit prepaid_max_balance
+        ].each do |key|
+          return "#{key} can't be negative" if values[key].negative?
+        end
+
+        if values[:prepaid_topup_min_amount] > values[:prepaid_topup_max_amount] && values[:prepaid_topup_max_amount].positive?
+          return 'prepaid_topup_min_amount cannot exceed prepaid_topup_max_amount'
+        end
+
+        values[:prepaid_currency_rates].each do |currency, rate|
+          return "currency rate for #{currency} must be positive" unless rate.positive?
+        end
+
+        nil
+      end
+
+      # No dedicated audit-log model for Configuration preferences (they're key/value, not an
+      # ActiveRecord row PaperTrail can version) -- structured log line is the same pattern
+      # #run_reconciliation already uses ("-- see logs") for admin-triggered store credit actions.
+      def log_settings_change(old_values, new_values)
+        changed = SETTINGS_KEYS.each_with_object({}) do |key, diff|
+          diff[key] = { from: old_values[key], to: new_values[key] } if old_values[key] != new_values[key]
+        end
+        return if changed.empty?
+
+        Rails.logger.info(
+          "[store_credit_settings_change] admin_id=#{try_spree_current_user&.id} changes=#{changed}"
+        )
+      end
+    end
+  end
+end

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

@@ -1,6 +1,8 @@
 module Spree
   module Admin
     class TicketTransferRulesController < Spree::Admin::ResourceController
+      before_action :load_offline_product_ids, only: %i[new edit create update]
+
       def index
         @search = model_class.ransack(params[:q])
         @ticket_transfer_rules = @search.result
@@ -11,6 +13,11 @@ module Spree
 
       private
 
+      # The scope-target search only returns `name`, so the form labels offline products from this list.
+      def load_offline_product_ids
+        @offline_product_ids = Spree::Product.where(offline: true).pluck(:id)
+      end
+
       def model_class
         SpreeCmCommissioner::TicketTransferRule
       end