spree_cm_commissioner 2.13.5 → 2.14.0

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

@@ -0,0 +1,142 @@
+module Spree
+  module Admin
+    # Stock, prices and sale status of a product's variants and their rate plans, per date.
+    # StockManagementsController keeps per-variant setup: stock locations, track inventory, purchases, resets.
+    class RatesAvailabilitiesController < Spree::Admin::BaseController
+      include RatesAvailabilityCells
+
+      MIN_DAYS_AHEAD = 14
+      MAX_BLOCK_DAYS = 62
+      VARIANTS_PER_PAGE = 25
+      BOOKINGS_PER_PAGE = 25
+
+      before_action :load_product
+      before_action :load_grid, only: %i[index dates]
+
+      helper SpreeCmCommissioner::Admin::RatesAvailabilitiesHelper
+      helper_method :filter_params
+
+      # GET /products/:product_id/rates_availabilities?from=&currency=&option_value_ids[]=&archived=&page=
+      def index
+        @option_types = Spree::Variants::OptionTypesFinder.new(variant_ids: @product.variants.ids).execute.select(&:variant?)
+        @currencies = supported_currencies_for_all_stores.map(&:iso_code)
+        # A channel manager sets these variants' stock, prices and closings, so BulkUpdate skips them; the page says why.
+        @managing_integration = @product.vendor&.integration if @grid.variants.any?(&:inventory_external_wins?)
+      end
+
+      # GET /products/:product_id/rates_availabilities/dates?from=&to=&<index filters>
+      #
+      # The page adds this block next to the dates it already shows, so a range across months doesn't need a reload.
+      # It asks for whole months, so a month never spans two blocks.
+      def dates
+        render partial: 'block', locals: { grid: @grid }
+      end
+
+      # PATCH /products/:product_id/rates_availabilities/bulk_update, JSON: { bulk_action:, cells: [...], values: {...} }
+      #
+      # Answers with the counts, and the page then reloads its loaded dates.
+      def bulk_update
+        result = SpreeCmCommissioner::RatesAvailabilities::BulkUpdate.call(
+          product: @product,
+          store: current_store,
+          action: params[:bulk_action].to_s,
+          cells: selected_cells,
+          values: params.fetch(:values, {}).permit(:amount, :compare_at_amount, :quantity, :currency),
+          user: try_spree_current_user
+        )
+
+        if result.success?
+          render json: result.value
+        else
+          render json: { error: result.error.to_s }, status: :unprocessable_entity
+        end
+      end
+
+      # POST /products/:product_id/rates_availabilities/bookings, JSON: { cells: [...], filter:, q:, page: }
+      #
+      # The bookings modal for the selected cells. POST, as cells travel in the body.
+      def bookings
+        finder = SpreeCmCommissioner::RatesAvailabilities::FindBookings.new(
+          product: @product,
+          cells: selected_cells,
+          filter: params[:filter].to_s,
+          query: params[:q]
+        )
+
+        line_items = finder.execute.page(params[:page]).per(BOOKINGS_PER_PAGE)
+        render partial: 'bookings', formats: [:html], locals: {
+          finder: finder,
+          line_items: line_items,
+          cells: selected_cells,
+          held_order_ids: finder.held_order_ids_among(line_items)
+        }
+      end
+
+      private
+
+      def filter_params
+        params.permit(:currency, :archived, option_value_ids: []).to_h
+      end
+
+      def load_product
+        @product = Spree::Product.find_by!(slug: params[:product_id])
+      end
+
+      def load_grid
+        @include_archived = params[:archived] == '1'
+        @variants = variants.page(params[:page]).per(VARIANTS_PER_PAGE)
+        @currency = (params[:currency].presence || current_currency).upcase
+        @from = parse_date(params[:from]) || Time.zone.today
+
+        dates = @product.permanent_stock? ? date_window.to_a : []
+
+        @grid = SpreeCmCommissioner::RatesAvailabilityGrid.new(
+          variants: @variants.to_a,
+          dates: dates,
+          currency: @currency,
+          include_archived: @include_archived
+        )
+      end
+
+      def variants
+        rate_plans = @include_archived ? :rate_plans : :active_rate_plans
+        scope = @product.variants.exists? ? @product.variants : Spree::Variant.where(id: @product.master.id)
+        scope = scope.where(id: matching_variant_ids) if option_value_ids.present?
+        scope.includes(:stock_items, { rate_plans => { option_values: :option_type } }, { vendor: :integration }, option_values: :option_type)
+             .order(:position, :id)
+      end
+
+      def option_value_ids
+        @option_value_ids ||= Array(params[:option_value_ids]).compact_blank.map(&:to_i)
+      end
+
+      def matching_variant_ids
+        SpreeCmCommissioner::Variants::FindByOptionValueIds.new(product: @product, option_value_ids: option_value_ids).execute.ids
+      end
+
+      # The first window is `from`'s month, plus the next one when fewer than MIN_DAYS_AHEAD days are left, so a
+      # late `from` still shows weeks ahead. Whole months, so the blocks added next to it are whole months too.
+      # Kept to about a month: every day is a column on every row, and a dated product can have many variants.
+      # The page scrolls to `from`.
+      def date_window
+        to = parse_date(params[:to])
+        return @from..[to, @from + (MAX_BLOCK_DAYS - 1)].min if to
+
+        last = @from.end_of_month
+        last = @from.next_month.end_of_month if (last - @from).to_i + 1 < MIN_DAYS_AHEAD
+        @from.beginning_of_month..last
+      end
+
+      def parse_date(value)
+        Date.parse(value.to_s) if value.present?
+      rescue Date::Error
+        nil
+      end
+
+      # Same permission as the stock calendar this replaces.
+      def model_class
+        Spree::StockItem
+      end
+    end
+  end
+end

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/stock_managements_controller.rb

@@ -5,7 +5,7 @@ module Spree
 
       before_action :load_parent
 
-      helper_method :inventory_item_message, :inventory_item_hold_message
+      helper SpreeCmCommissioner::Admin::InventoryItemsHelper
 
       def load_parent
         @product = Spree::Product.find_by(slug: params[:product_id])
@@ -40,58 +40,6 @@ module Spree
         redirect_back fallback_location: admin_product_stock_managements_path(@product)
       end
 
-      # GET /products/:slug/stock_managements/calendar?year=&selected_option_value_ids[]=
-      def calendar
-        @year = params[:year].present? ? params[:year].to_i : Time.zone.today.year
-
-        from_date = Date.new(@year, 1, 1).beginning_of_year
-        to_date = Date.new(@year, 1, 1).end_of_year
-
-        @variant_kind_option_types = Spree::Variants::OptionTypesFinder.new(variant_ids: @product.variants.ids)
-                                                                       .execute.select(&:variant?)
-        @selected_option_value_ids = Array(params[:selected_option_value_ids]).map(&:to_i)
-
-        inventory_items = @product.inventory_items.includes(:variant, :prices).where(
-          inventory_date: from_date..to_date
-        )
-
-        if @selected_option_value_ids.present?
-          variant_ids = SpreeCmCommissioner::Variants::FindByOptionValueIds.new(
-            product: @product, option_value_ids: @selected_option_value_ids
-          ).execute.ids
-          inventory_items = inventory_items.where(variant_id: variant_ids)
-          @matched_variants_count = variant_ids.size
-        else
-          @matched_variants_count = @product.variants.count
-        end
-
-        @inventory_items = inventory_items.to_a
-
-        @cached_inventory_items = ::SpreeCmCommissioner::RedisStock::CachedInventoryItemsBuilder.new(@inventory_items)
-                                                                                                .call
-                                                                                                .index_by(&:inventory_item_id)
-        @events = SpreeCmCommissioner::CalendarEvent.from_inventory_items(@inventory_items)
-      end
-
-      def inventory_item_message(inventory_item, cached_inventory_item)
-        synced = inventory_item.quantity_available == cached_inventory_item.quantity_available
-
-        if synced
-          "Synced: Quantity available matches in both DB and Redis (#{cached_inventory_item.quantity_available})."
-        else
-          "Out of sync: Redis shows #{cached_inventory_item.quantity_available} available, which doesn't match the database."
-        end
-      end
-
-      def inventory_item_hold_message(inventory_item, cached_inventory_item)
-        synced = inventory_item.quantity_on_hold == cached_inventory_item.quantity_on_hold
-        if synced
-          "Synced: Quantity on hold matches in both DB and Redis (#{cached_inventory_item.quantity_on_hold})."
-        else
-          "Out of sync: Redis shows #{cached_inventory_item.quantity_on_hold} on hold, which doesn't match the database."
-        end
-      end
-
       private
 
       def load_inventories

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