CSC/ECE 517 Spring 2025 - E2516. Reimplement teams users controller.rb

From Expertiza_Wiki
Jump to navigation Jump to search

E2516: Reimplement teams_users_controller.rb

Introduction

Expertiza is an open-source project implementation for an educational platform. It hosts a lot of functionalities: the professor can create assignments for the students; the students can submit their assignments supported across multiple file formats and also review assignments uploaded by other students; the students can form team and work together for an assignment or a project. This platform provides synchronicity to the professor as well as students to effectively manage their work.

Project Overview

Through this project, we have reimplement a controller component, namely, teams_users_controller. The entire component is shifted to another controller, namely teams_participants_controller. It now achieves below mentioned functionalities:

  • The code change now follows the SOLID and DRY principles
  • All associations and references between participants and assignments and courses have been modified
  • Clear distinction between "general user" and "assignment participant"
  • Improved code readability by integrating helper methods

Files Modified

The following files have been modified to achieve the mentioned functionalities:

  • TeamsParticipantsController
  • AssignmentTeam
  • MentoredTeam
  • TeamsParticipant

TeamsParticipantsController

The changes made in this controller included refactoring the TeamsUsersController to TeamsParticipantsController. This name change reflects a very important feature that needs to be implemented: A participant is compulsorily to be assigned a course or an assignment whereas a user is general purpose member who uses the expertiza platform. Helper methods and various other methods have been modified in this controller file. One other association that is also implemented simultaneously is that a participant is to be assigned only and only one team unless the participant is a mentor. 

 def valid_participant?(user, assignment_or_course)
   if assignment_or_course.user_on_team?(user)
     flash[:error] = "This user is already assigned to a team for this #{assignment_or_course.class.name.downcase}."
     return false
   end
   participant = assignment_or_course.participants.find_by(user_id: user.id)
   unless participant
     flash[:error] = participant_not_found_message(user.name, assignment_or_course)
     return false
   end
   true
 end

Above method in the controller file implements this functionality where it checks whether a participant is assigned a team or not. If the participant is already assigned a team, it throws an error that the participant is already assigned a team. If not, it finds the participant id and accordingly assigns a team.

AssignmentTeam

The AssignmentTeam class is inherited from the Team class to include all functionalities present in the Team class. The primary purpose of this model is to depict the team members present for a given assignment or course. A lot of things could be achieved by having such a model and necessary methods have been devised to achieve them. Firstly, association rules have been established where each team can be assigned to multiple reviewers and can have multiple review responses. It defines rules for returning participants of a team, whether a participant is part of a team, assigning a reviewer to a team, drafting the review map when a reviewer reviews the work of the team, detailing participants of a team and if necessary, adding participants to a team, creating a new team and assigning a topic to the team, and lastly adding or modifying or deleting a hyperlink which represents the link to the work done by a particular team. 

 belongs_to :assignment, class_name: 'Assignment', foreign_key: 'parent_id'
 has_many :review_mappings, class_name: 'ReviewResponseMap', foreign_key: 'reviewee_id'
 has_many :review_response_maps, foreign_key: 'reviewee_id'
 has_many :responses, through: :review_response_maps, foreign_key: 'map_id'


MentoredTeam

The MentoredTeam class is inherited from the AssignmentTeam class. The purpose of this class is to validating a team in regards to participants already present and adding a mentor to the team compulsorily and that too only once. One other feature achieved through this model is to automate the task of creating teams by importing the team member data from a csv file and validating at the same time whether a user can be added to the team based on the capacity of the team and whether the user exists or not. One other feature achieved through this is that of logging every action performed from above description.


TeamsParticipant

The TeamsParticipant class is inherited from the ApplicationRecord class meaning that it is an active record model. This model manages the association between the participant and the teams including adding, removing and fetching participants from the team. It establishes relationships which state that each team can have many participants and one participant can have only one team.

Test Cases for AssignmentTeam

Below are the test cases implemented for the `AssignmentTeam` model: 

 require 'rails_helper'
 RSpec.describe AssignmentTeam, type: :model do
   let(:assignment) { create(:assignment) }
   let(:team) { create(:assignment_team, assignment: assignment) }
   let(:user) { create(:user) }
   let(:participant) { create(:participant, user: user, assignment: assignment) }
   let(:reviewer) { create(:participant, assignment: assignment) }
   let(:review_response_map) { create(:review_response_map, reviewee: team, reviewer: reviewer) }
   describe '#user_id' do
     it 'returns the user_id of the first team member' do
       team.users << user
       expect(team.user_id).to eq(user.id)
     end
     it 'returns current_user.id if they are in the team' do
       team.users << user
       expect(team.user_id(user)).to eq(user.id)
     end
   end
   describe '#includes?' do
     it 'returns true if a participant is in the team' do
       allow(team).to receive(:participants).and_return([participant])
       expect(team.includes?(participant)).to be true
     end
     it 'returns false if a participant is not in the team' do
       allow(team).to receive(:participants).and_return([])
       expect(team.includes?(participant)).to be false
     end
   end
   describe '#parent_model' do
     it 'returns "Assignment"' do
       expect(team.parent_model).to eq('Assignment')
     end
   end
   describe '#assign_reviewer' do
     it 'raises an error if the assignment is not found' do
       allow(Assignment).to receive(:find_by).and_return(nil)
       expect { team.assign_reviewer(reviewer) }.to raise_error('The assignment cannot be found.')
     end
     it 'creates a review map for the reviewer' do
       expect { team.assign_reviewer(reviewer) }.to change { ReviewResponseMap.count }.by(1)
     end
   end
   describe '#create_review_map' do
     it 'creates a new ReviewResponseMap' do
       expect {
         team.create_review_map(reviewer, assignment)
       }.to change { ReviewResponseMap.count }.by(1)
     end
   end
   describe '#reviewed_by?' do
     it 'returns true if the team has been reviewed by the given reviewer' do
       review_response_map
       expect(team.reviewed_by?(reviewer)).to be true
     end
     it 'returns false if the team has not been reviewed by the given reviewer' do
       expect(team.reviewed_by?(reviewer)).to be false
     end
   end
   describe '#participants' do
     it 'returns the participants of the team' do
       allow(TeamsParticipant).to receive(:team_members).with(team.id).and_return([participant])
       expect(team.participants).to include(participant)
     end
   end
   describe '#add_participant' do
     it 'adds a participant to the team' do
       expect {
         team.add_participant(assignment.id, user)
       }.to change { TeamsParticipant.count }.by(1)
     end
     it 'does not add a participant if they are already in the team' do
       team.add_participant(assignment.id, user)
       expect {
         team.add_participant(assignment.id, user)
       }.not_to change { TeamsParticipant.count }
     end
   end
   describe '#create_new_team' do
     let(:signuptopic) { create(:sign_up_topic, assignment: assignment) }
     it 'creates a new team user and associates topic' do
       expect {
         team.create_new_team(user.id, signuptopic)
       }.to change { TeamsUser.count }.by(1)
         .and change { SignedUpTeam.count }.by(1)
         .and change { TeamNode.count }.by(1)
         .and change { TeamUserNode.count }.by(1)
     end
   end
   describe '#submit_hyperlink' do
     it 'calls TeamFileService.submit_hyperlink' do
       expect(TeamFileService).to receive(:submit_hyperlink).with(team, 'http://example.com')
       team.submit_hyperlink('http://example.com')
     end
   end
   describe '#remove_hyperlink' do
     it 'calls TeamFileService.remove_hyperlink' do
       expect(TeamFileService).to receive(:remove_hyperlink).with(team, 'http://example.com')
       team.remove_hyperlink('http://example.com')
     end
   end
   describe '#has_submissions?' do
     it 'returns true if the team has submissions' do
       allow(team).to receive(:submitted_files).and_return(['file1'])
       allow(team).to receive(:submitted_hyperlinks).and_return(nil)
       expect(team.has_submissions?).to be true
     end
     it 'returns false if the team has no submissions' do
       allow(team).to receive(:submitted_files).and_return([])
       allow(team).to receive(:submitted_hyperlinks).and_return(nil)
       expect(team.has_submissions?).to be false
     end
   end
   describe '#most_recent_submission' do
     it 'returns the latest submission' do
       submission1 = create(:submission_record, team: team, assignment: assignment, updated_at: 1.day.ago)
       submission2 = create(:submission_record, team: team, assignment: assignment, updated_at: Time.current)
       expect(team.most_recent_submission).to eq(submission2)
     end
   end
 end


Test Cases for MentoredTeam

Below are the test cases implemented for the `MentoredTeam` model: 

 require 'rails_helper'
 RSpec.describe MentoredTeam, type: :model do
   let(:team) { create(:mentored_team) }
   let(:user) { create(:user) }
   let(:mentor) { create(:user, role: :mentor) }
   describe '#import_team_members' do
     it 'imports members successfully from a given list' do
       members = [create(:user), create(:user)]
       expect { team.import_team_members(members) }.to change { team.users.count }.by(2)
     end
   end
   describe '#find_or_raise_user' do
     it 'returns the user if found' do
       expect(team.find_or_raise_user(user.id)).to eq(user)
     end
     it 'raises an error if the user is not found' do
       expect { team.find_or_raise_user(999) }.to raise_error(ActiveRecord::RecordNotFound)
     end
   end
   describe '#user_not_in_team?' do
     it 'returns true if user is not in the team' do
       expect(team.user_not_in_team?(user)).to be true
     end
     it 'returns false if user is in the team' do
       team.users << user
       expect(team.user_not_in_team?(user)).to be false
     end
   end
   describe '#mentor_assignment_valid?' do
     it 'returns true if a mentor can be assigned' do
       expect(team.mentor_assignment_valid?(mentor)).to be true
     end
     it 'returns false if an invalid mentor is assigned' do
       expect(team.mentor_assignment_valid?(user)).to be false
     end
   end
   describe '#add_member' do
     it 'adds a user to the team' do
       expect { team.add_member(user) }.to change { team.users.count }.by(1)
     end
     it 'does not add a user who is already in the team' do
       team.users << user
       expect { team.add_member(user) }.not_to change { team.users.count }
     end
   end
   describe '#can_add_member?' do
     it 'returns true if the team can add a member' do
       expect(team.can_add_member?).to be true
     end
     it 'returns false if the team has reached its limit' do
       allow(team).to receive(:users).and_return(Array.new(10) { create(:user) })
       expect(team.can_add_member?).to be false
     end
   end
   describe '#add_team_user' do
     it 'adds a user to the team successfully' do
       expect { team.add_team_user(user) }.to change { team.users.count }.by(1)
     end
   end
   describe '#add_participant_to_team' do
     it 'adds a participant to the team' do
       participant = create(:participant)
       expect { team.add_participant_to_team(participant) }.to change { team.users.count }.by(1)
     end
   end
   describe '#assign_mentor_if_needed' do
     it 'assigns a mentor if no mentor is present' do
       team.assign_mentor_if_needed(mentor)
       expect(team.mentor).to eq(mentor)
     end
     it 'does not assign a mentor if one is already assigned' do
       existing_mentor = create(:user, role: :mentor)
       team.mentor = existing_mentor
       team.assign_mentor_if_needed(mentor)
       expect(team.mentor).to eq(existing_mentor)
     end
   end
 end

Mentor

Team Members

Retrieved from "https://wiki.expertiza.ncsu.edu/index.php?title=CSC/ECE_517_Spring_2025_-_E2516._Reimplement_teams_users_controller.rb&oldid=162538"