spree_cm_commissioner 2.5.13.pre.pre11 → 2.5.13.pre.patch1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0199f4ae031efcea098fb06b2e7e20a58a848b21ff29c1d5182fe85caa4e13f3'
-  data.tar.gz: f15098ef969208ca80524115e0d713a6edf5cc0364fff5c65f609ee652196ad0
+  metadata.gz: 2ca95409fb32a7b43530a6b61ffdc869564893d7c9a8abcf68e72f9db8c9362d
+  data.tar.gz: 93e7de99a30c3f58f899426132837c134ca9a6a725e799a90443b9699b91213f
 SHA512:
-  metadata.gz: 3a7379b89a5b6f40e796719d634587baf0b23947435797bce34f82ceb47abd0e3733dab7f2bee17e4041720201253fbaf677f5d9c3729081b02e61c34f8d8a18
-  data.tar.gz: 4064ac92ac295cfd51ce359faa41c6d7c6e6ab3fdfc3e48f151f8dcde6fa72652a6dc2014b7b9fc225fd8fc4b21c0ff38e4fd0faf5719c92f3bbea8b850a64fe
+  metadata.gz: efd4bc5698835f6eaebfa42e71e213c6cb9ace7d5a6eb5219b3143e49993ed8679145da7c0732ee16176b8428509973f6bd1ead97dcbf0ede168af042e67ae0c
+  data.tar.gz: 2ea123009aa6a3ecb2208117d35e27a8ece4010e78142b619f8c71323a6741b453bb37e8f2148f23fca7320d933923e81be037ed20baf616b43b294c7be52739

data/.env.example

@@ -40,3 +40,13 @@ CACHE_SEMI_STATIC_MAX_AGE=3600 # Semi-static content (menus, homepage background
 CACHE_MODERATE_MAX_AGE=1800 # Moderate freshness (products, events, vendors) - 30 minutes
 CACHE_REALTIME_MAX_AGE=300 # High freshness (trips, trip search) - 5 minutes
 CACHE_DEFAULT_MAX_AGE=300 # Default for unlisted controllers - 5 minutes
+
+# Batch size for processing maintenance tasks in app/jobs/spree_cm_commissioner/maintenance_tasks/orchestrate_job.rb
+MAINTENANCE_TASKS_BATCH_SIZE=100
+
+# Export related:
+OPERATOR_GUEST_JSON_GZIP_CACHE_HOURS=24
+EXPORT_PRESIGNED_URL_EXPIRATION_MINUTES=15
+
+# import order batch size
+IMPORT_ORDERS_BATCH_SIZE=50

data/Gemfile.lock

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

data/app/controllers/concerns/spree/admin/service_calendars_concern.rb

@@ -0,0 +1,93 @@
+module Spree
+  module Admin
+    module ServiceCalendarsConcern
+      extend ActiveSupport::Concern
+
+      included do
+        new_action.before :set_exception_rules
+
+        helper 'spree_cm_commissioner/admin/service_calendars'
+      end
+
+      def update_status
+        if @object.update(active: !@object.active)
+          flash[:success] = flash_message_for(@object, :successfully_updated)
+        else
+          flash[:error] = @object.errors.full_messages.to_sentence
+        end
+
+        redirect_to collection_url
+      rescue ActiveRecord::RecordInvalid => e
+        flash[:error] = e.message
+        redirect_to collection_url
+      end
+
+      protected
+
+      def model_class
+        SpreeCmCommissioner::ServiceCalendar
+      end
+
+      def object_name
+        'spree_cm_commissioner_service_calendars'
+      end
+
+      def permitted_resource_params
+        service_calendar_params = params.require(:spree_cm_commissioner_service_calendar)
+                                        .permit(:calendarable_id, :calendarable_type, :start_date, :end_date,
+                                                :monday, :tuesday, :wednesday, :thursday, :friday, :saturday, :sunday
+                                        )
+        service_calendar_params[:exception_rules] = build_exception_rules(params[:spree_cm_commissioner_service_calendar][:exception_rules])
+        service_calendar_params
+      end
+
+      private
+
+      def build_exception_rules(exception_rules)
+        exception_rules.values.reject! { |rule| rule['from'].blank? || rule['to'].blank? || rule['type'].blank? } || exception_rules.values
+      end
+
+      def collection
+        load_calendarable
+
+        @objects = model_class.where(
+          calendarable_type: calendarable_type,
+          calendarable_id: calendarable_id
+        ).order(id: :desc)
+      end
+
+      def set_exception_rules
+        @exception_rules = [{ from: DateTime.now, to: DateTime.now, type: 'exclusion', reason: nil }]
+      end
+
+      def build_resource
+        today = Time.zone.today
+        model_class.new(start_date: today, end_date: today.next_year(3),
+                        exception_rules: [{ from: nil, to: nil, type: 'inclusion' }]
+        )
+      end
+
+      def set_calendarable
+        @object.calendarable_type = calendarable_type
+        @object.calendarable_id   = calendarable_id
+      end
+
+      # To be implemented by including controllers
+      def load_calendarable
+        raise NotImplementedError, 'must implement load_calendarable'
+      end
+
+      def calendarable
+        raise NotImplementedError, 'must implement calendarable'
+      end
+
+      def calendarable_id
+        calendarable.id
+      end
+
+      def calendarable_type
+        calendarable.class.name
+      end
+    end
+  end
+end

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

@@ -4,11 +4,19 @@ module Spree
       before_action :load_taxon_and_products
 
       def recalculate_conversions
-        @taxon.products.each do |product|
-          SpreeCmCommissioner::ConversionPreCalculatorJob.perform_later(product_id: product.id)
+        if @taxon.parent.event?
+          SpreeCmCommissioner::MaintenanceTasks::Event.pending.find_or_create_by(
+            maintainable_type: 'Spree::Taxon',
+            maintainable_id: @taxon.parent.id
+          ) do |task|
+            task.manually_triggered = true
+          end.async_execute
+
+          flash[:success] = flash_message_for(@taxon, :successfully_updated)
+        else
+          flash[:error] = 'Conversion recalculation can only be performed for taxons under an event.' # rubocop:disable Rails/I18nLocaleTexts
         end
 
-        flash[:success] = flash_message_for(@taxon, :successfully_updated)
         redirect_to collection_url
       end
 

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

@@ -3,7 +3,9 @@ module Spree
     class ImportExistingOrdersController < BaseImportOrdersController
       # override
       def collection
-        @collection ||= model_class.existing_order.page(params[:page])
+        @collection ||= model_class.existing_order
+                                   .order(created_at: :desc)
+                                   .page(params[:page])
                                    .per(params[:per_page])
       end
 

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

@@ -3,7 +3,9 @@ module Spree
     class ImportNewOrdersController < BaseImportOrdersController
       # override
       def collection
-        @collection ||= model_class.new_order.page(params[:page])
+        @collection ||= model_class.new_order
+                                   .order(created_at: :desc)
+                                   .page(params[:page])
                                    .per(params[:per_page])
       end
 

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

@@ -42,8 +42,8 @@ module Spree
         inventory_items = @product.inventory_items.where(id: inventory_item_ids)
         target_quantity = params[:quantity].to_i
 
-        if target_quantity.zero?
-          flash[:error] = "Target quantity (#{target_quantity}) must be greater than zero"
+        if target_quantity.negative?
+          flash[:error] = "Target quantity (#{target_quantity}) must not be negative"
           return redirect_back(fallback_location: admin_product_stock_managements_path(@product))
         end
 
@@ -52,7 +52,7 @@ module Spree
           quantity_change = target_quantity - inventory_item.quantity_available
 
           # Use adjust_quantity! to update max_capacity, quantity_available, and sync to Redis
-          inventory_item.adjust_quantity!(quantity_change) if quantity_change != 0
+          inventory_item.adjust_quantity!(quantity_change)
         end
 
         flash[:success] = "Successfully updated stocks for #{inventory_items.count} items"

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

@@ -0,0 +1,39 @@
+module Spree
+  module Admin
+    class InventoryMonitoringsController < BaseController
+      def index
+        authorize! :manage, SpreeCmCommissioner::InventoryItem
+
+        @time_range = params[:time_range] || 7
+        @filter_type = params[:filter_type] || 'all'
+        @vendor_id = params[:vendor_id]
+
+        finder = SpreeCmCommissioner::InventoryItems::RecentlyChangedFinder.new(
+          time_range: @time_range.to_i.days.ago,
+          limit: 1000,
+          vendor_id: @vendor_id,
+          filter_type: @filter_type
+        )
+
+        @inventory_items = finder.execute
+        @total_count = @inventory_items.size
+        @out_of_sync_count = @inventory_items.count { |item| item[:out_of_sync] }
+      end
+
+      def reset
+        authorize! :manage, SpreeCmCommissioner::InventoryItem
+
+        inventory_item = SpreeCmCommissioner::InventoryItem.find(params[:id])
+        result = SpreeCmCommissioner::Stock::InventoryItemResetter.call(inventory_item: inventory_item)
+
+        if result.success?
+          flash[:success] = "Successfully reset inventory for #{inventory_item.variant.product.name}"
+        else
+          flash[:error] = "Failed to reset inventory: #{result.message}"
+        end
+
+        redirect_to action: :index, time_range: params[:time_range], filter_type: params[:filter_type]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+module Spree
+  module Admin
+    class ProductServiceCalendarsController < Spree::Admin::ResourceController
+      include Spree::Admin::ServiceCalendarsConcern
+
+      before_action :load_product
+      before_action :ensure_product_type_supports_calendar
+      before_action :ensure_product_has_no_calendar, only: %i[new create]
+
+      create.before :set_calendarable
+      update.before :set_calendarable
+
+      protected
+
+      def collection_url(options = {})
+        admin_product_product_service_calendars_url(options)
+      end
+
+      private
+
+      def load_product
+        @product ||= (Spree::Product.find_by(slug: params[:product_id]) || Spree::Product.find_by(id: params[:product_id]))
+      end
+
+      def ensure_product_type_supports_calendar
+        return if @product.permanent_stock?
+
+        flash[:error] = I18n.t('vendor.service_calendars.not_available_for_product_type')
+        redirect_to edit_admin_product_url(@product)
+      end
+
+      def ensure_product_has_no_calendar
+        return if @product.service_calendar.blank?
+
+        flash[:error] = I18n.t('vendor.service_calendars.already_has_calendar')
+        redirect_to admin_product_product_service_calendars_url(@product)
+      end
+
+      def load_calendarable
+        load_product
+      end
+
+      def calendarable
+        @product
+      end
+    end
+  end
+end

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

@@ -14,7 +14,11 @@ module Spree
       def index
         @variants = @product.variants.includes(:images, :default_price, stock_items: :stock_location, option_values: :option_type)
         @variants = [@product.master] if @variants.empty?
-        @stock_locations = (@variants.flat_map(&:stock_locations) + @product.vendor.stock_locations).uniq
+
+        vendor_stock_locations = @product.vendor&.stock_locations || []
+        variant_stock_locations = @variants.flat_map(&:stock_locations).uniq
+
+        @stock_locations = (variant_stock_locations + vendor_stock_locations).uniq
 
         load_inventories unless @product.permanent_stock?
       end

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

@@ -5,6 +5,12 @@ module Spree
         base.before_action :build_assets, only: %i[create update]
       end
 
+      # override
+      def new
+        @taxon.parent_id = params[:parent_id] if params[:parent_id].present?
+        super
+      end
+
       def remove_category_icon
         remove_asset(@taxon.category_icon)
       end

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

@@ -1,92 +1,31 @@
 module Spree
   module Admin
     class VendorServiceCalendarsController < Spree::Admin::ResourceController
-      before_action :load_vendor
-      new_action.before :set_exception_rules
-
-      create.before :set_vendor
-      update.before :set_vendor
-
-      helper 'spree_cm_commissioner/admin/service_calendars'
+      include Spree::Admin::ServiceCalendarsConcern
 
-      def update_status
-        if @object.update(active: !@object.active)
-          flash[:success] = flash_message_for(@object, :successfully_updated)
-        else
-          flash[:error] = @object.errors.full_messages.to_sentence
-        end
+      before_action :load_vendor
 
-        redirect_to admin_vendor_vendor_service_calendars_url
-      rescue ActiveRecord::RecordInvalid => e
-        flash[:error] = e.message
-        redirect_to admin_vendor_vendor_service_calendars_url
-      end
+      create.before :set_calendarable
+      update.before :set_calendarable
 
       protected
 
-      def model_class
-        SpreeCmCommissioner::ServiceCalendar
-      end
-
-      def object_name
-        'spree_cm_commissioner_service_calendars'
-      end
-
       def collection_url(options = {})
         admin_vendor_vendor_service_calendars_url(options)
       end
 
-      def permitted_resource_params
-        service_calendar_params = params.require(:spree_cm_commissioner_service_calendar)
-                                        .permit(:calendarable_id, :calendarable_type, :start_date, :end_date,
-                                                :monday, :tuesday, :wednesday, :thursday, :friday, :saturday, :sunday
-                                        )
-        service_calendar_params[:exception_rules] = build_exception_rules(params[:spree_cm_commissioner_service_calendar][:exception_rules])
-        service_calendar_params
-      end
-
       private
 
       def load_vendor
         @vendor ||= (Spree::Vendor.find_by(slug: params[:vendor_id]) || Spree::Vendor.find_by(id: params[:vendor_id]))
       end
 
-      def set_vendor
-        @object.calendarable_type = calendarable_type
-        @object.calendarable_id   = calendarable_id
-      end
-
-      def build_exception_rules(exception_rules)
-        exception_rules.values.reject! { |rule| rule['from'].blank? || rule['to'].blank? || rule['type'].blank? } || exception_rules.values
-      end
-
-      def collection
+      def load_calendarable
         load_vendor
-
-        @objects = model_class.where(
-          calendarable_type: calendarable_type,
-          calendarable_id: calendarable_id
-        ).order(id: :desc)
-      end
-
-      def set_exception_rules
-        @exception_rules = [{ from: DateTime.now, to: DateTime.now, type: 'exclusion', reason: nil }]
-      end
-
-      # it load before :load_vendor
-      def build_resource
-        today = Time.zone.today
-        model_class.new(start_date: today, end_date: today.next_year(3),
-                        exception_rules: [{ from: nil, to: nil, type: 'inclusion' }]
-        )
-      end
-
-      def calendarable_id
-        @vendor.id
       end
 
-      def calendarable_type
-        @vendor.class.name
+      def calendarable
+        @vendor
       end
     end
   end

data/app/controllers/spree/api/v2/operator/check_ins_controller.rb

@@ -5,10 +5,23 @@ module Spree
         class CheckInsController < ::Spree::Api::V2::ResourceController
           before_action :require_spree_current_user, only: %i[index create]
 
+          # Check-in history data requires fresh/recent data for operator dashboards
+          # Short cache duration ensures operators see near real-time check-in activity
+          CACHE_EXPIRES_IN = 1.minute
+
           def collection
-            @collection = SpreeCmCommissioner::CheckIn.where(checkinable: params[:taxon_id])
+            @collection ||= SpreeCmCommissioner::CheckIn
+                            .where(checkinable_type: 'Spree::Taxon', checkinable_id: params[:taxon_id])
+                            .page(params[:page])
+                            .per(params[:per_page])
+          end
 
-            @collection = @collection.page(params[:page]).per(params[:per_page])
+          # override
+          def collection_cache_opts
+            {
+              namespace: Spree::Api::Config[:api_v2_collection_cache_namespace],
+              expires_in: CACHE_EXPIRES_IN
+            }
           end
 
           def create

data/app/controllers/spree/api/v2/operator/guest_json_gzips_controller.rb

@@ -3,7 +3,10 @@ module Spree
     module V2
       module Operator
         class GuestJsonGzipsController < ::Spree::Api::V2::ResourceController
+          include ActiveStorage::SetCurrent
+
           before_action :require_spree_current_user
+          before_action :require_event_user
 
           # POST /api/v2/operator/guest_json_gzips
           # - taxon_id=1
@@ -29,6 +32,10 @@ module Spree
             end
           end
 
+          def require_event_user
+            raise CanCan::AccessDenied unless spree_current_user.events.exists?(id: params[:taxon_id])
+          end
+
           # override
           def scope
             SpreeCmCommissioner::Exports::OperatorGuestJsonGzip.where(

data/app/controllers/spree/api/v2/operator/recalculate_tickets_controller.rb

@@ -7,13 +7,9 @@ module Spree
           before_action :load_taxon, only: :create
 
           def create
-            classification_ids = Spree::Classification.joins(:taxon)
-                                                      .where(spree_taxons: { id: @taxons.pluck(:id) })
-                                                      .pluck(:id)
-
-            classification_ids.each do |classification_id|
-              SpreeCmCommissioner::ConversionPreCalculator.call(product_taxon: Spree::Classification.find(classification_id))
-            end
+            SpreeCmCommissioner::MaintenanceTasks::Event.pending.find_or_create_by(
+              maintainable: @taxon
+            ).async_execute
 
             render json: { message: 'Conversions recalculated successfully' }, status: :ok
           end
@@ -21,8 +17,7 @@ module Spree
           private
 
           def load_taxon
-            parent_taxon = Spree::Taxon.find(params[:taxon_id])
-            @taxons = parent_taxon.children
+            @taxon = Spree::Taxon.find(params[:taxon_id])
           end
         end
       end

data/app/controllers/spree_cm_commissioner/orders_controller.rb

@@ -3,14 +3,26 @@ module SpreeCmCommissioner
     layout 'spree_cm_commissioner/layouts/order_mailer'
     helper 'spree/mail'
 
-    def show
+    def show # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       @order = if params[:id].match?(/^R\d{9,}-([A-Za-z0-9_\-]+)$/)
                  Spree::Order.search_by_qr_data!(params[:id])
                else
-                 SpreeCmCommissioner::Orders::JwtToken::Verify.call(token: params[:t]).value[:order]
+                 result = SpreeCmCommissioner::Orders::JwtToken::Verify.call(token: params[:t])
+                 unless result.success?
+                   @title = I18n.t('views.sign_in.errors.request_invalid')
+                   @message = I18n.t('views.sign_in.errors.request_invalid_message')
+
+                   return render(
+                     template: 'shared_console/errors/request_invalid',
+                     layout: 'error'
+                   )
+                 end
+
+                 result.value[:order]
                end
 
       @product_type = @order.products.first&.product_type || 'accommodation'
+      @expired_at = Time.zone.at(result&.value&.dig(:payload, 'exp')) if result&.value&.dig(:payload, 'exp')
 
       if @order.tenant.present?
         @name = @order.tenant.name

data/app/finders/spree_cm_commissioner/inventory_items/recently_changed_finder.rb

@@ -0,0 +1,88 @@
+module SpreeCmCommissioner
+  module InventoryItems
+    class RecentlyChangedFinder
+      def initialize(time_range: 7.days.ago, limit: 1000, vendor_id: nil, filter_type: 'all')
+        @time_range = time_range
+        @limit = limit
+        @vendor_id = vendor_id
+        @filter_type = filter_type
+      end
+
+      # Finds recently changed items with Redis comparison
+      # Returns array of hashes sorted by biggest discrepancy first
+      def execute
+        items = fetch_recent_items
+        items_with_comparison = fetch_quantity_in_redis_batch(items)
+
+        # Sort by biggest discrepancy first
+        items_with_comparison.sort_by { |item| (item[:quantity_in_redis].to_i - item[:quantity_available]).abs }.reverse
+      end
+
+      private
+
+      def fetch_recent_items
+        query = SpreeCmCommissioner::InventoryItem.active
+                                                  .where('cm_inventory_items.updated_at > ?', @time_range)
+                                                  .joins(variant: :product)
+                                                  .select(
+                                                    'cm_inventory_items.id',
+                                                    'cm_inventory_items.variant_id',
+                                                    'cm_inventory_items.inventory_date',
+                                                    'cm_inventory_items.quantity_available',
+                                                    'cm_inventory_items.updated_at',
+                                                    'cm_inventory_items.product_type',
+                                                    'spree_variants.sku',
+                                                    'spree_products.name as product_name',
+                                                    'spree_products.slug as product_slug'
+                                                  )
+
+        # Apply filter_type at query level
+        query = case @filter_type
+                when 'permanent'
+                  query.where(cm_inventory_items: { inventory_date: nil })
+                when 'non_permanent'
+                  query.where.not(cm_inventory_items: { inventory_date: nil })
+                else
+                  query
+                end
+
+        query = query.where(spree_variants: { vendor_id: @vendor_id }) if @vendor_id.present?
+
+        query.limit(@limit).order('cm_inventory_items.updated_at DESC')
+      end
+
+      # Batch fetch from Redis to avoid N+1 queries
+      def fetch_quantity_in_redis_batch(items)
+        return [] if items.empty?
+
+        keys = items.map { |item| "inventory:#{item.id}" }
+
+        # Use mget for efficient batch Redis fetch
+        quantity_in_redis_array = SpreeCmCommissioner.inventory_redis_pool.with do |redis|
+          redis.mget(*keys)
+        end
+
+        # Combine with DB data
+        items.each_with_index.map do |item, index|
+          quantity_in_redis = quantity_in_redis_array[index]&.to_i
+          quantity_available = item.quantity_available
+
+          {
+            inventory_item_id: item.id,
+            variant_id: item.variant_id,
+            product_name: item.product_name,
+            product_slug: item.product_slug,
+            sku: item.sku,
+            inventory_date: item.inventory_date,
+            quantity_available: quantity_available,
+            quantity_in_redis: quantity_in_redis,
+            difference: quantity_in_redis ? (quantity_in_redis - quantity_available) : nil,
+            out_of_sync: quantity_in_redis.nil? || quantity_in_redis != quantity_available,
+            last_updated: item.updated_at,
+            product_type: item.product_type
+          }
+        end
+      end
+    end
+  end
+end

data/app/helpers/spree_cm_commissioner/admin/service_calendars_helper.rb

@@ -5,9 +5,16 @@ module SpreeCmCommissioner
         label = resource.active ? 'Active' : 'Disabled'
         btn_active_class = resource.active ? 'btn-primary' : 'btn-warning'
 
+        # Determine the correct URL based on the calendarable type
+        url = if resource.calendarable_type == 'Spree::Product'
+                update_status_admin_product_product_service_calendar_path(resource.calendarable, resource)
+              else
+                update_status_admin_vendor_vendor_service_calendar_url(resource.calendarable, resource)
+              end
+
         button_to(
           label,
-          update_status_admin_vendor_vendor_service_calendar_url(resource.calendarable, resource),
+          url,
           form: { data: { confirm: 'Are you sure?' }, class: "btn btn-sm btn-active #{btn_active_class}" },
           method: :patch
         )

data/app/interactors/spree_cm_commissioner/inventory_item_syncer.rb

@@ -29,7 +29,17 @@ module SpreeCmCommissioner
       # ❌ DO NOT use increment! because it skips model validations.
       # We need validations to run so negative quantities are caught and surfaced
       # as errors, not silently allowed by the database.
-      inventory_item.update!(quantity_available: inventory_item.quantity_available + quantity)
+      #
+      # LOCKING STRATEGY: Dual Layer Protection
+      # 1. with_lock (Pessimistic): SELECT ... FOR UPDATE prevents concurrent writes
+      # 2. lock_version (Optimistic): Catches race conditions if row is modified between
+      #    SELECT and UPDATE (e.g., admin adjusts stock while job runs)
+      #
+      # Why both? Pessimistic lock protects against concurrent job execution.
+      # Optimistic lock catches stale reads from outside transactions.
+      inventory_item.with_lock do
+        inventory_item.update!(quantity_available: inventory_item.quantity_available + quantity)
+      end
     end
 
     def inventory_items