spree_cm_commissioner 2.5.14.pre.pre1 → 2.5.14.pre.pre2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 629ae666350f41be96fbbffc7fca9d392eac8719b6e3de8bdc59d078aca7bc19
-  data.tar.gz: c8c92dbab08ee3019c49cc1ca3d13ec85eee50e85e0197bc05da6654f2bd2a90
+  metadata.gz: 9fc822ca647b6847cc80bc5d4f24f68312c67c3cf772e8422801f29d36b8c871
+  data.tar.gz: ac27932993e5c366efcfe5d1f15491c7b0248a886f0d804af69545a28a6a83cd
 SHA512:
-  metadata.gz: 91f9dfb5083aedf8e8d939962bcb190c78c5d7601352a947ddba56dfd18693ef21061a781137f45ec613445889113461f8739dbc5b660935c865a38186e1bdea
-  data.tar.gz: 5634021b1f30d8473163aed1dcc78346fb82cebb0f3bdcb469e420755a66c3d0fc62790c393063e5b5d78ce8be3401118fe41ba1e4e3a7cd3887cc5747741712
+  metadata.gz: 6030cee41764d55a73430c81849bc91b12dcf12c04097795c3646297e75c53b3206ca186a704a6603eddcb6a57e4226d437e25227bf6a005fe514ea784891d26
+  data.tar.gz: d48e1f3ec06affa85260babeea658b9a9cb95ddffffe01175fa9dd24837df25c2a087fd5e4dbc3849ce2592178db9d71793719c21e783ca425820b226f142862

data/Gemfile.lock

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

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

@@ -7,10 +7,9 @@ module Spree
         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
+            maintainable_id: @taxon.parent.id,
+            manually_triggered: true
+          ).async_execute
 
           flash[:success] = flash_message_for(@taxon, :successfully_updated)
         else

data/app/jobs/spree_cm_commissioner/import_order_job.rb

@@ -2,12 +2,12 @@ module SpreeCmCommissioner
   class ImportOrderJob < ApplicationUniqueJob
     def perform(options = {})
       if options[:import_type] == 'new_order'
-        SpreeCmCommissioner::Imports::Orders::Create.new(
+        SpreeCmCommissioner::Imports::CreateOrderService.new(
           import_order_id: options[:import_order_id],
           import_by_user_id: options[:import_by_user_id]
         ).call
       else
-        SpreeCmCommissioner::Imports::Orders::Update.new(
+        SpreeCmCommissioner::Imports::UpdateOrderService.new(
           import_order_id: options[:import_order_id]
         ).call
       end

data/app/models/spree_cm_commissioner/exports/operator_guest_json_gzip.rb

@@ -33,8 +33,7 @@ module SpreeCmCommissioner
         output_gz_file = Tempfile.new(['export', '.json.gz'])
 
         begin
-          total_processed = stream_export_data_and_includes_to_separate_files(guests_query, guests_file, included_file)
-          self.guests_count = total_processed
+          stream_export_data_and_includes_to_separate_files(guests_query, guests_file, included_file)
           stream_export_merge_and_compress_data_and_includes_to_a_single_file(guests_file, included_file, output_gz_file)
           attach_file_to_record(output_gz_file)
         ensure
@@ -99,8 +98,6 @@ module SpreeCmCommissioner
             update(track_processed_messages: track_processed_messages.last(50))
           end
         end
-
-        total_processed_guests
       end
 
       def stream_export_merge_and_compress_data_and_includes_to_a_single_file(guests_file, included_file, output_gz_file)

data/app/services/spree_cm_commissioner/check_ins/create_bulk.rb

@@ -8,12 +8,23 @@ module SpreeCmCommissioner
 
         confirmed_at ||= Time.current
         guest_ids = check_ins_attributes.pluck(:guest_id)
-        indexed_guests = SpreeCmCommissioner::Guest.where(id: guest_ids).index_by(&:id)
+
+        indexed_guests = SpreeCmCommissioner::Guest
+                         .includes(:event, line_item: :order)
+                         .where(id: guest_ids)
+                         .index_by(&:id)
 
         check_ins = ActiveRecord::Base.transaction do
           check_ins_attributes.map do |attrs|
             guest = indexed_guests[attrs[:guest_id].to_i]
-            raise ActiveRecord::RecordNotFound, "Couldn't find Guest with 'id'=#{attrs[:guest_id]}" if guest.blank?
+            raise ActiveRecord::RecordNotFound, "Couldn't find Guest to check in" if guest.blank?
+
+            order = guest.line_item.order
+            if order.canceled?
+              error = ActiveRecord::RecordInvalid.new(guest)
+              error.record.errors.add(:base, 'Cannot check in Guest from cancelled order')
+              raise error
+            end
 
             check_in = check_in!(guest, attrs, check_in_by, confirmed_at)
             update_guest!(guest, attrs[:guest_attributes]) if attrs[:guest_attributes].present?
@@ -25,8 +36,8 @@ module SpreeCmCommissioner
         success(check_ins: check_ins)
       rescue ActiveRecord::RecordInvalid => e
         failure(:invalid_record, e.record.errors.full_messages.join(', '))
-      rescue ActiveRecord::RecordNotFound => e
-        failure(:record_not_found, e.message)
+      rescue ActiveRecord::RecordNotFound
+        failure(:record_not_found, 'Guest or related record not found')
       end
 
       private

data/app/services/spree_cm_commissioner/imports/base_import_order_service.rb

@@ -0,0 +1,55 @@
+module SpreeCmCommissioner
+  module Imports
+    class BaseImportOrderService
+      attr_reader :import_order_id, :fail_row_numbers
+
+      def initialize(import_order_id:)
+        @import_order_id = import_order_id
+        @fail_row_numbers = []
+      end
+
+      def call
+        update_import_status_when_start(:progress)
+        import_orders
+        save_fail_rows
+        update_import_status_when_finish(:done)
+      rescue StandardError => e
+        update_import_status_when_finish(:failed)
+        raise e
+      end
+
+      def save_fail_rows
+        import_order.update!(preferred_fail_rows: @fail_row_numbers.join(', ')) unless @fail_row_numbers.empty?
+      end
+
+      def record_failure(row_number)
+        @fail_row_numbers << row_number
+      end
+
+      def import_order
+        @import_order ||= SpreeCmCommissioner::Imports::ImportOrder.find(import_order_id)
+      end
+
+      def update_import_status_when_start(status)
+        import_order.update(status: status, started_at: Time.zone.now)
+      end
+
+      def update_import_status_when_finish(status)
+        import_order.update(status: status, finished_at: Time.zone.now)
+      end
+
+      def fetch_content
+        url = import_order.imported_file.url
+        response = Faraday.get(url)
+
+        raise "Failed to fetch content: #{response.status}" unless response.success?
+
+        response.body
+      end
+
+      def cleaned_value(value)
+        value.to_s.gsub(/\s+/, '')
+      end
+    end
+  end
+end

data/app/services/spree_cm_commissioner/imports/create_order_service.rb

@@ -0,0 +1,99 @@
+module SpreeCmCommissioner
+  module Imports
+    class CreateOrderService < BaseImportOrderService
+      attr_reader :import_by_user_id
+
+      def initialize(import_order_id:, import_by_user_id:)
+        super(import_order_id: import_order_id)
+        @import_by_user_id = import_by_user_id
+      end
+
+      def import_orders
+        content = fetch_content
+
+        CSV.parse(content, headers: true).each.with_index(2) do |row, index|
+          order_data = row.to_hash.symbolize_keys
+          process_order(order_data, index)
+        end
+      end
+
+      def process_order(order_data, index)
+        ActiveRecord::Base.transaction do
+          params = build_order_params(order_data)
+          order = create_order(params, index)
+          record_failure(index) if order && !complete_order(order)
+        end
+      rescue StandardError
+        record_failure(index)
+      end
+
+      private
+
+      def build_order_params(order_data)
+        guest_attributes = order_data.slice(*SpreeCmCommissioner::Guest.csv_importable_columns)
+        if order_data[:variant_id].present?
+          {
+            channel: construct_channel('google_form'),
+            email: order_data[:email],
+            phone_number: order_data[:phone_number],
+            line_items_attributes: [
+              {
+                quantity: 1,
+                variant_id: order_data[:variant_id].to_i,
+                guests_attributes: Array.new(1, guest_attributes)
+              }
+            ]
+          }
+        else
+          {
+            channel: construct_channel(order_data[:order_channel]),
+            email: order_data[:email],
+            phone_number: order_data[:phone_number],
+            line_items_attributes: [
+              {
+                quantity: order_data[:quantity].to_i,
+                sku: order_data[:variant_sku],
+                guests_attributes: Array.new(order_data[:quantity].to_i, guest_attributes)
+              }
+            ]
+          }
+        end
+      end
+
+      def create_order(params, index)
+        order = Spree::Core::Importer::Order.import(import_by, params)
+        unless order
+          record_failure(index)
+          return nil
+        end
+
+        order
+      end
+
+      def complete_order(order)
+        # Wraps order completion and inventory update in a transaction to ensure atomicity.
+        # If either the order update or inventory update fails, both operations will be rolled back.
+        # This prevents partial updates that could lead to data inconsistency.
+        order.unstock_inventory! do
+          order.update!(
+            completed_at: Time.zone.now,
+            state: 'complete',
+            payment_total: order.total,
+            payment_state: 'paid'
+          )
+        end
+      rescue StandardError => e
+        AppLogger.error("#{self.class.name}::#complete_order failed for Order ID #{order.id}: #{e.message}")
+        false
+      end
+
+      def import_by
+        @import_by ||= Spree::User.find(import_by_user_id)
+      end
+
+      def construct_channel(order_channel)
+        "#{order_channel}-#{import_order.id}-#{import_order.slug}"
+      end
+    end
+  end
+end

data/app/services/spree_cm_commissioner/imports/update_order_service.rb

@@ -0,0 +1,41 @@
+module SpreeCmCommissioner
+  module Imports
+    class UpdateOrderService < BaseImportOrderService
+      def import_orders
+        content = fetch_content
+
+        CSV.parse(content, headers: true).each.with_index(2) do |row, index|
+          order_number = cleaned_value(row['order_number'])
+          order = Spree::Order.find_by(number: order_number)
+
+          unless order
+            record_failure(index)
+            next
+          end
+
+          guest_id = cleaned_value(row['guest_id'])
+          seat_number = cleaned_value(row['seat_number'])
+          guest = order.guests.find_by(seat_number: seat_number) || order.guests.find_by(id: guest_id)
+
+          unless guest
+            record_failure(index)
+            next
+          end
+
+          guest_data = row.to_hash.symbolize_keys.slice(*SpreeCmCommissioner::Guest.csv_importable_columns)
+          guest_data.compact_blank!
+
+          if guest.update(guest_data)
+            recalculate_order(order)
+          else
+            record_failure(index)
+          end
+        end
+      end
+
+      def recalculate_order(order)
+        order.update_with_updater!
+      end
+    end
+  end
+end

data/app/services/spree_cm_commissioner/organizer/export_guest_csv_service.rb

@@ -29,6 +29,8 @@ module SpreeCmCommissioner
       def fetch_value(guest, column)
         if guest_field?(column)
           fetch_guest_value(guest, column)
+        elsif dynamic_field?(column)
+          fetch_dynamic_field_value(guest, column)
         else
           fetch_option_value(guest, column)
         end
@@ -38,6 +40,39 @@ module SpreeCmCommissioner
         SpreeCmCommissioner::KycBitwise::ORDERED_BIT_FIELDS.include?(column.to_sym)
       end
 
+      def dynamic_field?(column)
+        return false unless dynamic_fields_exist?
+
+        dynamic_field_labels.include?(column)
+      end
+
+      def dynamic_field_labels
+        return [] unless dynamic_fields_exist?
+
+        @dynamic_field_labels ||= load_dynamic_field_labels
+      end
+
+      def dynamic_fields_exist?
+        return @has_dynamic_fields unless @has_dynamic_fields.nil?
+
+        @has_dynamic_fields = event.event_products.joins(:product_dynamic_fields).exists?
+      end
+
+      def load_dynamic_field_labels
+        event.event_products.joins(product_dynamic_fields: :dynamic_field).distinct.pluck('label')
+      end
+
+      def fetch_dynamic_field_value(guest, column)
+        guest_dynamic_field = guest.guest_dynamic_fields.find { |gdf| gdf.dynamic_field&.label == column }
+        return '' unless guest_dynamic_field
+
+        if guest_dynamic_field.dynamic_field_option.present?
+          guest_dynamic_field.dynamic_field_option.value
+        else
+          guest_dynamic_field.value || ''
+        end
+      end
+
       def fetch_guest_value(guest, column)
         column_mappings(guest)[column] || ''
       end
@@ -82,6 +117,7 @@ module SpreeCmCommissioner
           :occupation,
           :nationality,
           :id_card,
+          guest_dynamic_fields: %i[dynamic_field dynamic_field_option],
           line_item: { variant: { option_values: :option_type } }
         ).complete
         scope = scope.where('cm_guests.created_at >= ?', formatted_date_time(filters[:from_date])) if filters[:from_date].present?

data/lib/spree_cm_commissioner/version.rb

@@ -1,5 +1,5 @@
 module SpreeCmCommissioner
-  VERSION = '2.5.14-pre1'.freeze
+  VERSION = '2.5.14.pre.pre2'.freeze
 
   module_function
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: spree_cm_commissioner
 version: !ruby/object:Gem::Version
-  version: 2.5.14.pre.pre1
+  version: 2.5.14.pre.pre2
 platform: ruby
 authors:
 - You
@@ -2032,9 +2032,9 @@ files:
 - app/services/spree_cm_commissioner/guests/preload_check_in_session_ids.rb
 - app/services/spree_cm_commissioner/homepage_data.rb
 - app/services/spree_cm_commissioner/homepage_data_loader.rb
-- app/services/spree_cm_commissioner/imports/orders/base.rb
-- app/services/spree_cm_commissioner/imports/orders/create.rb
-- app/services/spree_cm_commissioner/imports/orders/update.rb
+- app/services/spree_cm_commissioner/imports/base_import_order_service.rb
+- app/services/spree_cm_commissioner/imports/create_order_service.rb
+- app/services/spree_cm_commissioner/imports/update_order_service.rb
 - app/services/spree_cm_commissioner/integrations/base/sync_manager.rb
 - app/services/spree_cm_commissioner/integrations/base/sync_result.rb
 - app/services/spree_cm_commissioner/integrations/cleanup_sync_sessions.rb

data/app/services/spree_cm_commissioner/imports/orders/base.rb

@@ -1,70 +0,0 @@
-require 'tempfile'
-
-module SpreeCmCommissioner
-  module Imports
-    module Orders
-      class Base
-        attr_reader :import_order_id, :fail_row_numbers
-
-        def initialize(import_order_id:)
-          @import_order_id = import_order_id
-          @fail_row_numbers = []
-        end
-
-        def call
-          update_import_status_when_start(:progress)
-          import_orders
-          save_fail_rows
-          update_import_status_when_finish(:done)
-        rescue StandardError => e
-          update_import_status_when_finish(:failed)
-          raise e
-        end
-
-        def save_fail_rows
-          import_order.update!(preferred_fail_rows: @fail_row_numbers.join(', ')) unless @fail_row_numbers.empty?
-        end
-
-        def record_failure(row_number)
-          @fail_row_numbers << row_number
-        end
-
-        def import_order
-          @import_order ||= SpreeCmCommissioner::Imports::ImportOrder.find(import_order_id)
-        end
-
-        def update_import_status_when_start(status)
-          import_order.update(status: status, started_at: Time.zone.now)
-        end
-
-        def update_import_status_when_finish(status)
-          import_order.update(status: status, finished_at: Time.zone.now)
-        end
-
-        def fetch_content
-          url = import_order.imported_file.url
-          temp_file = Tempfile.new(['import', '.csv'], binmode: true)
-
-          begin
-            response = Faraday.get(url) do |req|
-              req.options.on_data = proc { |chunk| temp_file.write(chunk) }
-            end
-
-            raise "HTTP request failed with status #{response.status}" unless response.success?
-
-            temp_file.close
-            temp_file.path
-          rescue StandardError
-            temp_file.close
-            temp_file.unlink
-            raise
-          end
-        end
-
-        def cleaned_value(value)
-          value.to_s.gsub(/\s+/, '')
-        end
-      end
-    end
-  end
-end

data/app/services/spree_cm_commissioner/imports/orders/create.rb

@@ -1,134 +0,0 @@
-require 'tempfile'
-
-module SpreeCmCommissioner
-  module Imports
-    module Orders
-      class Create < Base
-        BATCH_SIZE = 100
-
-        attr_reader :import_by_user_id
-
-        def initialize(import_order_id:, import_by_user_id:)
-          super(import_order_id: import_order_id)
-          @import_by_user_id = import_by_user_id
-        end
-
-        def import_orders
-          # Processes CSV orders in a memory-efficient streaming manner to handle large files (50k+ rows).
-          # Batches rows into groups of 100 for reduced DB transaction overhead and atomicity per batch.
-          # Uses CSV.foreach to stream from disk, avoiding memory spikes. Row indices start at 2 (post-header).
-          file_path = fetch_content
-          batch = []
-
-          begin
-            CSV.foreach(file_path, headers: true).with_index(2) do |row, index|
-              batch << [row.to_hash.symbolize_keys, index]
-
-              if batch.size >= BATCH_SIZE
-                process_batch(batch)
-                batch = []
-              end
-            end
-
-            process_batch(batch) unless batch.empty?
-          ensure
-            FileUtils.rm_f(file_path)
-          end
-        end
-
-        def process_batch(batch)
-          # Processes a batch of orders with each row in its own transaction for error isolation.
-          # Failures record but don't affect other rows, allowing partial batch success.
-          batch.each do |order_data, index|
-            ActiveRecord::Base.transaction do
-              process_order(order_data, index)
-            rescue StandardError => e
-              CmAppLogger.error(
-                label: "#{self.class.name}::process_batch",
-                data: { message: e.message, row: index }
-              )
-              record_failure(index)
-            end
-          end
-        end
-
-        def process_order(order_data, index)
-          params = build_order_params(order_data)
-          order  = create_order(params, index)
-          record_failure(index) if order && !complete_order(order)
-        end
-
-        private
-
-        def build_order_params(order_data)
-          guest_attributes = order_data.slice(*SpreeCmCommissioner::Guest.csv_importable_columns)
-          channel = construct_channel(
-            order_data[:variant_id].present? ? 'google_form' : order_data[:order_channel]
-          )
-
-          common_attrs = {
-            channel: channel,
-            email: order_data[:email],
-            phone_number: order_data[:phone_number]
-          }
-
-          line_item_attrs =
-            if order_data[:variant_id].present?
-              {
-                quantity: 1,
-                variant_id: order_data[:variant_id].to_i,
-                guests_attributes: Array.new(1, guest_attributes)
-              }
-            else
-              {
-                quantity: order_data[:quantity].to_i,
-                sku: order_data[:variant_sku],
-                guests_attributes: Array.new(order_data[:quantity].to_i, guest_attributes)
-              }
-            end
-
-          common_attrs.merge(line_items_attributes: [line_item_attrs])
-        end
-
-        def create_order(params, index)
-          order = Spree::Core::Importer::Order.import(import_by, params)
-
-          unless order
-            record_failure(index)
-            return nil
-          end
-
-          order
-        end
-
-        def complete_order(order)
-          # Wraps order completion and inventory update in a transaction to ensure atomicity.
-          # If either the order update or inventory update fails, both operations will be rolled back.
-          # This prevents partial updates that could lead to data inconsistency.
-          order.unstock_inventory! do
-            order.update!(
-              completed_at: Time.zone.now,
-              state: 'complete',
-              payment_total: order.total,
-              payment_state: 'paid'
-            )
-          end
-        rescue StandardError => e
-          CmAppLogger.error(
-            label: "#{self.class.name}::complete_order",
-            data: { message: e.message, order_id: order.id }
-          )
-          false
-        end
-
-        def import_by
-          @import_by ||= Spree::User.find(import_by_user_id)
-        end
-
-        def construct_channel(order_channel)
-          "#{order_channel}-#{import_order.id}-#{import_order.slug}"
-        end
-      end
-    end
-  end
-end

data/app/services/spree_cm_commissioner/imports/orders/update.rb

@@ -1,77 +0,0 @@
-module SpreeCmCommissioner
-  module Imports
-    module Orders
-      class Update < Base
-        BATCH_SIZE = 100
-
-        def import_orders
-          file_path = fetch_content
-          batch = []
-
-          begin
-            CSV.foreach(file_path, headers: true).with_index(2) do |row, index|
-              batch << [row, index]
-
-              if batch.size >= BATCH_SIZE
-                process_batch(batch)
-                batch = []
-              end
-            end
-
-            process_batch(batch) unless batch.empty?
-          ensure
-            FileUtils.rm_f(file_path)
-          end
-        end
-
-        def process_batch(batch)
-          batch.each do |row, index|
-            ActiveRecord::Base.transaction do
-              process_row(row, index)
-            rescue StandardError
-              record_failure(index)
-            end
-          end
-        end
-
-        def process_row(row, index)
-          order_number = cleaned_value(row['order_number'])
-          order = Spree::Order.find_by(number: order_number)
-
-          unless order
-            record_failure(index)
-            return
-          end
-
-          guest_id = cleaned_value(row['guest_id'])
-          seat_number = cleaned_value(row['seat_number'])
-
-          guest =
-            order.guests.find_by(seat_number: seat_number) ||
-            order.guests.find_by(id: guest_id)
-
-          unless guest
-            record_failure(index)
-            return
-          end
-
-          guest_data = row.to_hash
-                          .symbolize_keys
-                          .slice(*SpreeCmCommissioner::Guest.csv_importable_columns)
-
-          guest_data.compact_blank!
-
-          if guest.update(guest_data)
-            recalculate_order(order)
-          else
-            record_failure(index)
-          end
-        end
-
-        def recalculate_order(order)
-          order.update_with_updater!
-        end
-      end
-    end
-  end
-end