Merge pull request #2546 from mroderick/fix/workshop-invitation-resilience

feat: add database-backed invitation logging and resilient bulk invitations

Author: mroderick

app/controllers/admin/workshop_invitation_logs_controller.rb

@@ -0,0 +1,19 @@
+module Admin
+  class WorkshopInvitationLogsController < Admin::ApplicationController
+    def index
+      @workshop = Workshop.find(params[:workshop_id])
+      authorize @workshop, :show?
+      logs = InvitationLog.where(loggable: @workshop)
+                          .order(created_at: :desc)
+                          .includes(:initiator, :entries)
+      @pagy, @logs = pagy(logs)
+    end
+
+    def show
+      @workshop = Workshop.find(params[:workshop_id])
+      authorize @workshop, :show?
+      @log = InvitationLog.find(params[:id])
+      @entries = @log.entries.order(processed_at: :desc).includes(:member)
+    end
+  end
+end

app/controllers/admin/workshops_controller.rb

@@ -85,9 +85,9 @@ def invite
     audience = params[:for]
 
     if @workshop.virtual?
-      InvitationManager.new.send_virtual_workshop_emails(@workshop, audience)
+      InvitationManager.new.send_virtual_workshop_emails(@workshop, audience, current_user.id)
     else
-      InvitationManager.new.send_workshop_emails(@workshop, audience)
+      InvitationManager.new.send_workshop_emails(@workshop, audience, current_user.id)
     end
 
     redirect_to admin_workshop_path(@workshop), notice: "Invitations to #{audience} are being emailed out."

app/jobs/cleanup_expired_invitation_logs_job.rb

@@ -0,0 +1,7 @@
+class CleanupExpiredInvitationLogsJob < ApplicationJob
+  queue_as :default
+
+  def perform
+    InvitationLog.destroy_by(expires_at: ..Time.current)
+  end
+end

app/models/concerns/workshop_invitation_manager_concerns.rb

@@ -15,19 +15,63 @@ def send_workshop_attendance_reminders(workshop)
     end
     handle_asynchronously :send_workshop_attendance_reminders
 
-    def send_workshop_emails(workshop, audience)
+    def send_workshop_emails(workshop, audience, initiator_id = nil)
       return 'The workshop is not invitable' unless workshop.invitable?
 
-      invite_students_to_workshop(workshop) if audience.in?(%w[students everyone])
-      invite_coaches_to_workshop(workshop) if audience.in?(%w[coaches everyone])
+      initiator = initiator_id ? Member.find_by(id: initiator_id) : nil
+      logger = initiator ? InvitationLogger.new(workshop, initiator, audience, :invite) : nil
+
+      if logger
+        begin
+          logger.start_batch
+        rescue ActiveRecord::RecordNotUnique
+          return 'A batch is already running for this workshop and audience'
+        end
+      end
+
+      total = 0
+      begin
+        if audience.in?(%w[students everyone])
+          total += invite_students_to_workshop(workshop, logger)
+        end
+        if audience.in?(%w[coaches everyone])
+          total += invite_coaches_to_workshop(workshop, logger)
+        end
+        logger&.finish_batch(total)
+      rescue StandardError => e
+        logger&.fail_batch(e)
+        raise
+      end
     end
     handle_asynchronously :send_workshop_emails
 
-    def send_virtual_workshop_emails(workshop, audience)
+    def send_virtual_workshop_emails(workshop, audience, initiator_id = nil)
       return 'The workshop is not invitable' unless workshop.invitable?
 
-      invite_students_to_virtual_workshop(workshop) if audience.in?(%w[students everyone])
-      invite_coaches_to_virtual_workshop(workshop) if audience.in?(%w[coaches everyone])
+      initiator = initiator_id ? Member.find_by(id: initiator_id) : nil
+      logger = initiator ? InvitationLogger.new(workshop, initiator, audience, :invite) : nil
+
+      if logger
+        begin
+          logger.start_batch
+        rescue ActiveRecord::RecordNotUnique
+          return 'A batch is already running for this workshop and audience'
+        end
+      end
+
+      total = 0
+      begin
+        if audience.in?(%w[students everyone])
+          total += invite_students_to_virtual_workshop(workshop, logger)
+        end
+        if audience.in?(%w[coaches everyone])
+          total += invite_coaches_to_virtual_workshop(workshop, logger)
+        end
+        logger&.finish_batch(total)
+      rescue StandardError => e
+        logger&.fail_batch(e)
+        raise
+      end
     end
     handle_asynchronously :send_virtual_workshop_emails
 
@@ -51,35 +95,87 @@ def send_workshop_waiting_list_reminders(workshop)
     private
 
     def create_invitation(workshop, member, role)
-      invitation = WorkshopInvitation.create(workshop: workshop, member: member, role: role)
-      invitation.persisted? ? invitation : nil
+      WorkshopInvitation.find_or_create_by(workshop: workshop, member: member, role: role)
+    rescue StandardError => e
+      log_invitation_failure(workshop, member, role, e)
+      nil
     end
 
-    def invite_coaches_to_virtual_workshop(workshop)
+    def log_invitation_failure(workshop, member, role, error)
+      Rails.logger.error(
+        '[InvitationManager] Failed to create invitation: ' \
+        "workshop_id=#{workshop.id}, chapter_id=#{workshop.chapter_id}, " \
+        "member_id=#{member.id}, role=#{role}, " \
+        "error=#{error.class.name}: #{error.message}"
+      )
+    end
+
+    def invite_coaches_to_virtual_workshop(workshop, logger = nil)
+      count = 0
       chapter_coaches(workshop.chapter).shuffle.each do |coach|
-        invitation = create_invitation(workshop, coach, 'Coach') || next
-        VirtualWorkshopInvitationMailer.invite_coach(workshop, coach, invitation).deliver_now
+        invitation = create_invitation(workshop, coach, 'Coach')
+        next unless invitation
+
+        count += 1
+        send_email_with_logging(logger, coach, invitation) do
+          VirtualWorkshopInvitationMailer.invite_coach(workshop, coach, invitation).deliver_now
+        end
       end
+      count
     end
 
-    def invite_coaches_to_workshop(workshop)
+    def invite_coaches_to_workshop(workshop, logger = nil)
+      count = 0
       chapter_coaches(workshop.chapter).shuffle.each do |coach|
-        invitation = create_invitation(workshop, coach, 'Coach') || next
-        WorkshopInvitationMailer.invite_coach(workshop, coach, invitation).deliver_now
+        invitation = create_invitation(workshop, coach, 'Coach')
+        next unless invitation
+
+        count += 1
+        send_email_with_logging(logger, coach, invitation) do
+          WorkshopInvitationMailer.invite_coach(workshop, coach, invitation).deliver_now
+        end
       end
+      count
     end
 
-    def invite_students_to_virtual_workshop(workshop)
+    def invite_students_to_virtual_workshop(workshop, logger = nil)
+      count = 0
       chapter_students(workshop.chapter).shuffle.each do |student|
-        invitation = create_invitation(workshop, student, 'Student') || next
-        VirtualWorkshopInvitationMailer.invite_student(workshop, student, invitation).deliver_now
+        invitation = create_invitation(workshop, student, 'Student')
+        next unless invitation
+
+        count += 1
+        send_email_with_logging(logger, student, invitation) do
+          VirtualWorkshopInvitationMailer.invite_student(workshop, student, invitation).deliver_now
+        end
       end
+      count
     end
 
-    def invite_students_to_workshop(workshop)
+    def invite_students_to_workshop(workshop, logger = nil)
+      count = 0
       chapter_students(workshop.chapter).shuffle.each do |student|
-        invitation = create_invitation(workshop, student, 'Student') || next
-        WorkshopInvitationMailer.invite_student(workshop, student, invitation).deliver_now
+        invitation = create_invitation(workshop, student, 'Student')
+        next unless invitation
+
+        count += 1
+        send_email_with_logging(logger, student, invitation) do
+          WorkshopInvitationMailer.invite_student(workshop, student, invitation).deliver_now
+        end
+      end
+      count
+    end
+
+    def send_email_with_logging(logger, member, invitation)
+      if logger
+        begin
+          yield
+          logger.log_success(member, invitation)
+        rescue StandardError => e
+          logger.log_failure(member, invitation, e)
+        end
+      else
+        yield
       end
     end
 

app/models/invitation_log.rb

@@ -0,0 +1,18 @@
+class InvitationLog < ApplicationRecord
+  enum :action, { invite: 'invite', reminder: 'reminder', waiting_list_notification: 'waiting_list_notification' },
+       prefix: false
+  enum :status, { running: 'running', completed: 'completed', failed: 'failed' }, prefix: false
+
+  belongs_to :loggable, polymorphic: true
+  belongs_to :initiator, class_name: 'Member', optional: true
+  belongs_to :chapter, optional: true
+  has_many :entries, class_name: 'InvitationLogEntry', dependent: :destroy
+
+  before_create :set_expires_at
+
+  private
+
+  def set_expires_at
+    self.expires_at ||= 180.days.from_now
+  end
+end

app/models/invitation_log_entry.rb

@@ -0,0 +1,9 @@
+class InvitationLogEntry < ApplicationRecord
+  enum :status, { success: 'success', failed: 'failed', skipped: 'skipped' }, prefix: false
+
+  belongs_to :invitation_log
+  belongs_to :member
+  belongs_to :invitation, polymorphic: true, optional: true
+
+  validates :member_id, uniqueness: { scope: %i[invitation_type invitation_id] }, allow_nil: true
+end

app/models/invitation_manager.rb

@@ -20,7 +20,11 @@ def send_monthly_attendance_reminder_emails(monthly)
   def send_meeting_emails(meeting)
     meeting.invitees.not_banned.each do |invitee|
       invitation = MeetingInvitation.new(meeting: meeting, member: invitee, role: 'Participant')
-      MeetingInvitationMailer.invite(meeting, invitee, invitation).deliver_now if invitation.save
+      next unless invitation.save
+
+      MeetingInvitationMailer.invite(meeting, invitee, invitation).deliver_now
+    rescue StandardError => e
+      log_event_meeting_invitation_failure("meeting_id=#{meeting.id}", invitee, e)
     end
   end
   handle_asynchronously :send_meeting_emails
@@ -30,17 +34,33 @@ def send_meeting_emails(meeting)
   def invite_students_to_event(event, chapter)
     chapter_students(chapter).each do |student|
       invitation = Invitation.new(event: event, member: student, role: 'Student')
-      EventInvitationMailer.invite_student(event, student, invitation).deliver_now if invitation.save
+      next unless invitation.save
+
+      EventInvitationMailer.invite_student(event, student, invitation).deliver_now
+    rescue StandardError => e
+      log_event_meeting_invitation_failure("event_id=#{event.id}", student, e)
     end
   end
 
   def invite_coaches_to_event(event, chapter)
     chapter_coaches(chapter).each do |coach|
       invitation = Invitation.new(event: event, member: coach, role: 'Coach')
-      EventInvitationMailer.invite_coach(event, coach, invitation).deliver_now if invitation.save
+      next unless invitation.save
+
+      EventInvitationMailer.invite_coach(event, coach, invitation).deliver_now
+    rescue StandardError => e
+      log_event_meeting_invitation_failure("event_id=#{event.id}", coach, e)
     end
   end
 
+  def log_event_meeting_invitation_failure(context, member, error)
+    Rails.logger.error(
+      '[InvitationManager] Failed to create invitation: ' \
+      "#{context}, member_id=#{member.id}, " \
+      "error=#{error.class.name}: #{error.message}"
+    )
+  end
+
   def chapter_students(chapter)
     Member.in_group(chapter.groups.students)
   end

app/models/workshop.rb

@@ -16,6 +16,7 @@ class Workshop < ApplicationRecord
   has_one :host, through: :workshop_host, source: :sponsor
   has_many :organisers, -> { where('permissions.name' => 'organiser') }, through: :permissions, source: :members
   has_many :feedbacks
+  has_many :invitation_logs, as: :loggable
 
   belongs_to :chapter
 

app/policies/invitation_log_policy.rb

@@ -0,0 +1,9 @@
+class InvitationLogPolicy < ApplicationPolicy
+  def index?
+    is_admin_or_chapter_organiser?
+  end
+
+  def show?
+    is_admin_or_chapter_organiser?
+  end
+end

app/services/invitation_logger.rb

@@ -0,0 +1,78 @@
+class InvitationLogger
+  def initialize(loggable, initiator, audience, action)
+    @loggable = loggable
+    @initiator = initiator
+    @audience = audience
+    @action = action
+    @log = nil
+  end
+
+  def start_batch
+    @log = InvitationLog.create!(
+      loggable: @loggable,
+      initiator: @initiator,
+      chapter_id: @loggable.try(:chapter_id),
+      audience: @audience,
+      action: @action,
+      started_at: Time.current,
+      status: :running
+    )
+  end
+
+  def log_success(member, invitation = nil)
+    return unless @log
+
+    @log.entries.create!(
+      member: member,
+      invitation: invitation,
+      status: :success,
+      processed_at: Time.current
+    ).tap { @log.increment!(:success_count) }
+  end
+
+  def log_failure(member, invitation, error)
+    return unless @log
+
+    @log.entries.create!(
+      member: member,
+      invitation: invitation,
+      status: :failed,
+      failure_reason: error.message,
+      processed_at: Time.current
+    ).tap { @log.increment!(:failure_count) }
+  end
+
+  def log_skipped(member, invitation, reason)
+    return unless @log
+
+    @log.entries.create!(
+      member: member,
+      invitation: invitation,
+      status: :skipped,
+      failure_reason: reason,
+      processed_at: Time.current
+    ).tap { @log.increment!(:skipped_count) }
+  end
+
+  def finish_batch(total_invitees)
+    return unless @log
+
+    @log.update!(
+      total_invitees: total_invitees,
+      completed_at: Time.current,
+      status: :completed
+    )
+  end
+
+  def fail_batch(error)
+    return unless @log
+
+    @log.update!(
+      status: :failed,
+      error_message: error.message,
+      completed_at: Time.current
+    )
+  end
+
+  attr_reader :log
+end