effective_mentorships 0.2.4 → 0.3.0

data/app/models/concerns/effective_mentorships_bulk_group.rb

@@ -0,0 +1,368 @@
+# frozen_string_literal: true
+
+# EffectiveCpdBulkAudit
+#
+# Mark your owner model with effective_cpd_bulk_audit to get all the includes
+
+module EffectiveMentorshipsBulkGroup
+  extend ActiveSupport::Concern
+
+  module Base
+    def effective_mentorships_bulk_group
+      include ::EffectiveMentorshipsBulkGroup
+    end
+  end
+
+  module ClassMethods
+    def effective_mentorships_bulk_group?; true; end
+  end
+
+  included do
+    acts_as_job_status
+    log_changes if respond_to?(:log_changes)
+
+    acts_as_wizard(
+      start: 'Start',
+      group: 'Preview',
+      grouping: 'Grouping',
+      review: 'Review',
+      publish: 'Publish',
+      notify: 'Notify',
+      notifying: 'Notifying',
+      finished: 'Finished'
+    )
+
+    # Effective Scoped
+    belongs_to :mentorship_cycle, class_name: 'Effective::MentorshipCycle'
+
+    # Application Scoped
+    has_many :mentorship_groups, -> { order(:id) }, inverse_of: :mentorship_bulk_group, dependent: :nullify
+    accepts_nested_attributes_for :mentorship_groups, allow_destroy: true
+
+    effective_resource do
+      mentorship_groups_count :integer
+
+      email_form_skip         :boolean
+
+      # Acts as Wizard
+      wizard_steps            :text, permitted: false
+
+      # Acts as Tokened
+      token                   :string
+
+      # Acts as Job Status
+      job_status            :string
+      job_started_at        :datetime
+      job_ended_at          :datetime
+      job_error             :text
+
+      timestamps
+    end
+
+    scope :deep, -> { all }
+    scope :sorted, -> { order(:id) }
+  end
+
+  def to_s
+    [model_name.human, ("##{id}" if id.present?)].compact.join(' ')
+  end
+
+  def max_pairings_mentee
+    raise('expected a mentorship cycle') unless mentorship_cycle.present?
+    mentorship_cycle.max_pairings_mentee || 10 # Hardcode a sane limit. This shouldn't ever be used. The registrations is limited to 1-5
+  end
+
+  def mentors_mentorship_registrations
+    raise('expected a mentorship cycle') unless mentorship_cycle.present?
+    EffectiveMentorships.MentorshipRegistration.opt_in.mentors.where(mentorship_cycle: mentorship_cycle)
+  end
+
+  def mentees_mentorship_registrations
+    raise('expected a mentorship cycle') unless mentorship_cycle.present?
+    EffectiveMentorships.MentorshipRegistration.opt_in.mentees.where(mentorship_cycle: mentorship_cycle)
+  end
+
+  def mentorship_group_for(user:)
+    mentorship_groups.find { |mentorship_group| mentorship_group.mentorship_group_user(user: user).present? }
+  end
+
+  def group!
+    # Calls create_groups! and save!
+    perform_with_job_status! { Effective::MentorshipsBulkCreateGroupsJob.perform_later(id) }
+  end
+
+  def publish!
+    mentorship_groups.deep.find_each { |mentorship_group| mentorship_group.publish! }
+    save!
+  end
+
+  def notify!
+    return skip_notify! if email_form_skip?
+
+    # Calls notify_groups! and save!
+    perform_with_job_status! { Effective::MentorshipsBulkNotifyGroupsJob.perform_later(id) }
+  end
+
+  def skip_notify!
+    wizard_steps[:notifying] ||= Time.zone.now
+    wizard_steps[last_wizard_step] ||= Time.zone.now
+    save!
+  end
+
+  def notifying!
+    wizard_steps[last_wizard_step] ||= Time.zone.now # Also finish the whole wizard
+    save!
+  end
+
+  # Called by Effective::MentorshipsBulkNotifyGroupsJob
+  def notify_groups!
+    mentorship_groups.published.not_notified.find_each do |mentorship_group|
+      mentorship_group.notify!
+    end
+
+    wizard_steps[:notifying] ||= Time.zone.now
+    save!
+  end
+
+  # Called by Effective::MentorshipsBulkCreateGroupsJob
+  def create_groups!
+    # First pass
+    # Create groups with 1 mentor and 1 best matching mentee each
+    EffectiveMentorships.MentorshipRegistration.uncached do
+      # In-person
+      mentors_mentorship_registrations.without_groups.in_person.find_each do |mentor_registration|
+        mentorship_group = build_mentorship_group(mentor_registration)
+        mentorship_group&.save!
+      end
+
+      # Either
+      mentors_mentorship_registrations.without_groups.either.find_each do |mentor_registration|
+        mentorship_group = build_mentorship_group(mentor_registration)
+        mentorship_group&.save!
+      end
+
+      # Virtual
+      mentors_mentorship_registrations.without_groups.virtual.find_each do |mentor_registration|
+        mentorship_group = build_mentorship_group(mentor_registration)
+        mentorship_group&.save!
+      end
+
+      # Second pass
+      # Create groups with 1 mentor and any mentee
+      mentors_mentorship_registrations.without_groups.find_each do |mentor_registration|
+        mentorship_group = build_mentorship_group(mentor_registration, any_mentee: true)
+        mentorship_group&.save!
+      end
+
+      # Third pass
+      # Add best matching mentees to groups where mentor wants more than 1 mentee
+      if max_pairings_mentee > 1
+        fillable_mentors_mentorship_registrations = mentors_mentorship_registrations.multiple_mentees.with_groups_from(self)
+
+        # In-person
+        fillable_mentors_mentorship_registrations.in_person.find_each do |mentor_registration|
+          mentorship_group = fill_mentorship_group(mentor_registration)
+          mentorship_group&.save!
+        end
+
+        # Either
+        fillable_mentors_mentorship_registrations.either.find_each do |mentor_registration|
+          mentorship_group = fill_mentorship_group(mentor_registration)
+          mentorship_group&.save!
+        end
+
+        # Virtual
+        fillable_mentors_mentorship_registrations.virtual.find_each do |mentor_registration|
+          mentorship_group = fill_mentorship_group(mentor_registration)
+          mentorship_group&.save!
+        end
+      end
+
+      # Fourth pass
+      # Add any mentees to groups where mentor wants more than 1 mentee
+      if max_pairings_mentee > 1
+        fillable_mentors_mentorship_registrations = mentors_mentorship_registrations.multiple_mentees.with_groups_from(self)
+
+        fillable_mentors_mentorship_registrations.find_each do |mentor_registration|
+          mentorship_group = fill_mentorship_group(mentor_registration, any_mentee: true)
+          mentorship_group&.save!
+        end
+      end
+
+      # Call after_save callback on all mentorship groups
+      mentorship_groups.each do |mentorship_group|
+        mentorship_group.assign_attributes(save_as_draft: true)
+        after_save_mentorship_group!(mentorship_group)
+      end
+    end
+
+    wizard_steps[:grouping] ||= Time.zone.now
+    save!
+  end
+
+  def build_mentorship_group(mentor_registration, any_mentee: false)
+    raise('expected a mentorship registration') unless mentor_registration.class.try(:effective_mentorships_registration?)
+    raise('expected a mentor mentorship registration') unless mentor_registration.mentor?
+
+    mentor = mentor_registration.user
+    raise('expected a mentorship user') unless mentor.class.try(:effective_mentorships_user?)
+
+    # Select the best matching mentees for this mentor registration
+    mentee_registration = find_best_mentee_registration(mentor_registration)
+
+    if any_mentee
+      mentee_registration ||= find_any_mentee_registration(mentor_registration) 
+    end
+
+    return unless mentee_registration.present?
+
+    mentee = mentee_registration.user
+    raise('expected a mentorship user') unless mentee.class.try(:effective_mentorships_user?)
+
+    # Create a new group in draft state
+    mentorship_group = mentorship_groups.build(mentorship_cycle: mentorship_cycle, save_as_draft: true)
+    mentorship_group.build_mentor(user: mentor)
+    mentorship_group.build_mentee(user: mentee)
+
+    # Return the group ready to be saved
+    mentorship_group
+  end
+
+  def fill_mentorship_group(mentor_registration, any_mentee: false)
+    raise('expected a mentorship registration') unless mentor_registration.class.try(:effective_mentorships_registration?)
+    raise('expected a mentor mentorship registration') unless mentor_registration.mentor?
+
+    mentor = mentor_registration.user
+    raise('expected a mentorship user') unless mentor.class.try(:effective_mentorships_user?)
+
+    # Find the existing mentorship group that we previously created
+    mentorship_group = mentorship_group_for(user: mentor)
+    return unless mentorship_group.present?
+
+    # Fill this group to limit of number of mentees
+    limit = [mentor_registration.mentor_multiple_mentees_limit.to_i, max_pairings_mentee].min
+    fill_mentees = (limit - mentorship_group.mentorship_group_mentees.length)
+    return unless fill_mentees > 0
+
+    # We only support 1 mentor and many mentees
+    fill_mentees.times do
+      mentee_registration = find_best_mentee_registration(mentor_registration)
+
+      if any_mentee
+        mentee_registration ||= find_any_mentee_registration(mentor_registration) 
+      end
+
+      if mentee_registration.present?
+        mentee = mentee_registration.user
+        raise('expected a mentorship user') unless mentee.class.try(:effective_mentorships_user?)
+
+        mentorship_group.build_mentee(user: mentee)
+      end
+    end
+
+    # Return the group ready to be saved
+    mentorship_group.assign_attributes(save_as_draft: true)
+    mentorship_group
+  end
+
+  def find_best_mentee_registration(mentor_registration)
+    case mentor_registration.venue
+    when 'In-person' 
+      find_best_in_person_mentee_registration(mentor_registration)
+    when 'Either' 
+      find_best_either_mentee_registration(mentor_registration)
+    when 'Virtual' 
+      find_best_virtual_mentee_registration(mentor_registration)
+    else
+      raise("unexpected venue: #{mentor_registration.venue}")
+    end
+  end
+
+  def find_any_mentee_registration(mentor_registration)
+    mentees_mentorship_registrations.without_groups.order(:id).first
+  end
+
+  def find_best_in_person_mentee_registration(mentor_registration)
+    registrations = mentees_mentorship_registrations.without_groups.order(:id)
+
+    # In-person, same location, same category
+    registration ||= registrations.in_person.where(location: mentor_registration.location, category: mentor_registration.category).first
+
+    # In-person, same location, any category
+    registration ||= registrations.in_person.where(location: mentor_registration.location).first
+
+    # Either, same location, same category
+    registration ||= registrations.either.where(location: mentor_registration.location, category: mentor_registration.category).first
+
+    # Either, same location, any category
+    registration ||= registrations.either.where(location: mentor_registration.location).first
+
+    # Might be nil
+    registration
+  end
+
+  def find_best_either_mentee_registration(mentor_registration)
+    raise('expected an in-person mentor registration') unless mentor_registration.either?
+
+    registrations = mentees_mentorship_registrations.without_groups.order(:id)
+
+    # Either, same location, same category
+    registration ||= registrations.either.where(location: mentor_registration.location, category: mentor_registration.category).first
+
+    # In-person, same location, same category
+    registration ||= registrations.in_person.where(location: mentor_registration.location, category: mentor_registration.category).first
+
+    # Either, any location, same category
+    registration ||= registrations.either.where(category: mentor_registration.category).first
+
+    # In-person, same location, any category
+    registration ||= registrations.in_person.where(location: mentor_registration.location).first
+
+    # Virtual, same location, same category 
+    registration ||= registrations.virtual.where(location: mentor_registration.location, category: mentor_registration.category).first
+
+    # Virtual, any location, same category
+    registration ||= registrations.virtual.where(category: mentor_registration.category).first
+
+    # Either any
+    registration ||= registrations.either.first
+
+    # Virtual any
+    registration ||= registrations.virtual.first
+
+    # Might be nil
+    registration
+  end
+
+  def find_best_virtual_mentee_registration(mentor_registration)
+    raise('expected an in-person mentor registration') unless mentor_registration.virtual?
+
+    registrations = mentees_mentorship_registrations.without_groups.order(:id)
+
+    # Virtual, same location, same category 
+    registration ||= registrations.virtual.where(location: mentor_registration.location, category: mentor_registration.category).first
+
+    # Virtual, any location, same category
+    registration ||= registrations.virtual.where(category: mentor_registration.category).first
+
+    # Either, same location, same category
+    registration ||= registrations.either.where(location: mentor_registration.location, category: mentor_registration.category).first
+
+    # Either, any location, same category
+    registration ||= registrations.either.where(category: mentor_registration.category).first
+
+    # Virtual any
+    registration ||= registrations.virtual.first
+
+    # Either any
+    registration ||= registrations.either.first
+
+    # Might be nil
+    registration
+  end
+
+  # Nothing to do. Override me.
+  def after_save_mentorship_group!(mentorship_group)
+  end
+
+end

data/app/models/concerns/effective_mentorships_group.rb

@@ -18,24 +18,36 @@ module EffectiveMentorshipsGroup
   end
 
   included do
-    acts_as_archived
+    acts_as_published
     acts_as_tokened
-
     log_changes if respond_to?(:log_changes)
 
     has_many_rich_texts
     # rich_text_admin_notes
 
+    # Application Scoped
+    belongs_to :mentorship_bulk_group, optional: true, counter_cache: true
+
     # Effective Scoped
     belongs_to :mentorship_cycle, class_name: 'Effective::MentorshipCycle', counter_cache: true
 
     has_many :mentorship_group_users, class_name: 'Effective::MentorshipGroupUser', dependent: :delete_all
     accepts_nested_attributes_for :mentorship_group_users, allow_destroy: true
 
+    has_many :mentorship_group_mentors, -> { where(mentorship_role: :mentor) }, class_name: 'Effective::MentorshipGroupUser'
+    has_many :mentorship_group_mentees, -> { where(mentorship_role: :mentee) }, class_name: 'Effective::MentorshipGroupUser'
+
     effective_resource do
       title         :string
 
-      archived      :boolean
+      # Track email
+      last_notified_at    :datetime
+
+      # Acts as Published
+      published_start_at  :datetime
+      published_end_at    :datetime
+
+      # Acts as Tokened
       token         :string
 
       timestamps
@@ -44,16 +56,79 @@ module EffectiveMentorshipsGroup
     scope :deep, -> { includes(:mentorship_cycle, :rich_texts, mentorship_group_users: [:user]) }
     scope :sorted, -> { order(:id) }
 
-    validates :title, presence: true, uniqueness: true
+    scope :notified, -> { where.not(last_notified_at: nil) }
+    scope :not_notified, -> { where(last_notified_at: nil) }
+
+    # When created on the MentorshipBulkGroup Review screen
+    before_validation(if: -> { mentorship_bulk_group.present? }) do
+      self.mentorship_cycle ||= mentorship_bulk_group.mentorship_cycle
+    end
+
+    before_save :assign_title # Assign computed title always
   end
 
   # Instance Methods
   def to_s
-    model_name.human
+    title.presence || model_name.human
   end
 
+  def assign_title
+    if present_mentorship_group_users.blank?
+      assign_attributes(title: "Empty")
+    else
+      mentor_names = mentors.map { |user| user.try(:first_name) || user.to_s.split(' ').first }.sort
+      mentee_names = mentees.map { |user| user.try(:first_name) || user.to_s.split(' ').first }.sort
+
+      assign_attributes(title: (mentor_names + mentee_names).join(', '))
+    end
+  end
+
+  def notify!
+    return false unless published?
+
+    present_mentorship_group_users.each do |mentorship_group_user|
+      case mentorship_group_user.mentorship_role.to_s
+      when 'mentor'
+        EffectiveMentorships.send_email(:mentorship_group_created_to_mentor, mentorship_group_user)
+      when 'mentee'
+        EffectiveMentorships.send_email(:mentorship_group_created_to_mentee, mentorship_group_user)
+      end
+    end
+
+    update!(last_notified_at: Time.zone.now)
+  end
+
+  # Find
   def mentorship_group_user(user:)
     mentorship_group_users.find { |mgu| mgu.user == user }
   end
 
+  # Find or build
+  def build_mentorship_group_user(user:, mentorship_role:)
+    raise("unexpected mentorship role: #{mentorship_role}") unless EffectiveMentorships.MentorshipRegistration.mentorship_roles.include?(mentorship_role)
+    mentorship_group_user(user: user) || mentorship_group_users.build(user: user, mentorship_role: mentorship_role)
+  end
+
+  # Find or build
+  def build_mentor(user:)
+    build_mentorship_group_user(user: user, mentorship_role: :mentor)
+  end
+
+  # Find or build
+  def build_mentee(user:)
+    build_mentorship_group_user(user: user, mentorship_role: :mentee)
+  end
+
+  def present_mentorship_group_users
+    mentorship_group_users.reject(&:marked_for_destruction?)
+  end
+
+  def mentors
+    present_mentorship_group_users.select(&:mentor?).map(&:user)
+  end
+
+  def mentees
+    present_mentorship_group_users.select(&:mentee?).map(&:user)
+  end
+
 end

data/app/models/concerns/effective_mentorships_registration.rb

@@ -16,10 +16,16 @@ module EffectiveMentorshipsRegistration
   module ClassMethods
     def effective_mentorships_registration?; true; end
 
+    # Don't change these roles
     def mentorship_roles
       [:mentor, :mentee]
     end
 
+    # Don't change these venues
+    def venues
+      ['Virtual', 'In-person', 'Either']
+    end
+
     def categories
       ['General', 'Industry Specific']
     end
@@ -27,10 +33,6 @@ module EffectiveMentorshipsRegistration
     def locations
       ['Canada', 'United States']
     end
-
-    def venues
-      ['Virtual', 'In-person', 'Either']
-    end
   end
 
   included do
@@ -42,11 +44,13 @@ module EffectiveMentorshipsRegistration
 
     # Effective Scoped
     belongs_to :mentorship_cycle, class_name: 'Effective::MentorshipCycle', counter_cache: true
+    has_many :mentorship_group_users, class_name: 'Effective::MentorshipGroupUser', inverse_of: :mentorship_registration, dependent: :nullify
 
     # App Scoped
     belongs_to :user
     belongs_to :parent, polymorphic: true, optional: true # A FeePayment if this was done through a fee payment
-
+    has_many :mentorship_groups, through: :mentorship_group_users
+    
     effective_resource do
       title              :string # Auto generated
 
@@ -83,7 +87,7 @@ module EffectiveMentorshipsRegistration
       validates :accept_declaration, acceptance: true
     end
 
-    validates :mentor_multiple_mentees_limit, numericality: { greater_than: 0 }, if: -> { opt_in? && mentor? }
+    validates :mentor_multiple_mentees_limit, numericality: { greater_than_or_equal_to: 1, less_than_or_equal_to: 5 }, if: -> { opt_in? && mentor? }
 
     scope :deep, -> { includes(:rich_texts, :user, :mentorship_cycle) }
     scope :sorted, -> { order(:id) }
@@ -92,6 +96,35 @@ module EffectiveMentorshipsRegistration
     scope :mentees, -> { where(mentorship_role: :mentee) }
     scope :opt_in, -> { where(opt_in: true) }
     scope :opt_out, -> { where(opt_in: false) }
+    scope :opt_in_without_groups, -> { opt_in.without_groups }
+
+    scope :in_person, -> { where(venue: 'In-person') }
+    scope :virtual, -> { where(venue: 'Virtual') }
+    scope :either, -> { where(venue: 'Either') }
+
+    scope :with_groups, -> { 
+      group_users = Effective::MentorshipGroupUser.all
+      where(id: group_users.select(:mentorship_registration_id))
+    }
+
+    scope :without_groups, -> {
+      group_users = Effective::MentorshipGroupUser.all
+      where.not(id: group_users.select(:mentorship_registration_id))
+    }
+
+    scope :with_groups, -> { 
+      group_users = Effective::MentorshipGroupUser.all
+      where(id: group_users.select(:mentorship_registration_id))
+    }
+
+    scope :with_groups_from, -> (mentorship_bulk_group) { 
+      groups = EffectiveMentorships.MentorshipGroup.where(mentorship_bulk_group: mentorship_bulk_group)
+      group_users = Effective::MentorshipGroupUser.where(mentorship_group_id: groups.select(:mentorship_group_id))
+
+      where(id: group_users.select(:mentorship_registration_id))
+    }
+
+    scope :multiple_mentees, -> { mentors.where('mentor_multiple_mentees_limit > 1') }
 
     # User
     validates :user_id, uniqueness: { scope: [:mentorship_cycle_id] }
@@ -102,12 +135,40 @@ module EffectiveMentorshipsRegistration
     title.presence || model_name.human
   end
 
+  def short_category
+    return category unless category.to_s.include?('(') && category.to_s.include?(')')
+    category.to_s.split('(').first.strip
+  end
+
+  def details
+    [
+      short_category.presence, 
+      venue.presence, 
+      location.presence, 
+      ("Limit #{mentor_multiple_mentees_limit}" if mentor? && mentor_multiple_mentees_limit.present?)
+    ].compact.join(', ').html_safe
+  end
+
+  # Mentorship roles
   def mentor?
-    mentorship_role == 'mentor'
+    mentorship_role.to_s == 'mentor'
   end
 
   def mentee?
-    mentorship_role == 'mentee'
+    mentorship_role.to_s == 'mentee'
+  end
+
+  # Venues
+  def in_person?
+    venue == 'In-person'
+  end
+
+  def virtual?
+    venue == 'Virtual'
+  end
+
+  def either?
+    venue == 'Either'
   end
 
 end

data/app/models/concerns/effective_mentorships_user.rb

@@ -27,6 +27,48 @@ module EffectiveMentorshipsUser
     has_many :mentorship_groups, through: :mentorship_group_users
 
     scope :deep_effective_mentorships_user, -> { all }
+
+    scope :mentorships_opted_in, -> (mentorship_cycle) {
+      raise('expected an EffectiveMentorships.MentorshipCycle') unless mentorship_cycle.kind_of?(Effective::MentorshipCycle)
+
+      opted_in = EffectiveMentorships.MentorshipRegistration.opt_in.where(mentorship_cycle: mentorship_cycle)
+      where(id: opted_in.select(:user_id))
+    }
+
+    scope :mentorships_opted_out, -> (mentorship_cycle) {
+      raise('expected an EffectiveMentorships.MentorshipCycle') unless mentorship_cycle.kind_of?(Effective::MentorshipCycle)
+
+      opted_out = EffectiveMentorships.MentorshipRegistration.opt_out.where(mentorship_cycle: mentorship_cycle)
+      where(id: opted_out.select(:user_id))
+    }
+
+    scope :mentorships_opted_in_mentors, -> (mentorship_cycle) {
+      raise('expected an EffectiveMentorships.MentorshipCycle') unless mentorship_cycle.kind_of?(Effective::MentorshipCycle)
+
+      opted_in_mentors = EffectiveMentorships.MentorshipRegistration.opt_in.mentors.where(mentorship_cycle: mentorship_cycle)
+      where(id: opted_in_mentors.select(:user_id))
+    }
+
+    scope :mentorships_opted_in_mentees, -> (mentorship_cycle) {
+      raise('expected an EffectiveMentorships.MentorshipCycle') unless mentorship_cycle.kind_of?(Effective::MentorshipCycle)
+
+      opted_in_mentees = EffectiveMentorships.MentorshipRegistration.opt_in.mentees.where(mentorship_cycle: mentorship_cycle)
+      where(id: opted_in_mentees.select(:user_id))
+    }
+
+    scope :mentorships_with_groups, -> (mentorship_cycle) {
+      raise('expected an EffectiveMentorships.MentorshipCycle') unless mentorship_cycle.kind_of?(Effective::MentorshipCycle)
+
+      grouped = Effective::MentorshipGroupUser.where(mentorship_cycle: mentorship_cycle)
+      where(id: grouped.select(:user_id))
+    }
+
+    scope :mentorships_without_groups, -> (mentorship_cycle) {
+      raise('expected an EffectiveMentorships.MentorshipCycle') unless mentorship_cycle.kind_of?(Effective::MentorshipCycle)
+
+      grouped = Effective::MentorshipGroupUser.where(mentorship_cycle: mentorship_cycle)
+      where.not(id: grouped.select(:user_id))
+    }
   end
 
   # Used for the dashboard datatables. Which cycles can we register for?

data/app/models/effective/mentorship_bulk_group.rb

@@ -0,0 +1,6 @@
+# Used to create the bulk group of mentorship requests
+module Effective
+  class MentorshipBulkGroup < ActiveRecord::Base
+    effective_mentorships_bulk_group
+  end
+end

data/app/models/effective/mentorship_cycle.rb

@@ -19,7 +19,6 @@ module Effective
       registration_start_at :datetime
       registration_end_at   :datetime
 
-      max_pairings_mentor   :integer
       max_pairings_mentee   :integer
 
       mentorship_groups_count         :integer
@@ -41,6 +40,7 @@ module Effective
 
     validates :title, presence: true, uniqueness: true
     validates :start_at, presence: true
+    validates :max_pairings_mentee, numericality: { greater_than_or_equal_to: 1, allow_blank: true }
 
     validate(if: -> { start_at.present? && end_at.present? }) do
       errors.add(:end_at, 'must be after the start date') unless end_at > start_at