Auto Accept PR 2: Frontend & Waiting List Integration

app/controllers/api/v0/competitions_controller.rb

@@ -184,6 +184,14 @@ def update_wcif
     }
   end
 
+  def disable_auto_accept
+    competition = competition_from_params
+    require_can_manage!(competition)
+
+    competition.update!(auto_accept_registrations: false)
+    render json: { status: 'success' }
+  end
+
   private def competition_from_params(associations: {})
     id = params[:competition_id] || params[:id]
     competition = Competition.includes(associations).find_by_id(id)

app/controllers/api/v1/registrations/registrations_controller.rb

@@ -105,7 +105,6 @@ def list
   # To list Registrations in the admin view you need to be able to administer the competition
   def validate_list_admin
     competition_id = list_params
-    # TODO: Do we set this as an instance variable here so we can use it below?
     @competition = Competition.find(competition_id)
     unless @current_user.can_manage_competition?(@competition)
       render_error(:unauthorized, Registrations::ErrorCodes::USER_INSUFFICIENT_PERMISSIONS)

app/models/competition.rb

@@ -173,6 +173,8 @@ class Competition < ApplicationRecord
     event_change_deadline_date
     competition_series_id
     registration_version
+    auto_accept_registrations
+    auto_accept_disable_threshold
   ).freeze
   VALID_NAME_RE = /\A([-&.:' [:alnum:]]+) (\d{4})\z/
   VALID_ID_RE = /\A[a-zA-Z0-9]+\Z/
@@ -354,6 +356,25 @@ def advancement_condition_must_be_present_for_all_non_final_rounds
     end
   end
 
+  validate :auto_accept_validations
+  private def auto_accept_validations
+    errors.add(:auto_accept_registrations, I18n.t('competitions.errors.must_use_wca_registration')) if
+      auto_accept_registrations && !use_wca_registration
+
+    errors.add(:auto_accept_registrations, I18n.t('competitions.errors.auto_accept_limit')) if
+      auto_accept_disable_threshold > 0 &&
+      competitor_limit.present? &&
+      auto_accept_disable_threshold >= competitor_limit
+
+    errors.add(:auto_accept_registrations, I18n.t('competitions.errors.auto_accept_not_negative')) if auto_accept_disable_threshold < 0
+
+    if auto_accept_registrations_changed?
+      errors.add(:auto_accept_registrations, I18n.t('competitions.errors.auto_accept_accept_paid_pending')) if registrations.pending.with_payments.count > 0
+      errors.add(:auto_accept_registrations, I18n.t('competitions.errors.auto_accept_accept_waitlisted')) if
+        registrations.waitlisted.count > 0 && !accepted_full?
+    end
+  end
+
   def has_any_round_per_event?
     competition_events.map(&:rounds).none?(&:empty?)
   end
@@ -453,11 +474,16 @@ def confirmed_or_visible?
     self.confirmed? || self.showAtAll
   end
 
+  # TODO: Consider refactoring this once auto-accept is implemented
   def registration_full?
     competitor_count = registrations.accepted_and_paid_pending_count
     competitor_limit_enabled? && competitor_count >= competitor_limit
   end
 
+  def accepted_full?
+    competitor_limit_enabled? && registrations.competing_status_accepted.count >= competitor_limit
+  end
+
   def number_of_bookmarks
     bookmarked_users.count
   end
@@ -1888,7 +1914,7 @@ def to_competition_info
                base_entry_fee_lowest_denomination currency_code allow_registration_edits allow_registration_self_delete_after_acceptance
                allow_registration_without_qualification refund_policy_percent use_wca_registration guests_per_registration_limit venue contact
                force_comment_in_registration use_wca_registration external_registration_page guests_entry_fee_lowest_denomination guest_entry_status
-               information events_per_registration_limit guests_enabled],
+               information events_per_registration_limit guests_enabled auto_accept_registrations auto_accept_disable_threshold],
       methods: %w[url website short_name city venue_address venue_details latitude_degrees longitude_degrees country_iso2 event_ids registration_currently_open?
                   main_event_id number_of_bookmarks using_payment_integrations? uses_qualification? uses_cutoff? competition_series_ids registration_full?
                   part_of_competition_series?],
@@ -2438,6 +2464,8 @@ def to_form_data
       "admin" => {
         "isConfirmed" => confirmed?,
         "isVisible" => showAtAll?,
+        "autoAcceptEnabled" => auto_accept_registrations,
+        "autoAcceptDisableThreshold" => auto_accept_disable_threshold,
       },
       "cloning" => {
         "fromId" => being_cloned_from_id,
@@ -2539,6 +2567,8 @@ def form_errors
       "admin" => {
         "isConfirmed" => errors[:confirmed_at],
         "isVisible" => errors[:showAtAll],
+        "autoAcceptEnabled" => errors[:auto_accept_registrations],
+        "autoAcceptDisableThreshold" => errors[:auto_accept_disable_threshold],
       },
       "cloning" => {
         "fromId" => errors[:being_cloned_from_id],
@@ -2644,6 +2674,8 @@ def self.form_data_to_attributes(form_data)
       showAtAll: form_data.dig('admin', 'isVisible'),
       being_cloned_from_id: form_data.dig('cloning', 'fromId'),
       clone_tabs: form_data.dig('cloning', 'cloneTabs'),
+      auto_accept_registrations: form_data.dig('admin', 'autoAcceptEnabled'),
+      auto_accept_disable_threshold: form_data.dig('admin', 'autoAcceptDisableThreshold'),
     }
   end
 
@@ -2827,6 +2859,8 @@ def self.form_data_json_schema
             "guestsPerRegistration" => { "type" => ["integer", "null"] },
             "extraRequirements" => { "type" => ["string", "null"] },
             "forceComment" => { "type" => ["boolean", "null"] },
+            "autoAcceptEnabled" => { "type" => ["boolean", "null"] },
+            "autoAcceptDisableThreshold" => { "type" => ["integer", "null"] },
           },
         },
         "eventRestrictions" => {
@@ -2883,4 +2917,8 @@ def self.form_data_json_schema
       },
     }
   end
+
+  def auto_accept_threshold_reached?
+    auto_accept_disable_threshold > 0 && auto_accept_disable_threshold <= registrations.competing_status_accepted.count
+  end
 end

app/models/registration.rb

@@ -43,12 +43,14 @@ class Registration < ApplicationRecord
 
   after_save :mark_registration_processing_as_done
 
+  after_update :waiting_list_auto_accept_check
+
   private def mark_registration_processing_as_done
     Rails.cache.delete(CacheAccess.registration_processing_cache_key(competition_id, user_id))
   end
 
-  def update_lanes!(params, acting_user)
-    Registrations::Lanes::Competing.update!(params, self.competition, acting_user.id)
+  def update_lanes!(params, acting_user_id)
+    Registrations::Lanes::Competing.update!(params, self.competition, acting_user_id)
   end
 
   def guest_limit
@@ -335,6 +337,14 @@ def self.accepted_and_paid_pending_count
     end
   end
 
+  validate :does_not_exceed_competitor_limit
+  private def does_not_exceed_competitor_limit
+    return unless competition&.competitor_limit.present?
+    return unless competing_status == Registrations::Helper::STATUS_ACCEPTED
+    errors.add(:competitor_limit, I18n.t('registrations.errors.competitor_limit_reached')) if
+      competition.registrations.competing_status_accepted.count >= competition.competitor_limit
+  end
+
   # TODO: V3-REG cleanup. All these Validations can be used instead of the registration_checker checks
   validate :cannot_be_undeleted_when_banned, if: :competing_status_changed?
   private def cannot_be_undeleted_when_banned
@@ -428,4 +438,44 @@ def series_registration_info
   def serializable_hash(options = nil)
     super(DEFAULT_SERIALIZE_OPTIONS.merge(options || {}))
   end
+
+  def auto_accept
+    return log_error('Auto-accept is not enabled for this competition.') unless competition.auto_accept_registrations
+    return log_error('Can only auto-accept pending registrations or first position on waiting list') unless
+      competing_status_pending? || (competing_status_waiting_list? && waiting_list_position == 1)
+    return log_error("Competition has reached auto_accept_disable_threshold of #{competition.auto_accept_disable_threshold} registrations") if
+      competition.auto_accept_threshold_reached?
+    return log_error('Competitor still has outstanding registration fees') if outstanding_entry_fees > 0
+    return log_error('Cant auto-accept while registration is not open') if !competition.registration_currently_open?
+
+    if competition.accepted_full? && competing_status_pending?
+      update_lanes!(
+        { user_id: user_id, competing: { status: Registrations::Helper::STATUS_WAITING_LIST } }.with_indifferent_access,
+        'Auto-accept',
+      )
+    else
+      update_lanes!(
+        { user_id: user_id, competing: { status: Registrations::Helper::STATUS_ACCEPTED } }.with_indifferent_access,
+        'Auto-accept',
+      )
+    end
+  rescue ActiveRecord::RecordInvalid => e
+    log_error("Auto accept error for registration #{id}: #{e}")
+  end
+
+  private def log_error(error)
+    Rails.logger.error(error)
+    false
+  end
+
+  private def waiting_list_auto_accept_check
+    changed_from_accepted = saved_change_to_competing_status? && saved_change_to_competing_status.first == Registrations::Helper::STATUS_ACCEPTED
+    return unless changed_from_accepted
+
+    waiting_list_leader_id = competition.waiting_list&.entries&.first
+
+    if changed_from_accepted && waiting_list_leader_id.present?
+      Registration.find(waiting_list_leader_id).auto_accept
+    end
+  end
 end

app/models/registration_payment.rb

@@ -9,6 +9,8 @@ class RegistrationPayment < ApplicationRecord
   belongs_to :refunded_registration_payment, class_name: 'RegistrationPayment', optional: true
   has_many :refunding_registration_payments, class_name: 'RegistrationPayment', inverse_of: :refunded_registration_payment, foreign_key: :refunded_registration_payment_id, dependent: :destroy
 
+  after_create :attempt_auto_accept
+
   monetize :amount_lowest_denomination,
            as: "amount",
            allow_nil: true,
@@ -26,4 +28,8 @@ def payment_status
       receipt.determine_wca_status
     end
   end
+
+  private def attempt_auto_accept
+    registration.auto_accept
+  end
 end

app/models/waiting_list.rb

@@ -8,6 +8,8 @@ def remove(entry_id)
   end
 
   def add(entry_id)
+    return if entries.include?(entry_id)
+
     if entries.nil?
       update_column :entries, [entry_id]
     else

app/views/registrations/edit_registrations.html.erb

@@ -1,5 +1,5 @@
 <% provide(:title, I18n.t('registrations.list.title', comp: @competition.name)) %>
 
 <%= render layout: 'nav' do %>
-  <%= react_component('RegistrationsV2/RegistrationAdministration', { competitionInfo: @competition.to_competition_info }) %>
+  <%= react_component('RegistrationsV2/RegistrationAdministration', { competitionId: @competition.id }) %>
 <% end %>

app/webpacker/components/CompetitionForm/FormSections/Admin.js

@@ -1,16 +1,23 @@
 import React from 'react';
-import { InputBoolean } from '../../wca/FormBuilder/input/FormInputs';
+import { InputBoolean, InputBooleanSelect, InputNumber } from '../../wca/FormBuilder/input/FormInputs';
+import ConditionalSection from './ConditionalSection';
 import { useStore } from '../../../lib/providers/StoreProvider';
 import SubSection from '../../wca/FormBuilder/SubSection';
+import { useFormObject } from '../../wca/FormBuilder/provider/FormObjectProvider';
 
 export default function Admin() {
+  const { admin } = useFormObject();
   const { isAdminView, isPersisted } = useStore();
   if (!isPersisted || !isAdminView) return null;
 
   return (
     <SubSection section="admin">
       <InputBoolean id="isConfirmed" />
       <InputBoolean id="isVisible" />
+      <InputBooleanSelect id="autoAcceptEnabled" required />
+      <ConditionalSection showIf={admin.autoAcceptEnabled}>
+        <InputNumber id="autoAcceptDisableThreshold" />
+      </ConditionalSection>
     </SubSection>
   );
 }

app/webpacker/components/RegistrationsV2/RegistrationAdministration/RegistrationAdministrationContainer.jsx

@@ -0,0 +1,44 @@
+import React from 'react';
+import { useQuery } from '@tanstack/react-query';
+import { setMessage } from '../Register/RegistrationMessage';
+import { useDispatch } from '../../../lib/providers/StoreProvider';
+import getCompetitionInfo from '../api/competition/get_competition_info';
+import RegistrationAdministrationList from './RegistrationAdministrationList';
+import Loading from '../../Requests/Loading';
+
+export default function RegistrationAdministrationContainer({ competitionId }) {
+  const dispatchStore = useDispatch();
+
+  const fetchCompetitionInfo = async () => getCompetitionInfo(competitionId);
+
+  const {
+    isLoading: isCompetitionInfoLoading,
+    data: competitionInfo,
+    refetch: refetchCompetitionInfo,
+  } = useQuery({
+    queryKey: ['competitionInfo', 'test'],
+    queryFn: fetchCompetitionInfo,
+    refetchOnWindowFocus: false,
+    refetchOnReconnect: false,
+    staleTime: Infinity,
+    refetchOnMount: 'always',
+    retry: false,
+    onError: () => {
+      dispatchStore(setMessage(
+        // i18n-tasks-use t('competitions.errors.cant_load_competition_info')
+        // eslint-disable-next-line quotes
+        `competitions.errors.cant_load_competition_info`,
+        'negative',
+      ));
+    },
+  });
+
+  return isCompetitionInfoLoading ? (
+    <Loading />
+  ) : (
+    <RegistrationAdministrationList
+      competitionInfo={competitionInfo}
+      refetchCompetitionInfo={refetchCompetitionInfo}
+    />
+  );
+}