initial refactor for teams hierarchy

Author: Chinzzii

app/controllers/teams_controller.rb

@@ -42,45 +42,31 @@ def members
   # POST /teams/:id/members
   # Adds a new member to the team.
   def add_member
-    # Find the user specified in the request.
     user = User.find(team_participant_params[:user_id])
-
-    # Determine the correct type of participant (Assignment or Course) based on the team type.
-    participant_class = @team.is_a?(AssignmentTeam) ? AssignmentParticipant : CourseParticipant
-    
-    # Find the specific participant record for this user in the team's context.
-    participant = participant_class.find_by(user_id: user.id, parent_id: @team.parent_id)
-
-    # If no participant record exists, the user isn't part of the assignment/course.
-    unless participant
-      return render json: { errors: ["#{user.name} is not a participant in this context."] }, status: :unprocessable_entity
-    end
-
-    # Delegate the add operation to the Team model with the found participant.
-    result = @team.add_member(participant)
+    result = @team.add_member(user)
 
     if result[:success]
       render json: user, serializer: UserSerializer, status: :created
     else
       render json: { errors: [result[:error]] }, status: :unprocessable_entity
     end
+  rescue ActiveRecord::RecordNotFound
+    render json: { errors: ['User not found'] }, status: :not_found
   end
 
   # DELETE /teams/:id/members/:user_id
   # Removes a member from the team based on user ID
   def remove_member
     user = User.find(params[:user_id])
-    participant = Participant.find_by(user: user, parent_id: @team.parent_id)
-    tp = @team.teams_participants.find_by(participant: participant)
+    result = @team.remove_member(user)
 
-    if tp
-      tp.destroy
+    if result[:success]
       head :no_content
     else
-      render json: { error: 'Member not found' }, status: :not_found
+      render json: { errors: [result[:error]] }, status: :not_found
     end
   rescue ActiveRecord::RecordNotFound
-    render json: { error: 'User not found' }, status: :not_found
+    render json: { errors: ['User not found'] }, status: :not_found
   end
 
   # Placeholder method to get current user (can be replaced by actual auth logic)
@@ -99,7 +85,7 @@ def set_team
 
   # Whitelists the parameters allowed for team creation/updation
   def team_params
-    params.require(:team).permit(:name, :max_team_size, :type, :assignment_id)
+    params.require(:team).permit(:name, :max_team_size, :type, :assignment_id, :course_id, :parent_id)
   end
 
   # Whitelists parameters required to add a team member
@@ -109,10 +95,14 @@ def team_participant_params
 
   # Validates the team type before team creation to ensure it's among allowed types
   def validate_team_type
-    return unless params[:team] && params[:team][:type]
-    valid_types = ['CourseTeam', 'AssignmentTeam', 'MentoredTeam']
-    unless valid_types.include?(params[:team][:type])
-      render json: { error: 'Invalid team type' }, status: :unprocessable_entity
+    # Use .dig to safely access nested params.
+    # Check that the type is present AND included in the list.
+    team_type = params.dig(:team, :type)
+
+    unless team_type.in?(['CourseTeam', 'AssignmentTeam', 'MentoredTeam'])
+      # If type is nil or not in the list, render an error and stop execution.
+      render json: { errors: ["Invalid or missing team type. Must be one of: CourseTeam, AssignmentTeam, MentoredTeam."] },
+             status: :unprocessable_entity
     end
   end
 end 

app/helpers/team_operations_helper.rb

@@ -13,9 +13,7 @@ def self.validate_mentor_assignment(team, user)
 
   # Copies all members from the source team to the target team
   def self.copy_team_members(source_team, target_team)
-    source_team.users.each do |user|
-      target_team.add_member(user)
-    end
+    source_team.copy_members_to(target_team)
   end
 
   # Returns a hash of basic statistics about the given team

app/models/assignment_team.rb

@@ -2,40 +2,13 @@
 
 class AssignmentTeam < Team
   # Each AssignmentTeam must belong to a specific assignment
-  belongs_to :assignment, class_name: 'Assignment', foreign_key: 'parent_id'
+  belongs_to :assignment, class_name: 'Assignment', foreign_key: 'parent_id', inverse_of: :teams
 
-  # Copies the current assignment team to a course team
-  # - Creates a new CourseTeam with a modified name
-  # - Copies team members from the assignment team to the course team
-  def copy_to_course_team(course)
-    course_team = CourseTeam.new(
-      name: "#{name} (Course)",              # Appends "(Course)" to the team name
-      course: course                         # Associates new team with the given course
-    )
-    if course_team.save
-      team_members.each do |member|
-        course_team.add_member(member.user)  # Copies each member to the new course team
-      end
-    end
-    course_team   # Returns the newly created course team object
+  def copy_to_course(course, name: "#{self.name} (Course)")
+    copy_to(course, as: CourseTeam, name:)
   end
 
-  protected
-
-    # Validates if a user is eligible to join the team
-  # - Checks whether the user is a participant of the associated assignment
-  def validate_membership(user)
-    # Ensure user is enrolled in the assignment by checking AssignmentParticipant
-    assignment.participants.exists?(user: user)
-  end
-
-  private
-
-  
-  # Validates that the team is an AssignmentTeam or a subclass (e.g., MentoredTeam)
-  def validate_assignment_team_type
-    unless self.kind_of?(AssignmentTeam)
-      errors.add(:type, 'must be an AssignmentTeam or its subclass')
-    end
+  def copy_to_assignment(assignment, as: AssignmentTeam, name: self.name)
+    copy_to(assignment, as:, name:)
   end
 end 

app/models/course_team.rb

@@ -2,44 +2,13 @@
 
 class CourseTeam < Team
   #Each course team must belong to a course
-  belongs_to :course, class_name: 'Course', foreign_key: 'parent_id'
+  belongs_to :course, class_name: 'Course', foreign_key: 'parent_id', inverse_of: :teams
 
-  #adds members to the course team post validation
-  def add_member(user)
-    # return false unless validate_membership(user)
-    super(user)
+  def copy_to_assignment(assignment, as: AssignmentTeam, name: "#{self.name} (Assignment)")
+    copy_to(assignment, as:, name:)
   end
 
-  # Copies the current course team to an assignment team
-  # - Creates a new AssignmentTeam with a modified name
-  # - Copies team members from the course team to the assignment team
-  def copy_to_assignment_team(assignment)
-    assignment_team = AssignmentTeam.new(
-      name: "#{name} (Assignment)",             # Appends "(Assignment)" to the team name
-      assignment: assignment                    # Associates the course team with an assignment
-    )
-    if assignment_team.save
-      team_members.each do |member|
-        assignment_team.add_member(member.user) # Copies each member to the new assignment team
-      end
-    end
-    assignment_team       # Returns the newly created assignment team object
-  end
-
-  protected
-
-  def validate_membership(user)
-    # Check if user is enrolled in any assignment in the course
-    course.assignments.any? { |assignment| assignment.participants.exists?(user: user) }
-  end
-
-  private
-
-  # Custom validation method for team type
-  # - Ensures the type is 'CourseTeam'
-  def type_must_be_course_team
-    unless self.kind_of?(CourseTeam)
-      errors.add(:type, 'must be CourseTeam')
-    end
+  def copy_to_course(course, name: self.name)
+    copy_to(course, as: CourseTeam, name:)
   end
 end 

app/models/mentored_team.rb

@@ -14,12 +14,23 @@ def mentor
   alias_method :mentor_user, :mentor
 
   # Adds members to the team who are not mentors
-  def add_member(participant)
+  def add_member(member)
+    participant =
+      case member
+      when Participant
+        member
+      when User
+        assignment&.participants&.find_by(user_id: member.id, parent_id: assignment&.id)
+      else
+        nil
+      end
+    return super(member) unless participant
+
     # Fail fast if the participant's duty is 'mentor'.
-    if participant.duty&.name&.downcase&.include?('mentor')
+    if mentor_designation?(participant)
       return { success: false, error: 'Mentors cannot be added as regular members.' }
     end
-
+    
     # If not a mentor, proceed with the standard add_member logic.
     super(participant)
   end
@@ -84,4 +95,8 @@ def mentor_must_be_present
       errors.add(:base, 'a mentor must be present')
     end
   end
+
+  def mentor_designation?(participant)
+    participant.duty&.name&.downcase&.include?('mentor')
+  end
 end