spree_cm_commissioner 2.5.13.pre.pre.pre.3 → 2.5.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: abe974606cb45f190fc9763b7e50c693e2349044545ad369da2cf595433a2ea4
-  data.tar.gz: 2e661fab59d721c66ef210688322477a59d2a2fc39fa5811b42f1699209872c7
+  metadata.gz: 3e4173db9eaef31ba44153b210477bd83e359559c6b007f644723d320e9e8f30
+  data.tar.gz: 38aba375ecb1177922443efbe00c09e923c75f3f2547c3df5cb383378e45a8b8
 SHA512:
-  metadata.gz: 05ff40748bfe49857e34a430dc47c1e0c809b2a6e7b40b6e8a326c21655dfe9a4493fc5bfefff857825dfa42a7cbfed926f405e86916ce705fb826ad523bcdbb
-  data.tar.gz: 31a426d613c9ba438c843ee92cc7fcc2ed26ae53c474caaa7dc5f099c5abc5f753de816ab08cb266f1a679e0a6309862ce5de8e747837fc0afaf3d8af46202b7
+  metadata.gz: 698f5ca602839ec3b8293cd2aecf31a1cc89d6125c16b831a8500ec0aa8c01d705bf15bc215dde6cd50de568c3d505803cf97ad4c4c6a4493f7018f7b535dde1
+  data.tar.gz: ef9ffdee2d499c102c1f8e2c7166d3ed0d3ccea24f9f6259d74555f4cdc8f7646b9e97ae373710f1412cf256f510e0296259e44fa5d693a19d927b9eecf51396

data/.env.example

@@ -40,3 +40,6 @@ 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 SpreeCmCommissioner::MaintenanceTasks::OrchestrateJob
+MAINTENANCE_TASKS_BATCH_SIZE=100

data/Gemfile.lock

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

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

@@ -4,11 +4,18 @@ 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,
+            manually_triggered: true
+          ).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/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/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/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/api/v2/tenant/guests_controller.rb

@@ -34,9 +34,9 @@ module Spree
 
             ActiveRecord::Base.transaction do
               resource.save!
+              recalculate_cart(resource.line_item)
               run_dynamic_fields(resource)
               resource.save_and_move_to_next_stage
-              recalculate_cart(resource.line_item)
             end
 
             render_serialized_payload(201) { serialize_resource(resource) }
@@ -49,8 +49,8 @@ module Spree
               run_dynamic_fields(resource) if guest_params[:guest_dynamic_fields_attributes]
               resource.assign_attributes(guest_params.except(:guest_dynamic_fields_attributes))
               resource.save!
-              resource.save_and_move_to_next_stage
               recalculate_cart(resource.line_item)
+              resource.save_and_move_to_next_stage
             end
 
             render_serialized_payload { serialize_resource(resource) }
@@ -117,10 +117,7 @@ module Spree
           end
 
           def recalculate_cart(line_item)
-            ::Spree::Dependencies.cart_recalculate_service.constantize.call(
-              line_item: line_item,
-              order: spree_current_order
-            )
+            ::Spree::Dependencies.cart_recalculate_service.constantize.call(line_item: line_item, order: spree_current_order)
           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/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

data/app/interactors/spree_cm_commissioner/stock/inventory_item_resetter.rb

@@ -11,7 +11,7 @@ module SpreeCmCommissioner
         updated = inventory_item.update(max_capacity: max_capacity, quantity_available: quantity_available)
         return context.fail!(message: 'Failed to update inventory item', errors: inventory_item.errors.full_messages) unless updated
 
-        clear_inventory_cache
+        reset_redis_inventory
       end
 
       def variant_total_inventory
@@ -34,9 +34,13 @@ module SpreeCmCommissioner
         end
       end
 
-      def clear_inventory_cache
+      def reset_redis_inventory
         SpreeCmCommissioner.inventory_redis_pool.with do |redis|
-          redis.del(inventory_item.redis_key)
+          redis.setex(
+            inventory_item.redis_key,
+            inventory_item.redis_expired_in,
+            inventory_item.quantity_available
+          )
         end
       end
     end

data/app/jobs/spree_cm_commissioner/maintenance_tasks/orchestrate_job.rb

@@ -0,0 +1,28 @@
+# Usage inside config/schedule.yml:
+#
+# maintenance_tasks_orchestrate:
+#   cron: "*/5 * * * *" # Every 5 minutes
+#   class: InvokeJob
+#   args: { class: "SpreeCmCommissioner::MaintenanceTasks::OrchestrateJob" }
+#
+# Or if you prefer less frequent:
+#   cron: "*/10 * * * *"
+module SpreeCmCommissioner
+  module MaintenanceTasks
+    class OrchestrateJob < ApplicationJob
+      queue_as :maintenance
+
+      BATCH_SIZE = ENV.fetch('MAINTENANCE_TASKS_BATCH_SIZE', '100').to_i
+
+      # Scheduled job that orchestrates maintenance tasks by enqueuing
+      # individual processor jobs. Thin wrapper for Orchestrate service.
+      # ApplicationJob handles error logging via around_perform hook.
+      def perform
+        tasks = SpreeCmCommissioner::MaintenanceTask.due_for_retry.order(created_at: :asc).limit(BATCH_SIZE)
+        return if tasks.empty?
+
+        tasks.each(&:async_execute)
+      end
+    end
+  end
+end

data/app/jobs/spree_cm_commissioner/maintenance_tasks/process_job.rb

@@ -0,0 +1,18 @@
+module SpreeCmCommissioner
+  module MaintenanceTasks
+    class ProcessJob < ApplicationUniqueJob
+      queue_as :maintenance
+
+      # Process a single maintenance task by calling task.execute directly.
+      # ApplicationJob handles error logging via around_perform hook.
+      def perform(options = {})
+        task_id = options[:task_id]
+        task = SpreeCmCommissioner::MaintenanceTask.find_by(id: task_id)
+
+        return if task.nil? || task.completed_at.present?
+
+        task.execute
+      end
+    end
+  end
+end

data/app/models/concerns/spree_cm_commissioner/order_state_machine.rb

@@ -53,9 +53,7 @@ module SpreeCmCommissioner
         after_transition from: :requested, to: :accepted, do: :decrement_user_request_orders_count
         after_transition to: :accepted, do: :send_order_accepted_app_notification_to_user
         after_transition to: :accepted, do: :send_order_accepted_telegram_alert_to_store
-
-        # call confirmation_delivered column directly since confirmation_delivered? is overrided
-        after_transition to: :accepted, if: :confirmation_delivered, do: :deliver_order_confirmation_email
+        after_transition to: :accepted, if: :confirmation_delivered?, do: :deliver_order_confirmation_email
 
         event :reject do
           transition from: :requested, to: :rejected
@@ -76,6 +74,14 @@ module SpreeCmCommissioner
       end
     end
 
+    # override
+    def deliver_order_confirmation_email
+      return if requested?
+      return if any_app_only_products?
+
+      super
+    end
+
     def increment_user_request_orders_count
       return if user.nil?
 
@@ -98,8 +104,13 @@ module SpreeCmCommissioner
     end
 
     def precalculate_conversion
-      line_items.each do |item|
-        SpreeCmCommissioner::ConversionPreCalculatorJob.perform_later(product_id: item.product_id)
+      event_ids = line_items.pluck(:event_id).compact.uniq
+      event_ids.each do |event_id|
+        # Just create task, CRON job will pick it up and execute.
+        SpreeCmCommissioner::MaintenanceTasks::Event.pending.find_or_create_by(
+          maintainable_type: 'Spree::Taxon',
+          maintainable_id: event_id
+        )
       end
     end
 
@@ -126,12 +137,6 @@ module SpreeCmCommissioner
       end
     end
 
-    # overrided not to send email yet to user if order needs confirmation
-    # it will send after vendors accepted.
-    def confirmation_delivered?
-      confirmation_delivered || need_confirmation?
-    end
-
     # allow authorized user to accept all requested line items
     def accepted_by(user)
       transaction do

data/app/models/concerns/spree_cm_commissioner/product_relation_type.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module SpreeCmCommissioner
+  module ProductRelationType
+    extend ActiveSupport::Concern
+
+    # Relation types for linking products together
+    # - open_dated_pair: Links fixed-date trip to open-dated trip (for flexible ticket redemption)
+    # - add_on: Links main product to optional extras
+    PRODUCT_RELATION_TYPES = %i[
+      open_dated_pair
+      add_on
+    ].freeze
+
+    included do
+      enum relation_type: PRODUCT_RELATION_TYPES.each_with_index.to_h { |type, index| [type, index] }
+    end
+
+    def self.options
+      PRODUCT_RELATION_TYPES.map { |k| [I18n.t("product_relation_type.#{k}"), k] }
+    end
+
+    def display_relation_type
+      return nil if relation_type.blank?
+
+      I18n.t("product_relation_type.#{relation_type}")
+    end
+  end
+end