Merge branch 'develop' into feature/adaptive-learning/learner-profile

README.md

@@ -47,7 +47,7 @@ Artemis brings interactive learning to life with instant, individual feedback on
    * **Integrated feedback**: Reviews can provide feedback and points directly next to the text segments.
    * **Language detection**: Artemis detects the language of the submission and shows the word and character count. 
 7. **[File upload exercises](https://docs.artemis.cit.tum.de/user/exercises/file-upload/)** allow full flexibility to instructors. Students can create any kind of file (e.g. PDF, PNG) and submit it to Artemis when they have completed their work. Artemis allows instructors and tutors to download the files and assess them manually based on structured grading criteria (see below in the section Assessment).
-8. **[Exam mode](https://docs.artemis.cit.tum.de/user/exam_mode/)**: Instructors can create online exams with exercise variants, integrated plagiarism checks, test runs and student reviews. You can find more information on [Exam mode student features](https://artemis.cit.tum.de/features/students) and on [Exam mode instructor features](https://artemis.cit.tum.de/features/instructors).
+8. **[Exam mode](https://docs.artemis.cit.tum.de/user/exam_mode/)**: Instructors can create online exams with exercise variants, integrated plagiarism checks, test runs and student reviews. You can find more information on [Exam mode student features](https://artemis.tum.de/features/students) and on [Exam mode instructor features](https://artemis.tum.de/features/instructors).
 9. **[Assessment](https://docs.artemis.cit.tum.de/user/exercises/assessment/)**: Artemis uses double-blind grading and structured grading criteria to improve consistency and fairness. 
     * **Training process**: It integrates an assessment training process (based on example submissions and example assessments defined by the instructor), has a grading leader board, and allows students to rate the assessments. Students can complain or ask for more feedback. 
     * **Grading**: Instructors can configure grade keys for courses and exams to automatically calculate grades and display them to students. Grades can be easily exported as csv files to upload them into university systems (such as Campus online). They can define bonus configurations for final exams to improve student grades according to their grades from a midterm exam or course exercises.
@@ -59,7 +59,7 @@ Artemis brings interactive learning to life with instant, individual feedback on
     * **[Adaptive learning](https://docs.artemis.cit.tum.de/user/adaptive-learning)**: Artemis allows instructors and students to define and track competencies. Students can monitor their progress towards these goals, while instructors can provide tailored feedback. This approach integrates lectures and exercises under overarching learning objectives. 
     * **[Learning analytics](https://docs.artemis.cit.tum.de/user/learning-analytics)**: Artemis integrated different statistics for students to compare themselves to the course average. It allows instructors to evaluate the average student performance based on exercises and competencies. 
     * **[Learning paths](https://docs.artemis.cit.tum.de/user/adaptive-learning/adaptive-learning-student.html#learning-paths)**: Based on the competency model and students' individual progress, Artemis creates learning paths that guide students through the course content.
-13. **[Iris](https://artemis.cit.tum.de/about-iris)**: Artemis integrates Iris, a LLM based virtual assistant that supports students and instructors with common questions and tasks.
+13. **[Iris](https://artemis.tum.de/about-iris)**: Artemis integrates Iris, a LLM based virtual assistant that supports students and instructors with common questions and tasks.
     * **Questions**: Iris supports students with answering questions about exercises, lectures, and the learning performance instantly.
     * **Pro-active assistance**: Iris can pro-actively communicate with the students, help them with the next steps in their learning experience and motivate them to continue.
 14. **[Athena](https://github.com/ls1intum/Athena)**: Artemis integrates Athena, a machine learning-based tool that supports instructors with the assessment of text, modeling and programming exercises. Athena offers different modules including automatic feedback suggestions based on generate AI. 
@@ -242,7 +242,7 @@ We communicate using GitHub issues and pull requests. Additionally, you can join
 The following universities are actively using Artemis or are currently evaluating Artemis.
 
 * **Technical University of Munich**  
-  https://artemis.cit.tum.de  
+  https://artemis.tum.de  
   Main contact person: [Stephan Krusche](mailto:krusche@tum.de)  
 
 * **LFU Innsbruck, Uni Salzburg, JKU Linz, AAU Klagenfurt, TU Wien**  

docs/admin/registration.rst

@@ -30,7 +30,7 @@ Example:
                     trust: <host>
     jhipster:
         mail:
-            base-url: https://artemis.cit.tum.de
+            base-url: https://artemis.tum.de
             from: artemis@xcit.tum.de
     management:
         health:

docs/user/exercises/programming-exercise-features.inc

@@ -47,6 +47,8 @@ Instructors can still use those templates to generate programming exercises and
   +----------------------+----------+---------+
   | Go                   | yes      | yes     |
   +----------------------+----------+---------+
+  | Bash                 | yes      | yes     |
+  +----------------------+----------+---------+
 
 - Not all ``templates`` support the same feature set and supported features can also change depending on the continuous integration system setup.
   Depending on the feature set, some options might not be available during the creation of the programming exercise.
@@ -91,6 +93,8 @@ Instructors can still use those templates to generate programming exercises and
   +----------------------+----------------------+----------------------+---------------------+--------------+------------------------------------------+------------------------------+------------------------+
   | Go                   | no                   | no                   | yes                 | yes          | n/a                                      | no                           | L: yes, J: no          |
   +----------------------+----------------------+----------------------+---------------------+--------------+------------------------------------------+------------------------------+------------------------+
+  | Bash                 | no                   | no                   | no                  | no           | n/a                                      | no                           | L: yes, J: no          |
+  +----------------------+----------------------+----------------------+---------------------+--------------+------------------------------------------+------------------------------+------------------------+
 
   - *Sequential Test Runs*: ``Artemis`` can generate a build plan which first executes structural and then behavioral tests. This feature can help students to better concentrate on the immediate challenge at hand.
   - *Static Code Analysis*: ``Artemis`` can generate a build plan which additionally executes static code analysis tools.

docs/user/mobile-applications.rst

@@ -59,7 +59,7 @@ Server Selection
 
 After installation, users have to first decide which Artemis server they want to connect to. Per default, the user can choose between the following instances:
 
-* TUM: https://artemis.cit.tum.de
+* TUM: https://artemis.tum.de
 * CodeAbility: https://artemis.codeability.uibk.ac.at
 * KIT: https://artemis.praktomat.cs.kit.edu
 
@@ -170,7 +170,7 @@ Server Selection
 
 After installation, users have to first decide which Artemis server they want to connect to. Per default, the user can choose between the following instances:
 
-* TUM: https://artemis.cit.tum.de
+* TUM: https://artemis.tum.de
 * CodeAbility: https://artemis.codeability.uibk.ac.at
 * KIT: https://artemis.praktomat.cs.kit.edu
 * Hochschule Munich: https://artemis.cs.hm.edu/

docs/user/orion.rst

@@ -39,8 +39,8 @@ Settings
 
 Orion's settings are at *Settings -> Tools -> Orion*. The settings include:
 
-- Artemis base url: Can be changed to switch to a specific Artemis instance. Defaults to https://artemis.cit.tum.de. **Important:** The url must not end with a ``/``, otherwise it does not work!
-- Artemis git url: Can be changed to switch to a specific Artemis instance. Defaults to https://artemis.cit.tum.de/git
+- Artemis base url: Can be changed to switch to a specific Artemis instance. Defaults to https://artemis.tum.de. **Important:** The url must not end with a ``/``, otherwise it does not work!
+- Artemis git url: Can be changed to switch to a specific Artemis instance. Defaults to https://artemis.tum.de/git
 - Artemis exercise paths: Orion suggests to store newly downloaded exercises at ``default-path/course/exercise-name``, with the default path dependent of the setting.
 - Default commit message: The default message for each commit.
 - Change user agent: The user agent is sent to Artemis to identify Orion. Usually, no changes are required.

src/main/java/de/tum/cit/aet/artemis/programming/domain/ProgrammingLanguage.java

@@ -39,6 +39,7 @@ public enum ProgrammingLanguage {
 
     private static final Set<ProgrammingLanguage> ENABLED_LANGUAGES = Set.of(
         ASSEMBLER,
+        BASH,
         C,
         C_PLUS_PLUS,
         C_SHARP,

src/main/java/de/tum/cit/aet/artemis/programming/repository/ProgrammingExerciseStudentParticipationRepository.java

@@ -78,8 +78,11 @@ Optional<ProgrammingExerciseStudentParticipation> findByIdWithAllResultsAndRelat
 
     List<ProgrammingExerciseStudentParticipation> findAllByExerciseIdAndStudentLogin(long exerciseId, String username);
 
-    default ProgrammingExerciseStudentParticipation findByExerciseIdAndStudentLoginOrThrow(long exerciseId, String username) {
-        return getValueElseThrow(findByExerciseIdAndStudentLogin(exerciseId, username));
+    @EntityGraph(type = LOAD, attributePaths = { "submissions" })
+    Optional<ProgrammingExerciseStudentParticipation> findWithSubmissionsByRepositoryUri(String repositoryUri);
+
+    default ProgrammingExerciseStudentParticipation findWithSubmissionsByRepositoryUriElseThrow(String repositoryUri) {
+        return getValueElseThrow(findWithSubmissionsByRepositoryUri(repositoryUri));
     }
 
     Optional<ProgrammingExerciseStudentParticipation> findByRepositoryUri(String repositoryUri);
@@ -88,41 +91,9 @@ default ProgrammingExerciseStudentParticipation findByRepositoryUriElseThrow(Str
         return getValueElseThrow(findByRepositoryUri(repositoryUri));
     }
 
-    @EntityGraph(type = LOAD, attributePaths = { "submissions" })
-    Optional<ProgrammingExerciseStudentParticipation> findWithSubmissionsByExerciseIdAndStudentLogin(long exerciseId, String username);
-
-    default ProgrammingExerciseStudentParticipation findWithSubmissionsByExerciseIdAndStudentLoginOrThrow(long exerciseId, String username) {
-        return getValueElseThrow(findWithSubmissionsByExerciseIdAndStudentLogin(exerciseId, username));
-    }
-
-    Optional<ProgrammingExerciseStudentParticipation> findByExerciseIdAndStudentLoginAndTestRun(long exerciseId, String username, boolean testRun);
-
     @EntityGraph(type = LOAD, attributePaths = { "team.students" })
     Optional<ProgrammingExerciseStudentParticipation> findByExerciseIdAndTeamId(long exerciseId, long teamId);
 
-    @Query("""
-            SELECT DISTINCT participation
-            FROM ProgrammingExerciseStudentParticipation participation
-                LEFT JOIN FETCH participation.team team
-                LEFT JOIN FETCH team.students
-            WHERE participation.exercise.id = :exerciseId
-                AND participation.team.shortName = :teamShortName
-            """)
-    Optional<ProgrammingExerciseStudentParticipation> findWithEagerStudentsByExerciseIdAndTeamShortName(@Param("exerciseId") long exerciseId,
-            @Param("teamShortName") String teamShortName);
-
-    @Query("""
-            SELECT DISTINCT participation
-            FROM ProgrammingExerciseStudentParticipation participation
-                LEFT JOIN FETCH participation.submissions
-                LEFT JOIN FETCH participation.team team
-                LEFT JOIN FETCH team.students
-            WHERE participation.exercise.id = :exerciseId
-                AND participation.team.shortName = :teamShortName
-            """)
-    Optional<ProgrammingExerciseStudentParticipation> findWithSubmissionsAndEagerStudentsByExerciseIdAndTeamShortName(@Param("exerciseId") long exerciseId,
-            @Param("teamShortName") String teamShortName);
-
     @Query("""
             SELECT DISTINCT participation
             FROM ProgrammingExerciseStudentParticipation participation
@@ -159,17 +130,6 @@ Optional<ProgrammingExerciseStudentParticipation> findWithSubmissionsAndEagerStu
     List<ProgrammingExerciseStudentParticipation> findWithSubmissionsByExerciseIdAndParticipationIds(@Param("exerciseId") long exerciseId,
             @Param("participationIds") Collection<Long> participationIds);
 
-    @Query("""
-            SELECT participation
-            FROM ProgrammingExerciseStudentParticipation participation
-                LEFT JOIN FETCH participation.submissions
-            WHERE participation.exercise.id = :exerciseId
-                AND participation.student.login = :username
-                AND participation.testRun = :testRun
-            """)
-    Optional<ProgrammingExerciseStudentParticipation> findWithSubmissionsByExerciseIdAndStudentLoginAndTestRun(@Param("exerciseId") long exerciseId,
-            @Param("username") String username, @Param("testRun") boolean testRun);
-
     @Query("""
             SELECT participation.repositoryUri
             FROM ProgrammingExerciseStudentParticipation participation

src/main/java/de/tum/cit/aet/artemis/programming/repository/SolutionProgrammingExerciseParticipationRepository.java

@@ -43,12 +43,6 @@ public interface SolutionProgrammingExerciseParticipationRepository
             """)
     Optional<SolutionProgrammingExerciseParticipation> findByBuildPlanIdWithResults(@Param("buildPlanId") String buildPlanId);
 
-    Optional<SolutionProgrammingExerciseParticipation> findByRepositoryUri(String repositoryUri);
-
-    default SolutionProgrammingExerciseParticipation findByRepositoryUriElseThrow(String repositoryUri) {
-        return getValueElseThrow(findByRepositoryUri(repositoryUri));
-    }
-
     @EntityGraph(type = LOAD, attributePaths = { "results", "submissions", "submissions.results" })
     Optional<SolutionProgrammingExerciseParticipation> findWithEagerResultsAndSubmissionsByProgrammingExerciseId(long exerciseId);
 

src/main/java/de/tum/cit/aet/artemis/programming/repository/TemplateProgrammingExerciseParticipationRepository.java

@@ -41,11 +41,11 @@ public interface TemplateProgrammingExerciseParticipationRepository
             """)
     Optional<TemplateProgrammingExerciseParticipation> findByBuildPlanIdWithResults(@Param("buildPlanId") String buildPlanId);
 
-    @EntityGraph(type = LOAD, attributePaths = { "results", "submissions" })
-    Optional<TemplateProgrammingExerciseParticipation> findWithEagerResultsAndSubmissionsByProgrammingExerciseId(long exerciseId);
+    @EntityGraph(type = LOAD, attributePaths = { "submissions" })
+    Optional<TemplateProgrammingExerciseParticipation> findWithSubmissionsByRepositoryUri(String repositoryUri);
 
-    default TemplateProgrammingExerciseParticipation findWithEagerResultsAndSubmissionsByProgrammingExerciseIdElseThrow(long exerciseId) {
-        return getValueElseThrow(findWithEagerResultsAndSubmissionsByProgrammingExerciseId(exerciseId));
+    default TemplateProgrammingExerciseParticipation findWithSubmissionsByRepositoryUriElseThrow(String repositoryUri) {
+        return getValueElseThrow(findWithSubmissionsByRepositoryUri(repositoryUri));
     }
 
     Optional<TemplateProgrammingExerciseParticipation> findByRepositoryUri(String repositoryUri);

src/main/java/de/tum/cit/aet/artemis/programming/repository/VcsAccessLogRepository.java

@@ -27,21 +27,36 @@
 public interface VcsAccessLogRepository extends ArtemisJpaRepository<VcsAccessLog, Long> {
 
     /**
-     * Find the access log entry which does not have any commit hash yet
+     * Retrieves the most recent {@link VcsAccessLog} for a given participation ID.
      *
-     * @param participationId The id of the participation the repository belongs to
-     * @return a log entry belonging to the participationId, which has no commit hash
+     * @param participationId the ID of the participation to filter by.
+     * @return an {@link Optional} containing the newest {@link VcsAccessLog}, or empty if none exists.
      */
     @Query("""
-
             SELECT vcsAccessLog
-                FROM VcsAccessLog vcsAccessLog
-                WHERE vcsAccessLog.participation.id = :participationId
-                ORDER BY vcsAccessLog.timestamp DESC
-                LIMIT 1
+            FROM VcsAccessLog vcsAccessLog
+            WHERE vcsAccessLog.participation.id = :participationId
+            ORDER BY vcsAccessLog.id DESC
+            LIMIT 1
             """)
     Optional<VcsAccessLog> findNewestByParticipationId(@Param("participationId") long participationId);
 
+    /**
+     * Retrieves the most recent {@link VcsAccessLog} for a specific repository URI of a participation.
+     *
+     * @param repositoryUri the URI of the participation to filter by.
+     * @return an Optional containing the newest {@link VcsAccessLog} of the participation, or empty if none exists.
+     */
+    @Query("""
+            SELECT vcsAccessLog
+            FROM VcsAccessLog vcsAccessLog
+                LEFT JOIN TREAT (vcsAccessLog.participation AS ProgrammingExerciseStudentParticipation) participation
+            WHERE participation.repositoryUri = :repositoryUri
+            ORDER BY vcsAccessLog.id DESC
+            LIMIT 1
+            """)
+    Optional<VcsAccessLog> findNewestByRepositoryUri(@Param("repositoryUri") String repositoryUri);
+
     /**
      * Retrieves a list of {@link VcsAccessLog} entities associated with the specified participation ID.
      * The results are ordered by the log ID in ascending order.