spree_cm_commissioner 2.5.13 → 2.5.14.pre.pre1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3e4173db9eaef31ba44153b210477bd83e359559c6b007f644723d320e9e8f30
-  data.tar.gz: 38aba375ecb1177922443efbe00c09e923c75f3f2547c3df5cb383378e45a8b8
+  metadata.gz: 629ae666350f41be96fbbffc7fca9d392eac8719b6e3de8bdc59d078aca7bc19
+  data.tar.gz: c8c92dbab08ee3019c49cc1ca3d13ec85eee50e85e0197bc05da6654f2bd2a90
 SHA512:
-  metadata.gz: 698f5ca602839ec3b8293cd2aecf31a1cc89d6125c16b831a8500ec0aa8c01d705bf15bc215dde6cd50de568c3d505803cf97ad4c4c6a4493f7018f7b535dde1
-  data.tar.gz: ef9ffdee2d499c102c1f8e2c7166d3ed0d3ccea24f9f6259d74555f4cdc8f7646b9e97ae373710f1412cf256f510e0296259e44fa5d693a19d927b9eecf51396
+  metadata.gz: 91f9dfb5083aedf8e8d939962bcb190c78c5d7601352a947ddba56dfd18693ef21061a781137f45ec613445889113461f8739dbc5b660935c865a38186e1bdea
+  data.tar.gz: 5634021b1f30d8473163aed1dcc78346fb82cebb0f3bdcb469e420755a66c3d0fc62790c393063e5b5d78ce8be3401118fe41ba1e4e3a7cd3887cc5747741712

data/Gemfile.lock

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

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

@@ -7,9 +7,10 @@ module Spree
         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
+            maintainable_id: @taxon.parent.id
+          ) do |task|
+            task.manually_triggered = true
+          end.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::CreateOrderService.new(
+        SpreeCmCommissioner::Imports::Orders::Create.new(
           import_order_id: options[:import_order_id],
           import_by_user_id: options[:import_by_user_id]
         ).call
       else
-        SpreeCmCommissioner::Imports::UpdateOrderService.new(
+        SpreeCmCommissioner::Imports::Orders::Update.new(
           import_order_id: options[:import_order_id]
         ).call
       end

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

@@ -33,7 +33,8 @@ module SpreeCmCommissioner
         output_gz_file = Tempfile.new(['export', '.json.gz'])
 
         begin
-          stream_export_data_and_includes_to_separate_files(guests_query, guests_file, included_file)
+          total_processed = stream_export_data_and_includes_to_separate_files(guests_query, guests_file, included_file)
+          self.guests_count = total_processed
           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
@@ -98,6 +99,8 @@ 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/imports/orders/base.rb

@@ -0,0 +1,70 @@
+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

@@ -0,0 +1,134 @@
+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

@@ -0,0 +1,77 @@
+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

data/lib/spree_cm_commissioner/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: spree_cm_commissioner
 version: !ruby/object:Gem::Version
-  version: 2.5.13
+  version: 2.5.14.pre.pre1
 platform: ruby
 authors:
 - You
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-02-18 00:00:00.000000000 Z
+date: 2026-02-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: spree
@@ -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/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/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/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
@@ -3215,9 +3215,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '2.7'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements:
 - none
 rubygems_version: 3.4.1

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

@@ -1,55 +0,0 @@
-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

@@ -1,99 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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