spree_cm_commissioner 2.0.3.pre.pre6 → 2.0.3.pre.pre.pre7

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

@@ -18,32 +18,29 @@ module SpreeCmCommissioner
     def date_unit
       return nil unless permanent_stock?
 
-      date_range.size
+      date_range_excluding_checkout.size if accommodation?
     end
 
-    def date_range
+    def date_range_excluding_checkout
       return [] unless date_present?
-      return [] unless permanent_stock?
-
-      # For transit products (e.g., bus, train), only return the departure day,
-      # as the booking represents a single trip rather than a duration.
-      return [from_date.to_date] if transit?
 
-      # For products with a stay or usage period (e.g., hotel, car rental, activities),
-      # return the full date range from start to end, inclusive.
-      return (from_date.to_date..to_date.to_date).to_a if service? || accommodation?
-
-      []
+      date_range = (from_date.to_date..to_date.to_date).to_a
+      date_range.pop if date_range.size > 1
+      date_range
     end
 
-    def checkin_date
-      from_date&.to_datetime
-    end
+    def date_range_including_checkout
+      return [] unless date_present?
 
-    def checkout_date
-      return to_date ? to_date.to_datetime + 1.day : nil if accommodation?
+      (from_date.to_date..to_date.to_date).to_a
+    end
 
-      to_date&.to_datetime
+    def date_range
+      if accommodation?
+        date_range_excluding_checkout
+      else
+        date_range_including_checkout
+      end
     end
 
     private

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

@@ -1,21 +1,13 @@
-# Number of guests are depend on the variant, but user is allowed to input custom number of guests
-# which will be stored in public_metadata.
-#
-# metadata {
-#   'number_of_adults': 2,
-#   'number_of_kids': 1,
-# }
 module SpreeCmCommissioner
   module LineItemGuestsConcern
     extend ActiveSupport::Concern
 
     included do
-      validate :validate_total_adults, if: -> { valid_integer_metadata?('number_of_adults') }
-      validate :validate_total_kids, if: -> { valid_integer_metadata?('number_of_kids') }
+      validate :validate_total_adults, if: -> { public_metadata[:number_of_adults].present? }
+      validate :validate_total_kids, if: -> { public_metadata[:number_of_kids].present? }
     end
 
-    def number_of_adults = public_metadata['number_of_adults']&.to_i || (variant.number_of_adults * quantity)
-    def number_of_kids = public_metadata['number_of_kids']&.to_i || (variant.number_of_kids * quantity)
+    def remaining_total_guests = [number_of_guests - guests.size, 0].max
     def number_of_guests = number_of_adults + number_of_kids
 
     def allowed_extra_adults = variant.allowed_extra_adults * quantity
@@ -24,7 +16,8 @@ module SpreeCmCommissioner
     def allowed_total_adults = (variant.number_of_adults * quantity) + allowed_extra_adults
     def allowed_total_kids = (variant.number_of_kids * quantity) + allowed_extra_kids
 
-    def remaining_total_guests = [number_of_guests - guests.size, 0].max
+    def number_of_adults = public_metadata[:number_of_adults] || (variant.number_of_adults * quantity)
+    def number_of_kids = public_metadata[:number_of_kids] || (variant.number_of_kids * quantity)
 
     def generate_remaining_guests
       return if remaining_total_guests.zero?
@@ -35,17 +28,15 @@ module SpreeCmCommissioner
     end
 
     def extra_adults
-      return 0 unless valid_integer_metadata?('number_of_adults')
       return 0 unless extra_adults?
 
-      public_metadata['number_of_adults'].to_i - (variant.number_of_adults * quantity)
+      public_metadata[:number_of_adults] - (variant.number_of_adults * quantity)
     end
 
     def extra_kids
-      return 0 unless valid_integer_metadata?('number_of_kids')
       return 0 unless extra_kids?
 
-      public_metadata['number_of_kids'].to_i - (variant.number_of_kids * quantity)
+      public_metadata[:number_of_kids] - (variant.number_of_kids * quantity)
     end
 
     def guest_options
@@ -64,30 +55,25 @@ module SpreeCmCommissioner
     end
 
     def extra_adults?
-      return false unless valid_integer_metadata?('number_of_adults')
-
-      public_metadata['number_of_adults'].to_i > variant.number_of_adults * quantity
+      public_metadata[:number_of_adults].present? && public_metadata[:number_of_adults] > variant.number_of_adults * quantity
     end
 
     def extra_kids?
-      return false unless valid_integer_metadata?('number_of_kids')
-
-      public_metadata['number_of_kids'].to_i > variant.number_of_kids * quantity
+      public_metadata[:number_of_kids].present? && public_metadata[:number_of_kids] > variant.number_of_kids * quantity
     end
 
     private
 
-    def valid_integer_metadata?(key)
-      value = public_metadata[key.to_s]
-      value.present? && value.to_s.match?(/\A-?\d+\z/)
-    end
-
     def validate_total_adults
-      errors.add(:quantity, 'exceed_total_adults') if public_metadata['number_of_adults'].to_i > allowed_total_adults
+      return if public_metadata[:number_of_adults] <= allowed_total_adults
+
+      errors.add(:quantity, 'exceed_total_adults')
     end
 
     def validate_total_kids
-      errors.add(:quantity, 'exceed_total_kids') if public_metadata['number_of_kids'].to_i > allowed_total_kids
+      return if public_metadata[:number_of_kids] <= allowed_total_kids
+
+      errors.add(:quantity, 'exceed_total_kids')
     end
   end
 end

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

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

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

@@ -5,8 +5,6 @@ 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
 
@@ -16,14 +14,10 @@ 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') }
 
@@ -73,39 +67,6 @@ 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,10 +3,12 @@ module SpreeCmCommissioner
     extend ActiveSupport::Concern
 
     included do
-      delegate :subscribable?,
+      delegate :product_type,
+               :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,20 +6,10 @@ 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[bus intercity_taxi airport_shuttle rails ferry].freeze
+    ROUTE_TYPES = %i[automobile subway rails ferry].freeze
 
     included do
       enum route_type: ROUTE_TYPES if table_exists? && column_names.include?('route_type')

data/app/models/spree_cm_commissioner/address_decorator.rb

@@ -1,44 +1,10 @@
 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
 
-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
+Spree::Address.prepend(SpreeCmCommissioner::AddressDecorator) unless Spree::Address.included_modules.include?(SpreeCmCommissioner::AddressDecorator)

data/app/models/spree_cm_commissioner/branch.rb

@@ -0,0 +1,12 @@
+require_dependency 'spree_cm_commissioner'
+
+module SpreeCmCommissioner
+  class Branch < SpreeCmCommissioner::Place
+    belongs_to :state,  class_name: 'Spree::State', optional: true
+    belongs_to :vendor, class_name: 'Spree::Vendor'
+
+    def validate_reference?
+      false
+    end
+  end
+end

data/app/models/spree_cm_commissioner/guest.rb

@@ -24,17 +24,10 @@ 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 }) }
 
@@ -55,15 +48,9 @@ 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]
 
@@ -226,97 +213,124 @@ 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 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
 
     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
+
+      event :complete_check_in do
+        transition 'during_check_in' => 'completed',
+                   if: -> (guest) { guest.check_in_completed? }
+      end
+    end
 
-      required_fields.each do |field|
-        errors.add(:base, "#{field.label} is required for #{phase} phase") unless filled_ids.include?(field.id)
+    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?
-
-      check_in_fields_completed?
-    end
+      return true unless line_item&.product&.dynamic_fields&.during_check_in&.any?
 
-    def current_collection_phase
-      if check_in.present?
-        :during_check_in
-      elsif line_item.order.completed?
-        :post_registration
-      else
-        :pre_registration
-      end
+      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 phase_completion_status
-      {
-        pre_registration: pre_registration_completed?,
-        post_registration: post_registration_completed?,
-        during_check_in: check_in_completed?
-      }
+    def pre_registration_fields?
+      line_item&.product&.dynamic_fields&.pre_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?
-
-      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
+    def post_registration_fields?
+      line_item&.product&.dynamic_fields&.post_registration&.any?
     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?)
+    def during_check_in_fields?
+      line_item&.product&.dynamic_fields&.during_check_in&.any?
     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)
+    private
 
-      errors.add(:block, "does not exist in variant #{line_item.variant_id}")
+    def product_dynamic_fields
+      @product_dynamic_fields ||= line_item.product.dynamic_fields
     end
 
-    def preload_order_block_ids
-      return if line_item.blank?
-      return if line_item.order.blank?
+    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) || []
 
-      block_ids = line_item.order.blocks.pluck(:id)
-      line_item.order.update(preload_block_ids: block_ids)
+      required_fields.reject { |field| filled_ids.include?(field.id) }
     end
   end
 end

data/app/models/spree_cm_commissioner/guest_dynamic_field.rb

@@ -4,10 +4,13 @@ module SpreeCmCommissioner
     belongs_to :dynamic_field, class_name: 'SpreeCmCommissioner::DynamicField', optional: false
     belongs_to :dynamic_field_option, class_name: 'SpreeCmCommissioner::DynamicFieldOption', optional: true
 
-    validates :value, presence: true
     validate :validate_value_format, if: -> { value.present? && dynamic_field.present? }
     validate :validate_option_reference, if: -> { dynamic_field_option.present? }
+    validate :validate_phase_sequence
     validate :check_required_fields_based_on_phase
+    validate :reject_empty_string_for_text_fields
+
+    after_commit :sync_guest_data_fill_stage_phase
 
     private
 
@@ -15,6 +18,8 @@ module SpreeCmCommissioner
       return if dynamic_field.blank?
 
       case dynamic_field.data_type.to_s
+      when 'text', 'textarea'
+        errors.add(:value, "can't be blank") if value.is_a?(String) && value.strip == ''
       when 'number'
         errors.add(:value, 'must be a number') unless value.to_s.match?(/\A\d+\z/)
       when 'boolean'
@@ -40,44 +45,49 @@ module SpreeCmCommissioner
       errors.add(:dynamic_field_option, 'must belong to the same dynamic field')
     end
 
-    def before_checkin_phase?
-      guest.present? && guest.line_item.present? && guest.check_in.nil?
-    end
+    def validate_phase_sequence
+      return if dynamic_field.blank? || guest.blank?
 
-    def after_purchase_phase?
-      guest.present? && guest.line_item.present? && guest.line_item.completed? && guest.check_in.nil?
+      case dynamic_field.data_fill_stage.to_sym
+      when :post_registration
+        errors.add(:base, 'Must complete pre_registration fields first') unless guest.pre_registration_completed?
+      when :during_check_in
+        unless guest.post_registration_completed? || !guest.post_registration_fields?
+          errors.add(:base, 'Must complete post_registration fields first')
+        end
+      end
     end
 
-    def during_checkin_phase?
-      guest.present? && guest.check_in.present?
-    end
+    def field_required_in_current_phase?
+      return false if dynamic_field.blank? || guest.blank?
 
-    def pre_registration_required?
-      dynamic_field.data_fill_stage.to_sym == :pre_registration &&
+      case dynamic_field.data_fill_stage.to_sym
+      when :pre_registration, :post_registration
         guest.line_item.order.completed? && guest.check_in.blank?
+      when :during_check_in
+        guest.check_in.present?
+      else
+        false
+      end
     end
 
-    def post_registration_required?
-      dynamic_field.data_fill_stage.to_sym == :post_registration &&
-        guest.line_item.order.completed? && guest.check_in.blank?
+    def check_required_fields_based_on_phase
+      return if dynamic_field.blank? || value.present?
+      return unless field_required_in_current_phase?
+
+      errors.add(:value, I18n.t("guest_dynamic_field.errors.#{dynamic_field.data_fill_stage}_required"))
     end
 
-    def during_check_in_required?
-      dynamic_field.data_fill_stage.to_sym == :during_check_in &&
-        guest.check_in.present?
+    def sync_guest_data_fill_stage_phase
+      guest&.save_and_move_to_next_stage
     end
 
-    def check_required_fields_based_on_phase
-      return if dynamic_field.blank? || value.present?
+    def reject_empty_string_for_text_fields
+      return if dynamic_field.blank?
+      return unless %w[text textarea].include?(dynamic_field.data_type.to_s)
+      return unless value.is_a?(String)
 
-      case dynamic_field.data_fill_stage.to_sym
-      when :pre_registration
-        errors.add(:value, I18n.t('guest_dynamic_field.errors.pre_registration_required')) if pre_registration_required?
-      when :post_registration
-        errors.add(:value, I18n.t('guest_dynamic_field.errors.post_registration_required')) if post_registration_required?
-      when :during_check_in
-        errors.add(:value, I18n.t('guest_dynamic_field.errors.during_check_in_required')) if during_check_in_required?
-      end
+      errors.add(:value, "can't be blank") if value.strip == ''
     end
   end
 end