spree_cm_commissioner 2.9.3.pre.pre1 → 2.9.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0cde283f01b472fecef2447fa4f2ecfbd2e89126a5c0100f6eb0da02d8470a81
-  data.tar.gz: 115e564d261168faef7c209fc743b7f57ef2914afbfaac75de7668d1d1579865
+  metadata.gz: 8b5fced09e0795a88c5dfc1cd5ef84584dc557c0c8f0c26f0c1ed8f0c62f5b9a
+  data.tar.gz: 612e81f2f3b4f7e15e6481c9910523fabc9fed36c9b8b265c83bd9fa1834b826
 SHA512:
-  metadata.gz: 61475e20da1c597866e2a2bf80d05ec60cbb5b26082c8103f002abde91d129738eb7d483c0955d66c0b1045d689ac4f68430888905ef638ddea162cf48d847b8
-  data.tar.gz: 659074571ef7ae8f01b2fe5737a4f569edb7986bd7d33bbb6e99342956bc211c6d0c85894feb5e4511557b22670711874d8316bcdc5f9deac5ffc63d446bc1c6
+  metadata.gz: 460533fe4a445145c9edd9e4c0fa1c9fa4c4fc6153105f0dea7e9cf2e873e423e6f967ba734931b5206a9309706a40d92c0a0a13b93d3c59bc57d65fc8be023f
+  data.tar.gz: 5f11f494bc107000bd15cf51a6ba29f43c64436f8803257f793488fce84f8d4549c15057f2c5b169460cc601a9fd5cea86bf5ec044999467fe013f9a5c6e5778

data/Gemfile.lock

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

data/app/controllers/concerns/spree_cm_commissioner/load_test_account_scope.rb

@@ -10,37 +10,30 @@ module SpreeCmCommissioner
       raise NotImplementedError, "#{self.class} must implement #load_test_tenant"
     end
 
-    # Scan cap for the tenant-scoped candidate set below — bounds the query while still comfortably
-    # covering realistic load-test pool sizes.
-    EXPORT_SCAN_LIMIT = 2000
-
-    DEFAULT_EXPORT_PER_PAGE = 20
+    DEFAULT_EXPORT_PER_PAGE = 10
 
     # Queried fresh from the DB every time, so it's always in sync with the current pool rather than
     # a stashed file or session state.
     #
-    # `load_test_account` lives in the `private_metadata` jsonb store (see UserDecorator's
-    # `store_private_metadata`), not a real column, so it can't be filtered in SQL directly —
-    # `store ..., coder: JSON` on top of an already-jsonb column double-encodes the value as a JSON
-    # string scalar rather than a native object, which breaks Postgres's `@>`/`->>` jsonb operators.
-    # Filter with the model's own `load_test_account?` in Ruby instead, which deserializes it
-    # correctly regardless of that storage quirk.
+    # Filters the `load_test_account` flag in SQL via the model's `load_test_accounts` scope (see
+    # UserDecorator), so only the tenant's load-test accounts are considered — never the whole users
+    # table. Unlike the old `order(:id).limit(2000).select(&:...)` approach, there's no scan cap:
+    # newly created accounts (highest ids, ordered first below) always show up even on tenants with
+    # far more than 2,000 users.
     #
-    # Filtering happens in Ruby, so this is a plain Array by the time it needs paging — wrap it
-    # with Kaminari.paginate_array (same pattern as VoteLogsController) to get the same
-    # `page`/`per_page` params and `paginate` view helper every other index page in this app uses,
-    # instead of hand-rolled pagination just for this one page.
+    # Kaminari pages on the relation itself, so the DB only ever loads the current page's rows
+    # (`LIMIT`/`OFFSET`) — never the full pool into memory — via the same `page`/`per_page` params
+    # and `paginate` view helper every other index page in this app uses.
     #
     # Shared between LoadTestAccountManagement (lists/mutates the pool) and
     # LoadTestLoginTokenGeneration (mints tokens for exactly the page shown), so both controllers
     # resolve the same page the same way.
     def export_accounts
-      matches = Spree::User.where(tenant_id: load_test_tenant&.id)
-                           .order(:id)
-                           .limit(EXPORT_SCAN_LIMIT)
-                           .select(&:load_test_account?)
-
-      Kaminari.paginate_array(matches).page(params[:page]).per(params[:per_page] || DEFAULT_EXPORT_PER_PAGE)
+      Spree::User.where(tenant_id: load_test_tenant&.id)
+                 .load_test_accounts
+                 .order(id: :desc)
+                 .page(params[:page])
+                 .per(params[:per_page] || DEFAULT_EXPORT_PER_PAGE)
     end
   end
 end

data/app/controllers/concerns/spree_cm_commissioner/load_test_bypassable.rb

@@ -0,0 +1,29 @@
+module SpreeCmCommissioner
+  # Sets Current.load_test_bypass when the request carries the correct X-Request-Verify secret, so
+  # anti-abuse services (e.g. InventoryHolds::ValidateLimits) can skip their checks for trusted
+  # load tests. No-op unless LOAD_TEST_BYPASS_KEY is set. Include in any controller that can
+  # trigger such a check.
+  module LoadTestBypassable
+    extend ActiveSupport::Concern
+
+    included do
+      before_action :set_load_test_bypass_current
+    end
+
+    private
+
+    # Always assigns the flag (false unless the request carries the correct
+    # secret), so its value never leaks from a previous request.
+    def set_load_test_bypass_current
+      SpreeCmCommissioner::Current.load_test_bypass = load_test_bypass_requested?
+    end
+
+    def load_test_bypass_requested?
+      key = ENV.fetch('LOAD_TEST_BYPASS_KEY', nil)
+      return false if key.blank?
+
+      provided = request.headers.fetch('X-Request-Verify', nil).to_s
+      ActiveSupport::SecurityUtils.secure_compare(provided, key)
+    end
+  end
+end

data/app/controllers/concerns/spree_cm_commissioner/turnstile_protectable.rb

@@ -27,13 +27,15 @@ module SpreeCmCommissioner
       return unless result.failure?
 
       render json: {
-        errors: [{
-          status: '403',
-          error_code: 'human_verification_failed',
-          title: I18n.t('turnstile.verification_failed'),
-          detail: result.message
-        }
-]
+        errors: [
+          {
+            status: '403',
+            error_code: 'human_verification_failed',
+            title: I18n.t('turnstile.verification_failed'),
+            detail: result.message,
+            turnstile_error_code: result.respond_to?(:error_code) ? result.error_code : nil
+          }
+        ]
       }, status: :forbidden
     end
 

data/app/controllers/spree/api/chatrace/guests_controller.rb

@@ -53,7 +53,7 @@ module Spree
           preferences upload_later social_contact_platform user_id
           bib_number bib_prefix bib_index public_metadata private_metadata
           seat_number intel_phone_number block_id saved_guest_id
-          data_fill_stage_phase
+          data_fill_stage
         ].freeze
 
         def guest_base_columns

data/app/controllers/spree/api/v2/operator/event_charts_controller.rb

@@ -36,6 +36,7 @@ module Spree
             SpreeCmCommissioner::EventChartQueries.new(
               taxon_id: params[:taxon_id],
               chart_type: params[:id] || 'participation',
+              check_in_session_id: params[:check_in_session_id],
               refreshed: params[:refreshed] || false
             )
           end

data/app/controllers/spree/api/v2/operator/guest_json_gzips_controller.rb

@@ -26,6 +26,8 @@ module Spree
 
             result = SpreeCmCommissioner::OperatorGuestJsonGzips::Create.call(
               exportable: exportable,
+              # Scope the offline file to the requesting operator's check-in role (nil = unrestricted).
+              role: spree_current_user.check_in_role_for(exportable),
               force_create: false,
               options: {
                 created_by_id: spree_current_user.id.to_s,
@@ -53,11 +55,19 @@ module Spree
           end
 
           # override
+          # Scope the list to the requesting operator's check-in group, the same way the create cache
+          # does — otherwise a restricted crew could list (and download via exported_file_url) other
+          # groups' files for the event.
           def scope
-            SpreeCmCommissioner::Exports::OperatorGuestJsonGzip.where(
-              exportable_type: 'Spree::Taxon',
-              exportable_id: params[:taxon_id]
-            ).order(created_at: :desc)
+            exportable = Spree::Taxon.find(params[:taxon_id])
+
+            SpreeCmCommissioner::Exports::OperatorGuestJsonGzip
+              .where(
+                exportable_type: 'Spree::Taxon',
+                exportable_id: params[:taxon_id],
+                role_id: spree_current_user.check_in_role_for(exportable)&.id
+              )
+              .order(created_at: :desc)
           end
 
           # override

data/app/controllers/spree/api/v2/storefront/account/guest_dynamic_fields_controller.rb

@@ -4,69 +4,40 @@ module Spree
       module Storefront
         module Account
           class GuestDynamicFieldsController < ::Spree::Api::V2::ResourceController
+            ALLOWED_PHASES = %w[pre_registration post_registration].freeze
+
             before_action :require_spree_current_user
             before_action :load_guest
 
             def update_dynamic_field
-              phase = params[:phase]
-
-              return render_error_payload('Invalid phase', 422) unless %w[pre_registration post_registration].include?(phase)
-
-              begin
-                fields = dynamic_fields_params
-              rescue ActionController::ParameterMissing
-                return render_error_payload('No dynamic fields provided', 422)
-              end
-
-              return render_error_payload('No dynamic fields provided', 422) if fields.blank?
-
-              ActiveRecord::Base.transaction do
-                fields.each do |field|
-                  process_dynamic_field(field)
-                end
-
-                @guest.save_and_move_to_next_stage
+              return render_error_payload('Invalid phase') unless ALLOWED_PHASES.include?(params[:phase])
+              return render_error_payload('No dynamic fields provided') if dynamic_fields_params.blank?
+
+              result = SpreeCmCommissioner::Guests::Update.call(
+                guest: @guest,
+                guest_params: {
+                  guest_dynamic_fields_attributes: dynamic_fields_params.map { |f| { dynamic_field_id: f[:id], value: f[:value] } }
+                }
+              )
+
+              if result.success?
+                render_serialized_payload { serialize_guest(result.value[:guest]) }
+              else
+                render_error_payload(result.error)
               end
-
-              render_serialized_payload { serialize_guest(@guest) }
-            rescue ActiveRecord::RecordInvalid => e
-              render_error_payload(e.record.errors, 422)
-            rescue ActiveRecord::RecordNotFound => e
-              render_error_payload(e.message, 404)
             end
 
             private
 
             def dynamic_fields_params
-              params.require(:dynamic_fields).map do |field|
-                field.permit(:id, :value)
-              end
+              Array(params[:dynamic_fields]).map { |field| field.permit(:id, :value) }
             end
 
             def load_guest
               @guest = SpreeCmCommissioner::Guest.find(params[:guest_id])
 
-              unless spree_current_user.guests.exists?(id: @guest.id) ||
-                  @guest.line_item.order.user == spree_current_user
-                render_error_payload('Unauthorized', 401)
-              end
-            end
-
-            def process_dynamic_field(field)
-              dynamic_field = SpreeCmCommissioner::DynamicField.find(field[:id])
-              guest_field = @guest.guest_dynamic_fields.build(dynamic_field_id: dynamic_field.id)
-
-              if dynamic_field.requires_dynamic_field_options?
-                option = dynamic_field.dynamic_field_options.find_by(value: field[:value])
-                raise ActiveRecord::RecordNotFound, "Invalid value for dynamic field #{dynamic_field.label}" unless option
-
-                guest_field.dynamic_field_option = option
-                guest_field.value = option.value
-              else
-                guest_field.value = field[:value]
-              end
-
-              guest_field.save!
+              raise CanCan::AccessDenied unless spree_current_user.guests.exists?(id: @guest.id) ||
+                @guest.line_item.order.user == spree_current_user
             end
 
             def serialize_guest(guest)

data/app/controllers/spree/api/v2/storefront/account/mark_guest_info_complete_controller.rb

@@ -7,7 +7,7 @@ module Spree
             before_action :require_spree_current_user
 
             def update
-              SpreeCmCommissioner::Users::IncompleteGuestCheckerService.new(spree_current_user).call
+              spree_current_user.clear_has_incomplete_guest_info_cache
               render_success
             end
 
@@ -18,7 +18,7 @@ module Spree
                 {
                   success: true,
                   message: 'Guest information marked as complete',
-                  has_incomplete_guest_info: false
+                  has_incomplete_guest_info: spree_current_user.has_incomplete_guest_info?
                 }
               end
             end

data/app/controllers/spree/api/v2/storefront/account/orders_controller_decorator.rb

@@ -24,21 +24,11 @@ module Spree
             private
 
             def find_orders_with_incomplete_guest_info
-              orders = spree_current_user.orders
-                                         .complete
-                                         .includes(line_items: { guests: [:guest_dynamic_fields] })
-
-              incomplete_order_ids = orders.select do |order|
-                order.line_items.any? do |line_item|
-                  line_item.guests.any? do |guest|
-                    guest.pre_registration_completed? &&
-                      guest.post_registration_fields? &&
-                      !guest.post_registration_completed?
-                  end
-                end
-              end.map(&:id)
-
-              spree_current_user.orders.where(id: incomplete_order_ids)
+              spree_current_user.orders
+                                .complete
+                                .joins(:guests)
+                                .merge(SpreeCmCommissioner::Guest.post_registration)
+                                .distinct
             end
 
             def collection_finder

data/app/controllers/spree/api/v2/storefront/account/saved_guests_controller.rb

@@ -0,0 +1,65 @@
+module Spree
+  module Api
+    module V2
+      module Storefront
+        module Account
+          class SavedGuestsController < ::Spree::Api::V2::ResourceController
+            before_action :require_spree_current_user
+            before_action :load_saved_guest, only: %i[show update destroy]
+
+            def collection
+              spree_current_user.saved_guests.order(created_at: :desc)
+                                .page(params[:page])
+                                .per(params[:per_page])
+            end
+
+            def create
+              saved_guest = spree_current_user.saved_guests.new(saved_guest_params)
+
+              if saved_guest.save
+                render_serialized_payload(201) { serialize_resource(saved_guest) }
+              else
+                render_error_payload(saved_guest.errors.full_messages.to_sentence, 422)
+              end
+            end
+
+            def update
+              if @saved_guest.update(saved_guest_params)
+                render_serialized_payload { serialize_resource(@saved_guest) }
+              else
+                render_error_payload(@saved_guest.errors.full_messages.to_sentence, 422)
+              end
+            end
+
+            def destroy
+              @saved_guest.destroy
+              head :no_content
+            end
+
+            private
+
+            def model_class
+              SpreeCmCommissioner::SavedGuest
+            end
+
+            def collection_serializer
+              resource_serializer
+            end
+
+            def resource_serializer
+              SpreeCmCommissioner::V2::Storefront::SavedGuestSerializer
+            end
+
+            def load_saved_guest
+              @saved_guest = spree_current_user.saved_guests.find(params[:id])
+            end
+
+            def saved_guest_params
+              params.require(:saved_guest).permit(*::Spree::PermittedAttributes.saved_guest_attributes)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/spree/api/v2/storefront/account_checker_controller.rb

@@ -3,6 +3,10 @@ module Spree
     module V2
       module Storefront
         class AccountCheckerController < Spree::Api::V2::BaseController
+          include SpreeCmCommissioner::TurnstileProtectable
+
+          before_action :verify_turnstile!, only: :index
+
           def index
             checker = SpreeCmCommissioner::ExistingAccountChecker.call(filter_params.to_h)
 

data/app/controllers/spree/api/v2/storefront/draft_orders_controller.rb

@@ -3,6 +3,9 @@ module Spree
     module V2
       module Storefront
         class DraftOrdersController < ::Spree::Api::V2::ResourceController
+          # Creating the order acquires the inventory hold, so honor the load-test bypass here too.
+          include SpreeCmCommissioner::LoadTestBypassable
+
           # Creates a generic draft order from a locally-assembled cart in a single request.
           # Endpoint: POST /api/v2/storefront/draft_orders
           # Params:

data/app/controllers/spree/api/v2/storefront/guests_controller.rb

@@ -31,26 +31,27 @@ module Spree
           def create
             spree_authorize! :update, spree_current_order, order_token
 
-            result = SpreeCmCommissioner::Cart::CreateGuest.call(
+            result = SpreeCmCommissioner::Guests::Create.call(
               line_item: parent,
-              options: guest_params
+              guest_params: guest_params
             )
 
             if result.success?
-              render_serialized_payload(201) { serialize_resource(result.value) }
+              render_serialized_payload(201) { serialize_resource(result.value[:guest]) }
             else
-              render_error_payload(result.value.errors, 422)
+              render_error_payload(result.error || result.value.errors, 422)
             end
           end
 
           def update
             spree_authorize! :update, spree_current_order, order_token unless guest_for_update.pre_registration?
 
-            begin
-              SpreeCmCommissioner::UpdateGuestService.new(guest_for_update, guest_params).call
-              render_serialized_payload { serialize_resource(guest_for_update) }
-            rescue ActiveRecord::RecordInvalid => e
-              render_error_payload(e.record.errors, 422)
+            result = SpreeCmCommissioner::Guests::Update.call(guest: guest_for_update, guest_params: guest_params)
+
+            if result.success?
+              render_serialized_payload { serialize_resource(result.value[:guest]) }
+            else
+              render_error_payload(result.error || result.value&.errors, 422)
             end
           end
 

data/app/controllers/spree/api/v2/storefront/order_histories_controller.rb

@@ -18,7 +18,6 @@ module Spree
             order = Spree::Order.not_archived.find_by!(token: order_token)
 
             spree_authorize! :update, order, order_token
-            raise CanCan::AccessDenied unless order.payment?
 
             if order.mark_as_archive
               render_serialized_payload { serialize_resource(order) }

data/app/controllers/spree/api/v2/tenant/account/orders_controller.rb

@@ -26,7 +26,7 @@ module Spree
             end
 
             def scope
-              spree_current_user.orders.complete
+              spree_current_user.orders.complete.exclude_vote_package
             end
 
             def collection_serializer

data/app/controllers/spree/api/v2/tenant/account/saved_guests_controller.rb

@@ -0,0 +1,70 @@
+module Spree
+  module Api
+    module V2
+      module Tenant
+        module Account
+          class SavedGuestsController < BaseController
+            around_action :wrap_with_multitenant_without
+            before_action :require_spree_current_user
+            before_action :load_saved_guest, only: %i[show update destroy]
+
+            def collection
+              spree_current_user.saved_guests.order(created_at: :desc)
+                                .page(params[:page])
+                                .per(params[:per_page])
+            end
+
+            def create
+              saved_guest = spree_current_user.saved_guests.new(saved_guest_params)
+
+              if saved_guest.save
+                render_serialized_payload(201) { serialize_resource(saved_guest) }
+              else
+                render_error_payload(saved_guest.errors.full_messages.to_sentence, 422)
+              end
+            end
+
+            def update
+              if @saved_guest.update(saved_guest_params)
+                render_serialized_payload { serialize_resource(@saved_guest) }
+              else
+                render_error_payload(@saved_guest.errors.full_messages.to_sentence, 422)
+              end
+            end
+
+            def destroy
+              @saved_guest.destroy
+              head :no_content
+            end
+
+            private
+
+            def wrap_with_multitenant_without(&block)
+              MultiTenant.without(&block)
+            end
+
+            def model_class
+              SpreeCmCommissioner::SavedGuest
+            end
+
+            def collection_serializer
+              resource_serializer
+            end
+
+            def resource_serializer
+              Spree::V2::Tenant::SavedGuestSerializer
+            end
+
+            def load_saved_guest
+              @saved_guest = spree_current_user.saved_guests.find(params[:id])
+            end
+
+            def saved_guest_params
+              params.require(:saved_guest).permit(*::Spree::PermittedAttributes.saved_guest_attributes)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/spree/api/v2/tenant/guests_controller.rb

@@ -30,28 +30,25 @@ module Spree
           def create
             spree_authorize! :update, spree_current_order, order_token
 
-            resource = scope.new(guest_params.except(:guest_dynamic_fields_attributes))
+            result = SpreeCmCommissioner::Guests::Create.call(line_item: parent, guest_params: guest_params)
 
-            ActiveRecord::Base.transaction do
-              resource.save!
-              run_dynamic_fields(resource)
-              resource.save_and_move_to_next_stage
+            if result.success?
+              render_serialized_payload(201) { serialize_resource(result.value[:guest]) }
+            else
+              render_error_payload(result.error || result.value&.errors, 422)
             end
-
-            render_serialized_payload(201) { serialize_resource(resource) }
           end
 
           def update
             spree_authorize! :update, spree_current_order, order_token
 
-            ActiveRecord::Base.transaction do
-              run_dynamic_fields(resource) if guest_params[:guest_dynamic_fields_attributes]
-              resource.assign_attributes(guest_params.except(:guest_dynamic_fields_attributes))
-              resource.save!
-              resource.save_and_move_to_next_stage
-            end
+            result = SpreeCmCommissioner::Guests::Update.call(guest: resource, guest_params: guest_params)
 
-            render_serialized_payload { serialize_resource(resource) }
+            if result.success?
+              render_serialized_payload { serialize_resource(result.value[:guest]) }
+            else
+              render_error_payload(result.error || result.value&.errors, 422)
+            end
           end
 
           private
@@ -99,13 +96,6 @@ module Spree
             )
           end
 
-          def run_dynamic_fields(resource)
-            SpreeCmCommissioner::GuestDynamicFieldsManager.call(
-              resource: resource,
-              dynamic_fields_attributes: guest_params[:guest_dynamic_fields_attributes]
-            )
-          end
-
           def handle_record_invalid(exception)
             render_error_payload(exception.record.errors, 422)
           end

data/app/controllers/spree/api/v2/tenant/my_votes_controller.rb

@@ -0,0 +1,51 @@
+module Spree
+  module Api
+    module V2
+      module Tenant
+        # Returns the session's contestants each annotated with the current
+        # user's own vote tally (my_vote_count).
+        #
+        # Kept separate from the public VotingContestantsController — that
+        # endpoint does not require an authenticated user and is cacheable,
+        # whereas this one is strictly per-user and must never be cached.
+        class MyVotesController < BaseController
+          before_action :require_spree_current_user
+          before_action :load_voting_session
+
+          def show
+            render_serialized_payload do
+              serialize_collection(collection)
+            end
+          end
+
+          private
+
+          def collection
+            @collection ||= SpreeCmCommissioner::UserVotesPerContestantQuery.new(
+              user: spree_current_user,
+              voting_session: @voting_session
+            ).contestants
+          end
+
+          def load_voting_session
+            @voting_session = current_vendor.voting_sessions.find(params[:voting_session_id])
+          end
+
+          # Overrided: skip collection_options (pagination/links) — this is a
+          # bounded per-session collection, not a paginated one.
+          def serialize_collection(collection)
+            collection_serializer.new(collection).serializable_hash
+          end
+
+          def collection_serializer
+            Spree::V2::Tenant::MyVoteSerializer
+          end
+
+          def model_class
+            SpreeCmCommissioner::VotingContestant
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/spree/api/v2/tenant/order_histories_controller.rb

@@ -21,7 +21,6 @@ module Spree
             order = Spree::Order.not_archived.find_by!(token: order_token)
 
             spree_authorize! :update, order, order_token
-            raise CanCan::AccessDenied unless order.payment?
 
             if order.mark_as_archive
               render_serialized_payload { serialize_resource(order) }