spree_cm_commissioner 2.0.3 → 2.1.0.pre.pre2

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

@@ -14,13 +14,6 @@ module SpreeCmCommissioner
       state_selection
       payment_option
       delivery_option
-      amenity
-      departure_time
-      duration
-      vehicle_id
-      origin
-      destination
-      place_id
     ].freeze
 
     RESERVED_OPTIONS = {
@@ -48,11 +41,9 @@ module SpreeCmCommissioner
       'bib-display-prefix' => 'boolean',
       'bib-pre-generation-on-create' => 'boolean',
       'seat-number-positions' => 'array',
-      'origin' => 'place_id',
-      'destination' => 'place_id',
-      'departure-time' => 'time',
-      'vehicle' => 'vehicle_id',
-      'allow-seat-selection' => 'boolean'
+      'seat-type' => 'string',
+      'intercity-taxi' => 'string',
+      'pickup-time' => 'integer'
     }.freeze
 
     included do

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

@@ -0,0 +1,44 @@
+module SpreeCmCommissioner
+  module OrderSeatable
+    def should_manage_blocks?
+      preload_block_ids.any?
+    end
+
+    def hold_blocks!
+      return unless should_manage_blocks?
+
+      CmAppLogger.log(label: "#{self.class.name}#hold_blocks!", data: { order_id: id }) do
+        SpreeCmCommissioner::Seats::BlocksHolder.new(line_item_ids: line_item_ids, hold_by: user).hold_blocks!
+      end
+    end
+
+    def cancel_blocks!
+      return unless should_manage_blocks?
+
+      CmAppLogger.log(label: "#{self.class.name}#cancel_blocks!", data: { order_id: id }) do
+        SpreeCmCommissioner::Seats::BlocksCanceler.new(order_id: id, cancel_by: user).cancel_blocks!
+      end
+    end
+
+    def reserve_blocks!
+      return unless should_manage_blocks?
+
+      CmAppLogger.log(label: "#{self.class.name}#reserve_blocks!", data: { order_id: id }) do
+        SpreeCmCommissioner::Seats::BlocksReserver.new(line_item_ids: line_item_ids, reserve_by: user).reserve_blocks!
+      end
+    end
+
+    # Calling `.block_ids` directly can cause many slow database queries (N+1 problem)
+    # every time `.should_manage_blocks?` or `.preload_block_ids` runs.
+    # To avoid this, we store a precomputed list of block IDs in `private_metadata`.
+    # This list is updated whenever a guest’s block is saved or destroy.
+    def preload_block_ids=(preload_block_ids = [])
+      self.private_metadata ||= {}
+      self.private_metadata['preload_block_ids'] = preload_block_ids
+    end
+
+    def preload_block_ids
+      self.private_metadata&.fetch('preload_block_ids', []) || []
+    end
+  end
+end

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

@@ -5,6 +5,8 @@ module SpreeCmCommissioner
     extend ActiveSupport::Concern
 
     included do
+      state_machine.before_transition to: :payment, do: :hold_blocks!
+
       state_machine.before_transition to: :complete, do: :request, if: :need_confirmation?
       state_machine.before_transition to: :complete, do: :generate_bib_number
 
@@ -14,10 +16,14 @@ module SpreeCmCommissioner
       state_machine.after_transition to: :complete, do: :send_order_complete_telegram_alert_to_vendors, unless: :need_confirmation?
       state_machine.after_transition to: :complete, do: :send_order_complete_telegram_alert_to_store, unless: :need_confirmation?
 
+      state_machine.around_transition to: :complete, do: :unstock_inventory!
+
       state_machine.after_transition to: :complete, do: :send_transaction_email_to_user, if: :user_has_email?
       state_machine.after_transition to: :resumed, do: :precalculate_conversion
+      state_machine.around_transition to: :resumed, do: :unstock_inventory!
 
       state_machine.after_transition to: :canceled, do: :precalculate_conversion
+      state_machine.after_transition to: :canceled, do: :restock_inventory!
 
       scope :accepted, -> { where(request_state: 'accepted') }
 
@@ -67,6 +73,39 @@ module SpreeCmCommissioner
       end
     end
 
+    def unstock_inventory!
+      ActiveRecord::Base.transaction do
+        yield # Equal to block.call
+
+        # After the transition is complete, the following code will execute first before proceeding to other `after_transition` callbacks.
+        # This ensures that if `reserve_blocks!` or `unstock_inventory_in_redis!` fails, the state will be rolled back,
+        # and neither the `finalize!` method nor any notifications will be triggered.
+        # The payment will be reversed in vPago gem, and `Spree::Checkout::Complete` will be called, which checks `order.reload.complete?`.
+        # This is critical because if the order state is complete, the payment will be marked as paid.
+
+        reserve_blocks!
+        unstock_inventory_in_redis!
+
+        # We rollback only order state, and we keep payment state as it is.
+        # We implement payment in vPago gem, and it will be reversed in the gem.
+        # Some bank has api for refund, but some don't have the api to refund yet. So we keep the payment state as it is and refund manually.
+      end
+    rescue StandardError => e
+      CmAppLogger.log(
+        label: 'SpreeCmCommissioner::OrderStateMachine#reserve_inventory failed',
+        data: { order_id: id, error: e.message, type: e.class.name, backtrace: e.backtrace&.first(5)&.join("\n") }
+      )
+
+      raise e
+    end
+
+    def restock_inventory!
+      ActiveRecord::Base.transaction do
+        cancel_blocks!
+        restock_inventory_in_redis!
+      end
+    end
+
     def generate_bib_number
       line_items.find_each(&:generate_remaining_guests)
 

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

@@ -3,12 +3,10 @@ module SpreeCmCommissioner
     extend ActiveSupport::Concern
 
     included do
-      delegate :product_type,
-               :subscribable?,
+      delegate :subscribable?,
                :allowed_upload_later?,
                :need_confirmation?, :need_confirmation,
                :allow_anonymous_booking,
-               :accommodation?, :service?, :ecommerce?,
                :allow_self_check_in,
                :allow_self_check_in?,
                :required_self_check_in_location,

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

@@ -6,10 +6,20 @@ module SpreeCmCommissioner
     extend ActiveSupport::Concern
 
     PRODUCT_TYPES = %i[accommodation service ecommerce transit].freeze
+    PERMANENT_STOCK_PRODUCT_TYPES = %w[accommodation service transit].freeze
+    PRE_INVENTORY_DAYS = { 'transit' => 90, 'accommodation' => 365, 'service' => 30 }.freeze
 
     included do
       enum product_type: PRODUCT_TYPES if table_exists? && column_names.include?('product_type')
       enum primary_product_type: PRODUCT_TYPES if table_exists? && column_names.include?('primary_product_type')
     end
+
+    def permanent_stock?
+      PERMANENT_STOCK_PRODUCT_TYPES.include?(product_type)
+    end
+
+    def pre_inventory_days
+      PRE_INVENTORY_DAYS[product_type]
+    end
   end
 end

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

@@ -2,7 +2,7 @@ module SpreeCmCommissioner
   module RouteType
     extend ActiveSupport::Concern
 
-    ROUTE_TYPES = %i[automobile subway rails ferry].freeze
+    ROUTE_TYPES = %i[bus intercity_taxi airport_shuttle rails ferry].freeze
 
     included do
       enum route_type: ROUTE_TYPES if table_exists? && column_names.include?('route_type')

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

@@ -3,7 +3,7 @@ module SpreeCmCommissioner
     extend ActiveSupport::Concern
 
     included do
-      enum kind: { category: 0, cms: 1, event: 2, occupation: 3, nationality: 4, organization: 5, transit: 6 }
+      enum kind: { category: 0, cms: 1, event: 2, occupation: 3, nationality: 4, organization: 5, transit: 6, industry: 7 }
     end
   end
 end

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

@@ -7,19 +7,27 @@ module SpreeCmCommissioner
 
       has_many :user_identity_providers, dependent: :destroy, class_name: 'SpreeCmCommissioner::UserIdentityProvider'
 
-      validates :user_identity_providers, presence: true, if: -> (u) { u.require_login_identity_all_blank_for(:user_identity_providers) }
+      # Attribute to flag social network registration to skip presence validation
+      # for email, login, phone_number, and user_identity_providers
+      attr_accessor :registering_via_social_network
 
-      validates :phone_number, presence: true, if: -> (u) { u.require_login_identity_all_blank_for(:phone_number) }
+      validates :user_identity_providers, presence: true, if: lambda { |u|
+        u.require_login_identity_all_blank_for(:user_identity_providers) && !u.registering_via_social_network
+      }
+
+      validates :phone_number, presence: true, if: lambda { |u|
+        u.require_login_identity_all_blank_for(:phone_number) && !u.registering_via_social_network
+      }
       validates :phone_number, uniqueness: { scope: :tenant_id, allow_blank: true }
       validates :phone_number, format: { with: /^\d{8,12}$/, :multiline => true, allow_blank: true }
 
-      validates :login, presence: true, if: -> (u) { u.require_login_identity_all_blank_for(:login) }
+      validates :login, presence: true, if: -> (u) { u.require_login_identity_all_blank_for(:login) && !u.registering_via_social_network }
       validates :login, uniqueness: { scope: :tenant_id, case_sensitive: false, allow_blank: true }
 
       _validators.reject! { |key, _| key == :email }
       _validate_callbacks.each { |c| c.filter.attributes.delete(:email) if c.filter.respond_to?(:attributes) }
 
-      validates :email, presence: true, if: -> (u) { u.require_login_identity_all_blank_for(:email) }
+      validates :email, presence: true, if: -> (u) { u.require_login_identity_all_blank_for(:email) && !u.registering_via_social_network }
       validates :email, uniqueness: { scope: :tenant_id, case_sensitive: false, allow_blank: true }
       validates :email, format: { with: URI::MailTo::EMAIL_REGEXP, allow_blank: true }
     end

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

@@ -29,6 +29,7 @@ module SpreeCmCommissioner
                :bib_pre_generation_on_create?,
                :seat_number_positions,
                :seat_number_layouts,
+               :seat_type,
                to: :options
     end
 

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

@@ -0,0 +1,11 @@
+module SpreeCmCommissioner
+  module VehicleType
+    extend ActiveSupport::Concern
+
+    VEHICLE_TYPES = %i[suv sedan minivan van sleeping_bus luxury_van air_bus bus].freeze
+
+    included do
+      enum vehicle_type: VEHICLE_TYPES if table_exists? && column_names.include?('vehicle_type')
+    end
+  end
+end

data/app/models/spree_cm_commissioner/address_decorator.rb

@@ -1,10 +1,44 @@
 module SpreeCmCommissioner
   module AddressDecorator
     def self.prepended(base)
-      # Field is not mandatory
       base.enum gender: { :not_selected => 0, :male => 1, :female => 2, :other => 3 }
+
+      base.validates :address1, presence: true, if: :require_address1?
+      base.validates :city, presence: true, if: :require_city?
+      base.validates :country, presence: true, if: :require_country?
+    end
+
+    # override to return false instead of true
+    # in case no country
+    def require_zipcode?
+      country ? country.zipcode_required? : false
+    end
+
+    def require_address1?
+      false
+    end
+
+    def require_city?
+      false
+    end
+
+    def require_country?
+      false
     end
   end
 end
 
-Spree::Address.prepend(SpreeCmCommissioner::AddressDecorator) unless Spree::Address.included_modules.include?(SpreeCmCommissioner::AddressDecorator)
+if Spree::Address.included_modules.exclude?(SpreeCmCommissioner::AddressDecorator)
+  keys = %i[address1 city country]
+
+  Spree::Address._validators.reject! { |key, _| keys.include?(key) }
+  Spree::Address._validate_callbacks.each do |c|
+    next unless c.filter.respond_to?(:attributes)
+
+    c.filter.attributes.delete(:address1)
+    c.filter.attributes.delete(:city)
+    c.filter.attributes.delete(:country)
+  end
+
+  Spree::Address.prepend(SpreeCmCommissioner::AddressDecorator)
+end

data/app/models/spree_cm_commissioner/block.rb

@@ -0,0 +1,43 @@
+module SpreeCmCommissioner
+  class Block < Base
+    enum block_type: {
+      seat: 1,
+      sleeping_seat: 2,
+      driver: 3,
+      bathroom: 4,
+      other: 0
+    }
+
+    belongs_to :seat_section, class_name: 'SpreeCmCommissioner::SeatSection', optional: true
+    belongs_to :seat_layout, class_name: 'SpreeCmCommissioner::SeatLayout', optional: false
+
+    validates :label, presence: true, if: :label_required?
+
+    has_many :variant_blocks, class_name: 'SpreeCmCommissioner::VariantBlock', dependent: :destroy
+    has_many :variants, class_name: 'Spree::Variant', through: :variant_blocks
+
+    validates :width, presence: true, numericality: { greater_than: 0 }
+    validates :height, presence: true, numericality: { greater_than: 0 }
+    validates :x, presence: true, numericality: true
+    validates :y, presence: true, numericality: true
+    validates :rotation, presence: true, numericality: { greater_than_or_equal_to: -360, less_than_or_equal_to: 360 }
+
+    before_validation :assign_layout_from_section, if: -> { seat_layout.nil? && seat_section.present? }
+
+    def label_required?
+      seatable? || block_type.to_s == 'other'
+    end
+
+    def self.seatable?(block_type)
+      block_type.to_s.in?(%w[sleeping_seat seat])
+    end
+
+    def seatable?
+      self.class.seatable?(block_type)
+    end
+
+    def assign_layout_from_section
+      self.seat_layout = seat_section.seat_layout
+    end
+  end
+end

data/app/models/spree_cm_commissioner/customer_notification.rb

@@ -1,19 +1,25 @@
 module SpreeCmCommissioner
   class CustomerNotification < SpreeCmCommissioner::Base
+    acts_as_paranoid column: :deleted_at
     has_many :notifications, as: :notificable, dependent: :destroy, class_name: 'SpreeCmCommissioner::Notification'
 
     # deprecated
     has_one :feature_image, as: :viewable, dependent: :destroy, class_name: 'SpreeCmCommissioner::FeatureImage'
 
     has_many :feature_images, as: :viewable, dependent: :destroy, class_name: 'SpreeCmCommissioner::FeatureImage'
-    has_many :notification_taxons, class_name: 'SpreeCmCommissioner::NotificationTaxon'
+    has_many :notification_taxons, dependent: :destroy, class_name: 'SpreeCmCommissioner::NotificationTaxon'
     has_many :taxons, through: :notification_taxons, class_name: 'Spree::Taxon'
 
+    belongs_to :vendor, class_name: 'Spree::Vendor'
+
     validates :title, presence: true
     validates :url, presence: true
 
     validates :notification_type, presence: true
 
+    self.whitelisted_ransackable_attributes = %w[title excerpt notification_type]
+    self.whitelisted_ransackable_associations = %w[notification_taxons taxons]
+
     enum notification_type: { :promotion => 0, :announcement => 1 }
 
     def push_notification_image_url

data/app/models/spree_cm_commissioner/dynamic_field.rb

@@ -18,6 +18,8 @@ module SpreeCmCommissioner
     validates :configurations, presence: true, allow_blank: false
     validate :validate_data_fill_stage_phase
 
+    scope :with_dynamic_field_options, -> { includes(dynamic_field_options: :dynamic_field) }
+
     def requires_dynamic_field_options?
       checkbox? || radio? || selection?
     end

data/app/models/spree_cm_commissioner/guest.rb

@@ -24,10 +24,17 @@ module SpreeCmCommissioner
     scope :none_bib, -> { where(bib_prefix: [nil, '']) }
 
     belongs_to :line_item, class_name: 'Spree::LineItem'
+
     has_one :variant, class_name: 'Spree::Variant', through: :line_item
+
     belongs_to :user, class_name: 'Spree::User'
     belongs_to :occupation, class_name: 'Spree::Taxon'
     belongs_to :nationality, class_name: 'Spree::Taxon'
+    belongs_to :block, class_name: 'SpreeCmCommissioner::Block', optional: true
+    belongs_to :saved_guest, class_name: 'SpreeCmCommissioner::SavedGuest', optional: true
+
+    has_one :reserved_block, class_name: 'SpreeCmCommissioner::ReservedBlock'
+
     scope :checked_ins, -> { joins(:check_in) }
     scope :no_show, -> { left_outer_joins(:check_in).where(cm_check_ins: { id: nil }) }
 
@@ -48,12 +55,22 @@ module SpreeCmCommissioner
 
     before_create :generate_bib, if: -> { line_item.reload && variant.bib_pre_generation_on_create? }
 
+    after_create :preload_order_block_ids, if: -> { block_id.present? }
+    after_update :preload_order_block_ids, if: :saved_change_to_block_id?
+    after_destroy :preload_order_block_ids
+
     validates :seat_number, uniqueness: { scope: :event_id }, allow_nil: true, if: -> { event_id.present? }
     validates :bib_index, uniqueness: true, allow_nil: true
 
+    validate :validate_block, if: :should_validate_block?
+
     self.whitelisted_ransackable_associations = %w[id_card event line_item]
     self.whitelisted_ransackable_attributes = %w[first_name last_name phone_number gender contact occupation_id card_type created_at check_in_status]
 
+    scope :with_dynamic_fields_and_options, lambda {
+      includes(guest_dynamic_fields: { dynamic_field: :dynamic_field_options })
+    }
+
     def self.csv_importable_columns
       %i[
         first_name last_name phone_number age dob gender address other_occupation
@@ -213,75 +230,147 @@ module SpreeCmCommissioner
       save!
     end
 
-    def missing_dynamic_fields_for_stage(stage)
-      required_fields = line_item.product.dynamic_fields.where(data_fill_stage: stage)
-      filled_ids = guest_dynamic_fields.map(&:dynamic_field_id)
+    # bib_number: 345, bib_prefix: 5KM, bib_zerofill: 5 => return 5KM00345
+    # bib_number: 345, bib_prefix: 5KM, bib_zerofill: 2 => return 5KM345
+    def formatted_bib_number
+      return nil if line_item.blank? || line_item.variant.blank?
+      return nil if bib_prefix.blank?
+      return nil if bib_number.blank?
 
-      required_fields.reject { |field| filled_ids.include?(field.id) }
+      filled_bib_number = bib_number.to_s.rjust(line_item.variant.bib_zerofill.to_i, '0')
+
+      if bib_display_prefix?
+        "#{bib_prefix}#{filled_bib_number}"
+      else
+        filled_bib_number
+      end
+    end
+
+    # validate only if block_id is present AND (new record OR block_id is changing)
+    # goal: don't bother re-validating when block_id stays the same
+    def should_validate_block?
+      block_id.present? && (new_record? || will_save_change_to_block_id?)
+    end
+
+    def validate_block
+      return if block_id.blank?
+      return if line_item.blank? || line_item.variant.blank?
+      return if line_item.variant.variant_blocks.exists?(block_id: block_id)
+
+      errors.add(:block, "does not exist in variant #{line_item.variant_id}")
+    end
+
+    def preload_order_block_ids
+      return if line_item.blank?
+      return if line_item.order.blank?
+
+      block_ids = line_item.order.blocks.pluck(:id)
+      line_item.order.update(preload_block_ids: block_ids)
     end
 
     def all_required_dynamic_fields_completed?(stage)
       missing_dynamic_fields_for_stage(stage).blank?
     end
 
-    def validate_dynamic_fields_for_phase(phase)
-      required_fields = line_item.product.dynamic_fields.where(data_fill_stage: phase)
-      filled_ids = guest_dynamic_fields.map(&:dynamic_field_id)
+    state_machine :data_fill_stage_phase, initial: 'pre_registration' do
+      state 'pre_registration', value: 'pre_registration'
+      state 'post_registration', value: 'post_registration'
+      state 'during_check_in', value: 'during_check_in'
+      state 'completed', value: 'completed'
+
+      event :complete_pre_registration do
+        transition 'pre_registration' => 'post_registration',
+                   if: -> (guest) { guest.pre_registration_completed? && guest.post_registration_fields? }
+        transition 'pre_registration' => 'during_check_in',
+                   if: -> (guest) { guest.pre_registration_completed? && !guest.post_registration_fields? && guest.during_check_in_fields? }
+        transition 'pre_registration' => 'completed',
+                   if: -> (guest) { guest.pre_registration_completed? && !guest.post_registration_fields? && !guest.during_check_in_fields? }
+      end
+
+      event :complete_post_registration do
+        transition 'post_registration' => 'during_check_in',
+                   if: -> (guest) { guest.post_registration_completed? && guest.during_check_in_fields? }
+        transition 'post_registration' => 'completed',
+                   if: -> (guest) { guest.post_registration_completed? && !guest.during_check_in_fields? }
+      end
 
-      required_fields.each do |field|
-        errors.add(:base, "#{field.label} is required for #{phase} phase") unless filled_ids.include?(field.id)
+      event :complete_check_in do
+        transition 'during_check_in' => 'completed',
+                   if: -> (guest) { guest.check_in_completed? }
       end
     end
 
+    def save_and_move_to_next_stage(_transition = nil)
+      # Trigger state machine transitions based on completion status
+      case data_fill_stage_phase
+      when 'pre_registration'
+        complete_pre_registration! if pre_registration_completed?
+      when 'post_registration'
+        complete_post_registration! if post_registration_completed?
+      when 'during_check_in'
+        complete_check_in! if check_in_completed?
+      end
+    end
+
+    def completed_phases
+      phases = []
+      phases << 'pre_registration' if pre_registration_completed?
+      phases << 'post_registration' if post_registration_completed?
+      phases << 'during_check_in' if check_in_completed?
+      phases
+    end
+
     def pre_registration_completed?
-      return true unless line_item.product.dynamic_fields.pre_registration.any?
+      return true unless line_item&.product&.dynamic_fields&.pre_registration&.any?
 
-      pre_registration_fields_completed?
+      required_fields = line_item.product.dynamic_fields.pre_registration.pluck(:id)
+      filled_fields = guest_dynamic_fields.where(dynamic_field_id: required_fields).pluck(:dynamic_field_id)
+      (required_fields - filled_fields).empty?
     end
 
     def post_registration_completed?
-      return true unless line_item.product.dynamic_fields.post_registration.any?
+      return true unless line_item&.product&.dynamic_fields&.post_registration&.any?
 
-      post_registration_fields_completed?
+      required_fields = line_item.product.dynamic_fields.post_registration.pluck(:id)
+      filled_fields = guest_dynamic_fields.where(dynamic_field_id: required_fields).pluck(:dynamic_field_id)
+      (required_fields - filled_fields).empty?
     end
 
     def check_in_completed?
-      return true unless line_item.product.dynamic_fields.during_check_in.any?
+      return true unless line_item&.product&.dynamic_fields&.during_check_in&.any?
 
-      check_in_fields_completed?
+      required_fields = line_item.product.dynamic_fields.during_check_in.pluck(:id)
+      filled_fields = guest_dynamic_fields.where(dynamic_field_id: required_fields).pluck(:dynamic_field_id)
+      (required_fields - filled_fields).empty?
     end
 
-    def current_collection_phase
-      if check_in.present?
-        :during_check_in
-      elsif line_item.order.completed?
-        :post_registration
-      else
-        :pre_registration
-      end
+    def pre_registration_fields?
+      line_item&.product&.dynamic_fields&.pre_registration&.any?
     end
 
-    def phase_completion_status
-      {
-        pre_registration: pre_registration_completed?,
-        post_registration: post_registration_completed?,
-        during_check_in: check_in_completed?
-      }
+    def post_registration_fields?
+      line_item&.product&.dynamic_fields&.post_registration&.any?
     end
 
-    # bib_number: 345, bib_prefix: 5KM, bib_zerofill: 5 => return 5KM00345
-    # bib_number: 345, bib_prefix: 5KM, bib_zerofill: 2 => return 5KM345
-    def formatted_bib_number
-      return nil if bib_prefix.blank?
-      return nil if bib_number.blank?
+    def during_check_in_fields?
+      line_item&.product&.dynamic_fields&.during_check_in&.any?
+    end
 
-      filled_bib_number = bib_number.to_s.rjust(line_item.variant.bib_zerofill.to_i, '0')
+    private
 
-      if bib_display_prefix?
-        "#{bib_prefix}#{filled_bib_number}"
-      else
-        filled_bib_number
-      end
+    def product_dynamic_fields
+      @product_dynamic_fields ||= line_item.product.dynamic_fields
+    end
+
+    def missing_dynamic_fields_for_stage(stage)
+      return [] if line_item.blank? || line_item.product.blank?
+
+      # Cache product dynamic fields to avoid multiple queries
+      @product_dynamic_fields ||= line_item.product.dynamic_fields
+      required_fields = @product_dynamic_fields.where(data_fill_stage: stage)
+      filled_ids = guest_dynamic_fields&.pluck(:dynamic_field_id) || []
+
+      required_fields.reject { |field| filled_ids.include?(field.id) }
     end
   end
 end