Development: Remove eager relationship between team and students

src/main/java/de/tum/in/www1/artemis/domain/Team.java

@@ -42,7 +42,7 @@ public class Team extends AbstractAuditingEntity implements Participant {
      * The cache concurrency strategy needs to be READ_WRITE (and not NONSTRICT_READ_WRITE) since the non-strict mode will cause an SQLIntegrityConstraintViolationException to
      * occur when trying to persist the entity for the first time after changes have been made to the related entities of the ManyToMany relationship (users in this case).
      */
-    @ManyToMany(fetch = FetchType.EAGER)
+    @ManyToMany(fetch = FetchType.LAZY)
     @Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
     @JsonInclude(JsonInclude.Include.NON_NULL)
     @JoinTable(name = "team_student", joinColumns = @JoinColumn(name = "team_id", referencedColumnName = "id"), inverseJoinColumns = @JoinColumn(name = "student_id", referencedColumnName = "id"))

src/main/java/de/tum/in/www1/artemis/repository/ParticipationRepository.java

@@ -68,13 +68,15 @@ default Participation findByIdWithLegalSubmissionsElseThrow(long participationId
             SELECT p
             FROM Participation p
                 LEFT JOIN FETCH p.submissions s
+                LEFT JOIN FETCH p.team t
+                LEFT JOIN FETCH t.students
             WHERE p.id = :participationId
             """)
-    Optional<Participation> findWithEagerSubmissionsById(@Param("participationId") Long participationId);
+    Optional<Participation> findWithEagerSubmissionsByIdWithTeamStudents(@Param("participationId") Long participationId);
 
     @NotNull
-    default Participation findByIdWithSubmissionsElseThrow(long participationId) {
-        return findWithEagerSubmissionsById(participationId).orElseThrow(() -> new EntityNotFoundException("Participation", participationId));
+    default Participation findWithEagerSubmissionsByIdWithTeamStudentsElseThrow(long participationId) {
+        return findWithEagerSubmissionsByIdWithTeamStudents(participationId).orElseThrow(() -> new EntityNotFoundException("Participation", participationId));
     }
 
     @NotNull

src/main/java/de/tum/in/www1/artemis/repository/ProgrammingExerciseStudentParticipationRepository.java

@@ -77,6 +77,7 @@ default ProgrammingExerciseStudentParticipation findWithSubmissionsByExerciseIdA
 
     Optional<ProgrammingExerciseStudentParticipation> findByExerciseIdAndStudentLoginAndTestRun(Long exerciseId, String username, boolean testRun);
 
+    @EntityGraph(type = LOAD, attributePaths = { "team" })
     Optional<ProgrammingExerciseStudentParticipation> findByExerciseIdAndTeamId(Long exerciseId, Long teamId);
 
     @Query("""

src/main/java/de/tum/in/www1/artemis/repository/ProgrammingSubmissionRepository.java

@@ -34,8 +34,23 @@ default ProgrammingSubmission findByIdElseThrow(long submissionId) {
         return findById(submissionId).orElseThrow(() -> new EntityNotFoundException("ProgrammingSubmission", submissionId));
     }
 
-    @EntityGraph(type = LOAD, attributePaths = { "results.feedbacks" })
-    ProgrammingSubmission findFirstByParticipationIdAndCommitHashOrderByIdDesc(Long participationId, String commitHash);
+    @Query("""
+            SELECT s
+            FROM ProgrammingSubmission s
+                LEFT JOIN FETCH s.results r
+                LEFT JOIN FETCH r.feedbacks f
+                LEFT JOIN FETCH s.participation p
+                LEFT JOIN FETCH p.team t
+                LEFT JOIN FETCH t.students
+            WHERE p.id = :participationId
+                AND s.commitHash = :commitHash
+            ORDER BY s.id DESC
+            """)
+    List<ProgrammingSubmission> findByParticipationIdAndCommitHashOrderByIdDescWithFeedbacksAndTeamStudents(Long participationId, String commitHash);
+
+    default ProgrammingSubmission findFirstByParticipationIdAndCommitHashOrderByIdDescWithFeedbacksAndTeamStudents(Long participationId, String commitHash) {
+        return findByParticipationIdAndCommitHashOrderByIdDescWithFeedbacksAndTeamStudents(participationId, commitHash).stream().findFirst().orElse(null);
+    }
 
     @Query("""
             SELECT s FROM ProgrammingSubmission s

src/main/java/de/tum/in/www1/artemis/repository/StudentParticipationRepository.java

@@ -39,7 +39,11 @@ public interface StudentParticipationRepository extends JpaRepository<StudentPar
     Set<StudentParticipation> findByExerciseId(@Param("exerciseId") Long exerciseId);
 
     @Query("""
-            SELECT DISTINCT p FROM StudentParticipation p LEFT JOIN FETCH p.results r
+            SELECT DISTINCT p
+            FROM StudentParticipation p
+                LEFT JOIN FETCH p.results r
+                LEFT JOIN FETCH p.team t
+                LEFT JOIN FETCH t.students
             WHERE p.exercise.course.id = :#{#courseId}
                 AND (r.rated IS NULL OR r.rated = true)
             """)

src/main/java/de/tum/in/www1/artemis/repository/TeamRepository.java

@@ -1,10 +1,13 @@
 package de.tum.in.www1.artemis.repository;
 
+import static org.springframework.data.jpa.repository.EntityGraph.EntityGraphType.LOAD;
+
 import java.time.Instant;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Optional;
 
+import org.springframework.data.jpa.repository.EntityGraph;
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.data.jpa.repository.Query;
 import org.springframework.data.repository.query.Param;
@@ -23,6 +26,7 @@
 @Repository
 public interface TeamRepository extends JpaRepository<Team, Long> {
 
+    @EntityGraph(type = LOAD, attributePaths = "students")
     List<Team> findAllByExerciseId(@Param("exerciseId") Long exerciseId);
 
     List<Team> findAllByExerciseCourseIdAndShortName(@Param("courseId") Long courseId, @Param("shortName") String shortName);
@@ -36,7 +40,7 @@ public interface TeamRepository extends JpaRepository<Team, Long> {
     @Query("""
             SELECT COUNT(DISTINCT team)
             FROM Team team
-            WHERE team.exercise.id = :#{#exerciseId}
+            WHERE team.exercise.id = :exerciseId
             """)
     Integer getNumberOfTeamsForExercise(@Param("exerciseId") Long exerciseId);
 
@@ -60,8 +64,13 @@ SELECT COUNT(DISTINCT team)
     @Query(value = "select distinct team from Team team left join fetch team.students where team.exercise.id = :#{#exerciseId} and team.owner.id = :#{#teamOwnerId}")
     List<Team> findAllByExerciseIdAndTeamOwnerIdWithEagerStudents(@Param("exerciseId") long exerciseId, @Param("teamOwnerId") long teamOwnerId);
 
-    @Query("select team from Team team left join fetch team.students where team.id = :#{#teamId}")
-    Optional<Team> findOneWithEagerStudents(@Param("teamId") Long teamId);
+    @Query("""
+            SELECT team
+            FROM Team team
+                LEFT JOIN FETCH team.students
+            WHERE team.id = :teamId
+            """)
+    Optional<Team> findWithStudentsById(@Param("teamId") Long teamId);
 
     /**
      * Returns all teams for an exercise (optionally filtered for a specific tutor who owns the teams)
@@ -98,7 +107,8 @@ default Team save(Exercise exercise, Team team) {
             team.setLastModifiedDate(Instant.now());
         }
         team.setExercise(exercise);
-        return save(team);
+        team = save(team);
+        return findWithStudentsByIdElseThrow(team.getId());
     }
 
     /**
@@ -122,4 +132,8 @@ private List<Pair<User, Team>> findStudentTeamConflicts(Exercise exercise, Team
     default Team findByIdElseThrow(long teamId) throws EntityNotFoundException {
         return findById(teamId).orElseThrow(() -> new EntityNotFoundException("Team", teamId));
     }
+
+    default Team findWithStudentsByIdElseThrow(long teamId) throws EntityNotFoundException {
+        return findWithStudentsById(teamId).orElseThrow(() -> new EntityNotFoundException("Team", teamId));
+    }
 }

src/main/java/de/tum/in/www1/artemis/repository/TeamScoreRepository.java

@@ -45,10 +45,11 @@ public interface TeamScoreRepository extends JpaRepository<TeamScore, Long> {
             SELECT t, SUM(s.lastRatedPoints)
             FROM TeamScore s
                 LEFT JOIN s.team t
+                LEFT JOIN FETCH t.students
             WHERE s.exercise IN :exercises
             GROUP BY t.id
             """)
-    List<Object[]> getAchievedPointsOfTeams(@Param("exercises") Set<Exercise> exercises);
+    List<Object[]> getAchievedPointsOfTeamsWithStudents(@Param("exercises") Set<Exercise> exercises);
 
     @Query("""
             SELECT s

src/main/java/de/tum/in/www1/artemis/service/AuthorizationCheckService.java

@@ -27,6 +27,7 @@
 import de.tum.in.www1.artemis.domain.lecture.LectureUnit;
 import de.tum.in.www1.artemis.domain.participation.StudentParticipation;
 import de.tum.in.www1.artemis.repository.CourseRepository;
+import de.tum.in.www1.artemis.repository.TeamRepository;
 import de.tum.in.www1.artemis.repository.UserRepository;
 import de.tum.in.www1.artemis.security.Role;
 import de.tum.in.www1.artemis.security.SecurityUtils;
@@ -53,14 +54,17 @@ public class AuthorizationCheckService {
     @Value("${artemis.user-management.course-enrollment.allowed-username-pattern:#{null}}")
     private Pattern allowedCourseEnrollmentUsernamePattern;
 
-    public AuthorizationCheckService(UserRepository userRepository, CourseRepository courseRepository, ExamDateService examDateService) {
+    private final TeamRepository teamRepository;
+
+    public AuthorizationCheckService(UserRepository userRepository, CourseRepository courseRepository, ExamDateService examDateService, TeamRepository teamRepository) {
         this.userRepository = userRepository;
         this.courseRepository = courseRepository;
         this.examDateService = examDateService;
 
         if (allowedCourseEnrollmentUsernamePattern == null) {
             allowedCourseEnrollmentUsernamePattern = allowedCourseRegistrationUsernamePattern;
         }
+        this.teamRepository = teamRepository;
     }
 
     /**
@@ -556,6 +560,9 @@ public boolean isOwnerOfParticipation(@NotNull StudentParticipation participatio
             return false;
         }
         else {
+            if (participation.getParticipant() instanceof Team team) {
+                participation.setParticipant(teamRepository.findWithStudentsByIdElseThrow(team.getId()));
+            }
             return participation.isOwnedBy(user);
         }
     }

src/main/java/de/tum/in/www1/artemis/service/ComplaintService.java

@@ -35,13 +35,16 @@ public class ComplaintService {
 
     private final ExamRepository examRepository;
 
+    private final TeamRepository teamRepository;
+
     public ComplaintService(ComplaintRepository complaintRepository, ComplaintResponseRepository complaintResponseRepository, ResultRepository resultRepository,
-            ExamRepository examRepository, UserRepository userRepository) {
+            ExamRepository examRepository, UserRepository userRepository, TeamRepository teamRepository) {
         this.complaintRepository = complaintRepository;
         this.complaintResponseRepository = complaintResponseRepository;
         this.resultRepository = resultRepository;
         this.examRepository = examRepository;
         this.userRepository = userRepository;
+        this.teamRepository = teamRepository;
     }
 
     /**
@@ -97,6 +100,10 @@ else if (complaint.getComplaintType() == ComplaintType.MORE_FEEDBACK && !course.
             validateTimeOfComplaintOrRequestMoreFeedback(originalResult, studentParticipation.getExercise(), studentParticipation, course, complaint.getComplaintType());
         }
 
+        if (studentParticipation.getParticipant() instanceof Team team) {
+            studentParticipation.setParticipant(teamRepository.findWithStudentsByIdElseThrow(team.getId()));
+        }
+
         if (!studentParticipation.isOwnedBy(principal.getName())) {
             throw new BadRequestAlertException("You can create a complaint only for a result you submitted", ENTITY_NAME, "differentuser");
         }

src/main/java/de/tum/in/www1/artemis/service/ParticipantScoreService.java

@@ -138,7 +138,7 @@ private List<ScoreDTO> calculateScores(Set<Exercise> exercises, Set<User> users,
         // team exercises
         // [0] -> Team
         // [1] -> sum of achieved points in exercises
-        List<Object[]> teamAndAchievedPoints = teamScoreRepository.getAchievedPointsOfTeams(teamExercises);
+        List<Object[]> teamAndAchievedPoints = teamScoreRepository.getAchievedPointsOfTeamsWithStudents(teamExercises);
         for (Object[] rawData : teamAndAchievedPoints) {
             Team team = (Team) rawData[0];
             double achievedPoints = rawData[1] != null ? ((Number) rawData[1]).doubleValue() : 0.0;

src/main/java/de/tum/in/www1/artemis/service/ParticipationAuthorizationCheckService.java

@@ -6,11 +6,10 @@
 import org.slf4j.LoggerFactory;
 import org.springframework.stereotype.Service;
 
-import de.tum.in.www1.artemis.domain.Course;
-import de.tum.in.www1.artemis.domain.ProgrammingExercise;
-import de.tum.in.www1.artemis.domain.User;
+import de.tum.in.www1.artemis.domain.*;
 import de.tum.in.www1.artemis.domain.participation.*;
 import de.tum.in.www1.artemis.repository.ProgrammingExerciseRepository;
+import de.tum.in.www1.artemis.repository.TeamRepository;
 import de.tum.in.www1.artemis.repository.UserRepository;
 import de.tum.in.www1.artemis.web.rest.errors.AccessForbiddenException;
 
@@ -25,12 +24,15 @@ public class ParticipationAuthorizationCheckService {
 
     private final AuthorizationCheckService authCheckService;
 
+    private final TeamRepository teamRepository;
+
     public ParticipationAuthorizationCheckService(UserRepository userRepository, ProgrammingExerciseRepository programmingExerciseRepository,
-            AuthorizationCheckService authCheckService) {
+            AuthorizationCheckService authCheckService, TeamRepository teamRepository) {
         this.userRepository = userRepository;
         this.programmingExerciseRepository = programmingExerciseRepository;
 
         this.authCheckService = authCheckService;
+        this.teamRepository = teamRepository;
     }
 
     /**
@@ -68,6 +70,10 @@ public boolean canAccessParticipation(@NotNull final ParticipationInterface part
      * @return True, if the user is allowed to access the participation; false otherwise.
      */
     public boolean canAccessParticipation(@NotNull final ParticipationInterface participation, final User user) {
+        if (participation instanceof StudentParticipation studentParticipation && studentParticipation.getParticipant() instanceof Team team) {
+            // eager load the team with students so their information can be used for the access check below
+            studentParticipation.setParticipant(teamRepository.findWithStudentsByIdElseThrow(team.getId()));
+        }
         if (participation instanceof ProgrammingExerciseParticipation programmingExerciseParticipation) {
             return canAccessProgrammingParticipation(programmingExerciseParticipation, user);
         }

src/main/java/de/tum/in/www1/artemis/service/ParticipationService.java

@@ -439,6 +439,10 @@ private ProgrammingExerciseStudentParticipation configureRepository(ProgrammingE
         if (!participation.getInitializationState().hasCompletedState(InitializationState.REPO_CONFIGURED)) {
             // do not allow the student to access the repository if this is an exam exercise that has not started yet
             boolean allowAccess = !exercise.isExamExercise() || ZonedDateTime.now().isAfter(exercise.getParticipationStartDate());
+            if (participation.getParticipant() instanceof Team team) {
+                // eager load the team with students so their information can be used for the repository configuration
+                participation.setParticipant(teamRepository.findWithStudentsByIdElseThrow(team.getId()));
+            }
             versionControlService.orElseThrow().configureRepository(exercise, participation, allowAccess);
             participation.setInitializationState(InitializationState.REPO_CONFIGURED);
             return programmingExerciseStudentParticipationRepository.saveAndFlush(participation);

src/main/java/de/tum/in/www1/artemis/service/TeamService.java

@@ -83,6 +83,7 @@ public void updateRepositoryMembersIfNeeded(Long exerciseId, Team existingTeam,
         var optionalParticipation = programmingExerciseStudentParticipationRepository.findByExerciseIdAndTeamId(exerciseId, existingTeam.getId());
 
         optionalParticipation.ifPresent(participation -> {
+
             // Users in the existing team that are no longer in the updated team need to be removed
             Set<User> usersToRemove = new HashSet<>(existingTeam.getStudents());
             usersToRemove.removeAll(updatedTeam.getStudents());

src/main/java/de/tum/in/www1/artemis/service/programming/ProgrammingMessagingService.java

@@ -10,6 +10,7 @@
 
 import de.tum.in.www1.artemis.domain.*;
 import de.tum.in.www1.artemis.domain.participation.*;
+import de.tum.in.www1.artemis.repository.TeamRepository;
 import de.tum.in.www1.artemis.service.WebsocketMessagingService;
 import de.tum.in.www1.artemis.service.connectors.lti.LtiNewResultService;
 import de.tum.in.www1.artemis.service.notifications.GroupNotificationService;
@@ -30,12 +31,15 @@ public class ProgrammingMessagingService {
 
     private final Optional<LtiNewResultService> ltiNewResultService;
 
+    private final TeamRepository teamRepository;
+
     public ProgrammingMessagingService(GroupNotificationService groupNotificationService, WebsocketMessagingService websocketMessagingService,
-            ResultWebsocketService resultWebsocketService, Optional<LtiNewResultService> ltiNewResultService) {
+            ResultWebsocketService resultWebsocketService, Optional<LtiNewResultService> ltiNewResultService, TeamRepository teamRepository) {
         this.groupNotificationService = groupNotificationService;
         this.websocketMessagingService = websocketMessagingService;
         this.resultWebsocketService = resultWebsocketService;
         this.ltiNewResultService = ltiNewResultService;
+        this.teamRepository = teamRepository;
     }
 
     public void notifyInstructorAboutStartedExerciseBuildRun(ProgrammingExercise programmingExercise) {
@@ -81,6 +85,10 @@ public void notifyUserAboutSubmissionError(ProgrammingSubmission submission, Bui
      */
     public void notifyUserAboutSubmissionError(Participation participation, BuildTriggerWebsocketError error) {
         if (participation instanceof StudentParticipation studentParticipation) {
+            if (studentParticipation.getParticipant() instanceof Team team) {
+                // eager load the team with students so their information can be used for the messages below
+                studentParticipation.setParticipant(teamRepository.findWithStudentsByIdElseThrow(team.getId()));
+            }
             studentParticipation.getStudents().forEach(user -> websocketMessagingService.sendMessageToUser(user.getLogin(), NEW_SUBMISSION_TOPIC, error));
         }
 

src/main/java/de/tum/in/www1/artemis/service/programming/ProgrammingSubmissionService.java

@@ -160,8 +160,8 @@ public ProgrammingSubmission processNewProgrammingSubmission(ProgrammingExercise
         }
 
         // There can't be two submissions for the same participation and commitHash!
-        ProgrammingSubmission programmingSubmission = programmingSubmissionRepository.findFirstByParticipationIdAndCommitHashOrderByIdDesc(participation.getId(),
-                commit.commitHash());
+        ProgrammingSubmission programmingSubmission = programmingSubmissionRepository
+                .findFirstByParticipationIdAndCommitHashOrderByIdDescWithFeedbacksAndTeamStudents(participation.getId(), commit.commitHash());
         if (programmingSubmission != null) {
             throw new IllegalStateException("Submission for participation id " + participation.getId() + " and commitHash " + commit.commitHash() + " already exists!");
         }
@@ -350,7 +350,8 @@ public ProgrammingSubmission getOrCreateSubmissionWithLastCommitHashForParticipa
             throws IllegalStateException {
         String lastCommitHash = getLastCommitHashForParticipation(participation);
         // we first try to get an existing programming submission with the last commit hash
-        var programmingSubmission = programmingSubmissionRepository.findFirstByParticipationIdAndCommitHashOrderByIdDesc(participation.getId(), lastCommitHash);
+        var programmingSubmission = programmingSubmissionRepository.findFirstByParticipationIdAndCommitHashOrderByIdDescWithFeedbacksAndTeamStudents(participation.getId(),
+                lastCommitHash);
         // in case no programming submission is available, we create one
         return Objects.requireNonNullElseGet(programmingSubmission, () -> createSubmissionWithCommitHashAndSubmissionType(participation, lastCommitHash, submissionType));
     }