Bring registration emails in line with v2 statuses

app/mailers/registrations_mailer.rb

@@ -55,14 +55,6 @@ def notify_registrant_of_accepted_registration(registration)
                    reply_to: registration.competition.organizers_or_delegates.map(&:email)
   end
 
-  def notify_registrant_of_pending_registration(registration)
-    @registration = registration
-    localized_mail @registration.user.locale,
-                   -> { I18n.t('registrations.mailer.pending.mail_subject', comp_name: registration.competition.name) },
-                   to: registration.user.email,
-                   reply_to: registration.competition.organizers_or_delegates.map(&:email)
-  end
-
   def notify_registrant_of_deleted_registration(registration)
     @registration = registration
     localized_mail @registration.user.locale,
@@ -80,4 +72,12 @@ def notify_registrant_of_locked_account_creation(user, competition)
       subject: "Unlock your new account on the WCA website",
     )
   end
+
+  def notify_registrant_of_waitlisted_registration(registration)
+    @registration = registration
+    localized_mail @registration.user.locale,
+                   -> { I18n.t('registrations.mailer.waiting_list.mail_subject', comp_name: registration.competition.name) },
+                   to: registration.user.email,
+                   reply_to: registration.competition.organizers_or_delegates.map(&:email)
+  end
 end

app/views/registrations_mailer/notify_registrant_of_deleted_registration.html.erb

@@ -8,9 +8,6 @@
   <li>
     <%= t 'registrations.mailer.deleted.causes.missing_info' %>
   </li>
-  <li>
-    <%= t 'registrations.mailer.pending.causes.withdrawal' %>
-  </li>
   <li>
     <%= t 'registrations.mailer.deleted.causes.incomplete' %>
   </li>
@@ -26,7 +23,7 @@
 </ul>
 
 <p>
-  <%= t 'registrations.mailer.pending.email_if_error' %>
+  <%= t 'registrations.mailer.deleted.email_if_error' %>
 </p>
 
 <%= render partial: 'organizers_or_delegates_signature' %>

app/views/registrations_mailer/notify_registrant_of_waitlisted_registration.html.erb

@@ -0,0 +1,11 @@
+<% @competition = @registration.competition %>
+
+<p>
+  <%= t 'registrations.mailer.waiting_list.waitlisted_html', here: link_to(t('common.here'), competition_register_url(@competition)) %>
+</p>
+
+<p>
+  <%= t 'registrations.mailer.waiting_list.email_if_error' %>
+</p>
+
+<%= render partial: 'organizers_or_delegates_signature' %>

config/locales/en.yml

@@ -1192,27 +1192,23 @@ en:
         #context: "comp_name" contains the competition's name
         see_you_soon: "We look forward to seeing you at %{comp_name}!"
       #context: when registration is moved to waiting list
-      pending:
+      waiting_list:
         #context: "comp_name" contains the competition's name
-        mail_subject: "Registration Moved to Waitlist: %{comp_name}"
-        #context: "comp_name" contains the competition's name
-        moved_html: "Your registration for %{comp_name} has been moved to the waiting list. Possible causes are:"
-        #context: this key is one of the reasons explaining why a registration could be moved to the waiting list
-        causes:
-          accepted: "Your registration was accidentally accepted"
-          withdrawal: "You asked for withdrawal"
+        mail_subject: "You're on the Waiting List: %{comp_name}"
+        waitlisted_html: "The competition is full, but you have been placed on a waiting list, and you will receive an email if enough spots open up for you to be able to attend. Check your position on the waiting list %{here}."
         email_if_error: "If you think this is an error, please reply to this email."
       #context: when registration is deleted
       deleted:
         #context: "comp_name" contains the competition's name
         mail_subject: "Registration Deleted: %{comp_name}"
         message_html: "Your registration for %{comp_name} has been deleted. Possible causes are:"
+        email_if_error: "If you think this is an error, please reply to this email."
         #context: this key is one of the reasons explaining why a registration could be deleted
         causes:
           missing_info: "You did not submit all the required details"
           incomplete: "You didn't meet the registration criteria (for example, paying the registration fee in advance or meeting the qualifying times for events)"
           registrations_full: "The competitor limit has been reached and there are no more spots available"
-          multiple_registrations: "You registered twice or more times"
+          multiple_registrations: "You registered two or more times"
           competition_canceled: "The competition has been canceled"
     #context: on the registrations list
     list:

lib/registrations/lanes/competing.rb

@@ -59,7 +59,7 @@ def self.update!(update_params, competition, current_user_id)
           registration.add_history_entry(changes, 'user', current_user_id, Registrations::Helper.action_type(update_params, current_user_id))
         end
 
-        send_status_change_email(registration, status, user_id, current_user_id) if status.present? && old_status != status
+        send_status_change_email(registration, status, old_status, user_id, current_user_id) if status.present? && old_status != status
 
         # TODO: V3-REG Cleanup Figure out a way to get rid of this reload
         registration.reload
@@ -85,12 +85,12 @@ def self.update_status(registration, status)
         registration.competing_status = status
       end
 
-      def self.send_status_change_email(registration, status, user_id, current_user_id)
+      def self.send_status_change_email(registration, status, old_status, user_id, current_user_id)
         case status
         when Registrations::Helper::STATUS_WAITING_LIST
-          # TODO: V3-REG Cleanup, at new waiting list email
+          RegistrationsMailer.notify_registrant_of_waitlisted_registration(registration).deliver_later
         when Registrations::Helper::STATUS_PENDING
-          RegistrationsMailer.notify_registrant_of_pending_registration(registration).deliver_later
+          RegistrationsMailer.notify_registrant_of_new_registration(registration).deliver_later
         when Registrations::Helper::STATUS_ACCEPTED
           RegistrationsMailer.notify_registrant_of_accepted_registration(registration).deliver_later
         when Registrations::Helper::STATUS_REJECTED, Registrations::Helper::STATUS_DELETED, Registrations::Helper::STATUS_CANCELLED

spec/mailers/registrations_mailer_spec.rb

@@ -15,7 +15,7 @@
     let(:registration) { FactoryBot.create(:registration, user: french_user, competition: competition_with_organizers) }
     let(:mail_new) { RegistrationsMailer.notify_registrant_of_new_registration(registration) }
     let(:mail_accepted) { RegistrationsMailer.notify_registrant_of_accepted_registration(registration) }
-    let(:mail_pending) { RegistrationsMailer.notify_registrant_of_pending_registration(registration) }
+    let(:mail_waitlisted) { RegistrationsMailer.notify_registrant_of_waitlisted_registration(registration) }
     let(:mail_deleted) { RegistrationsMailer.notify_registrant_of_deleted_registration(registration) }
 
     it "renders the headers in foreign locale" do
@@ -26,7 +26,7 @@
       # scope this call, but rather compare the result to the expected locale.
       expect(mail_new.subject).to eq(I18n.t('registrations.mailer.new.mail_subject', comp_name: registration.competition.name, locale: :fr))
       expect(mail_accepted.subject).to eq(I18n.t('registrations.mailer.accepted.mail_subject', comp_name: registration.competition.name, locale: :fr))
-      expect(mail_pending.subject).to eq(I18n.t('registrations.mailer.pending.mail_subject', comp_name: registration.competition.name, locale: :fr))
+      expect(mail_waitlisted.subject).to eq(I18n.t('registrations.mailer.waitlisted.mail_subject', comp_name: registration.competition.name, locale: :fr))
       expect(mail_deleted.subject).to eq(I18n.t('registrations.mailer.deleted.mail_subject', comp_name: registration.competition.name, locale: :fr))
     end
 
@@ -41,7 +41,7 @@
       end
       expect(mail_new.body.encoded).to match(regards_in_french)
       expect(mail_accepted.body.encoded).to match(regards_in_french)
-      expect(mail_pending.body.encoded).to match(regards_in_french)
+      expect(mail_waitlisted.body.encoded).to match(regards_in_french)
       expect(mail_deleted.body.encoded).to match(regards_in_french)
     end
   end
@@ -169,26 +169,24 @@
     end
   end
 
-  describe "notify_registrant_of_pending_registration for a competition without organizers" do
-    let(:mail) { RegistrationsMailer.notify_registrant_of_pending_registration(registration) }
+  describe "notify_registrant_of_waitlisted_registration for competition without organizers" do
+    let(:mail) { RegistrationsMailer.notify_registrant_of_waitlisted_registration(registration) }
     let(:registration) { FactoryBot.create(:registration, competition: competition_without_organizers) }
 
     it "renders the headers" do
-      expect(mail.subject).to eq("Registration Moved to Waitlist: #{competition_without_organizers.name}")
+      expect(mail.subject).to eq("You're on the Waiting List: #{competition_without_organizers.name}")
       expect(mail.to).to eq([registration.email])
       expect(mail.reply_to).to eq(competition_without_organizers.delegates.map(&:email))
       expect(mail.from).to eq(["[email protected]"])
     end
 
     it "renders the body" do
-      expect(mail.body.encoded).to match("Your registration for .{1,200}#{registration.competition.name}.{1,200} has been moved to the waiting list")
-      expect(mail.body.encoded).to match("If you think this is an error, please reply to this email.")
-      expect(mail.body.encoded).to match("Regards, #{users_to_sentence(competition_without_organizers.organizers_or_delegates)}.")
+      expect(mail.body.encoded).to match("The competition is full, but you have been placed on a waiting list, and you will receive an email if enough spots open up for you to be able to attend.")
     end
   end
 
-  describe "notify_registrant_of_pending_registration for a competition with organizers" do
-    let(:mail) { RegistrationsMailer.notify_registrant_of_pending_registration(registration) }
+  describe "notify_registrant_of_waitlisted_registration for competition with organizers" do
+    let(:mail) { RegistrationsMailer.notify_registrant_of_waitlisted_registration(registration) }
     let(:registration) { FactoryBot.create(:registration, competition: competition_with_organizers) }
 
     it "sets organizers in the reply_to" do

spec/requests/api_registrations_spec.rb

@@ -29,26 +29,23 @@
       end
 
       it 'creates a registration when job is worked off' do
-        perform_enqueued_jobs do
-          post api_v1_registrations_register_path, params: registration_request, headers: headers
-          # post api_v1_registrations_register_path, params: registration_request, headers: headers
+        post api_v1_registrations_register_path, params: registration_request, headers: headers
+        perform_enqueued_jobs
 
-          registration = Registration.find_by(user_id: user.id)
-          expect(registration).to be_present
-          expect(registration.events.map(&:id).sort).to eq(['333', '333oh'])
-        end
+        registration = Registration.find_by(user_id: user.id)
+        expect(registration).to be_present
+        expect(registration.events.map(&:id).sort).to eq(['333', '333oh'])
       end
 
       it 'creates a registration history' do
-        perform_enqueued_jobs do
-          post api_v1_registrations_register_path, params: registration_request, headers: headers
+        post api_v1_registrations_register_path, params: registration_request, headers: headers
+        perform_enqueued_jobs
 
-          registration = Registration.find_by(user_id: user.id)
-          reg_history = registration.registration_history.first
+        registration = Registration.find_by(user_id: user.id)
+        reg_history = registration.registration_history.first
 
-          expect(reg_history[:actor_id]).to eq(user.id.to_s)
-          expect(reg_history[:action]).to eq("Worker processed")
-        end
+        expect(reg_history[:actor_id]).to eq(user.id.to_s)
+        expect(reg_history[:action]).to eq("Worker processed")
       end
     end
 
@@ -76,15 +73,14 @@
         )
         headers = { 'Authorization' => registration_request['jwt_token'] }
 
-        perform_enqueued_jobs do
-          post api_v1_registrations_register_path, params: registration_request, headers: headers
+        post api_v1_registrations_register_path, params: registration_request, headers: headers
+        perform_enqueued_jobs
 
-          expect(response.status).to eq(202)
+        expect(response.status).to eq(202)
 
-          registration = Registration.find_by(user_id: user_with_results.id)
-          expect(registration).to be_present
-          expect(registration.events.map(&:id).sort).to eq(events)
-        end
+        registration = Registration.find_by(user_id: user_with_results.id)
+        expect(registration).to be_present
+        expect(registration.events.map(&:id).sort).to eq(events)
       end
 
       it 'cant register when qualifications arent met' do
@@ -94,28 +90,27 @@
 
         headers = { 'Authorization' => registration_request['jwt_token'] }
 
-        perform_enqueued_jobs do
-          post api_v1_registrations_register_path, params: registration_request, headers: headers
+        post api_v1_registrations_register_path, params: registration_request, headers: headers
+        perform_enqueued_jobs
 
-          expect(response.status).to eq(422)
+        expect(response.status).to eq(422)
 
-          error_json = {
-            error: Registrations::ErrorCodes::QUALIFICATION_NOT_MET,
-            data: events,
-          }.to_json
+        error_json = {
+          error: Registrations::ErrorCodes::QUALIFICATION_NOT_MET,
+          data: events,
+        }.to_json
 
-          expect(response.body).to eq(error_json)
+        expect(response.body).to eq(error_json)
 
-          registration = Registration.find_by(user_id: user_without_results.id)
-          expect(registration).not_to be_present
-        end
+        registration = Registration.find_by(user_id: user_without_results.id)
+        expect(registration).not_to be_present
       end
     end
   end
 
   describe 'PATCH #update' do
     let(:user) { FactoryBot.create :user }
-    let(:competition) { FactoryBot.create :competition, :registration_open, :editable_registrations }
+    let(:competition) { FactoryBot.create :competition, :registration_open, :editable_registrations, :with_organizer }
     let(:registration) { FactoryBot.create(:registration, competition: competition, user: user) }
 
     it 'updates a registration' do
@@ -164,6 +159,47 @@
       registration = Registration.find_by(user_id: user.id, competition_id: favourites_reg.competition.id)
       expect(registration.event_ids.sort).to eq(new_event_ids.sort)
     end
+
+    it 'user gets registration email if they cancel and re-register' do
+      cancelled_reg = FactoryBot.create(:registration, :cancelled, competition: competition)
+
+      update_request = FactoryBot.build(
+        :update_request,
+        user_id: cancelled_reg.user_id,
+        competition_id: cancelled_reg.competition.id,
+        competing: { 'status' => 'pending' },
+      )
+      headers = { 'Authorization' => update_request['jwt_token'] }
+
+      patch api_v1_registrations_register_path, params: update_request, headers: headers
+      perform_enqueued_jobs
+
+      expect(response.status).to eq(200)
+
+      email = ActionMailer::Base.deliveries.last
+      expect(email.subject).to eq(I18n.t('registrations.mailer.new.mail_subject', comp_name: registration.competition.name))
+    end
+
+    it 'user gets registration email if they were rejected and get moved to pending' do
+      rejected_reg = FactoryBot.create(:registration, :rejected, competition: competition)
+
+      update_request = FactoryBot.build(
+        :update_request,
+        user_id: rejected_reg.user_id,
+        competition_id: rejected_reg.competition.id,
+        submitted_by: competition.organizers.first.id,
+        competing: { 'status' => 'pending' },
+      )
+      headers = { 'Authorization' => update_request['jwt_token'] }
+
+      patch api_v1_registrations_register_path, params: update_request, headers: headers
+      perform_enqueued_jobs
+
+      expect(response.status).to eq(200)
+
+      email = ActionMailer::Base.deliveries.last
+      expect(email.subject).to eq(I18n.t('registrations.mailer.new.mail_subject', comp_name: registration.competition.name))
+    end
   end
 
   describe 'PATCH #bulk_update' do