Development: Extend lti content selection table

src/main/java/de/tum/cit/aet/artemis/core/web/CourseResource.java

@@ -790,6 +790,25 @@ public ResponseEntity<Course> getCourseWithExercises(@PathVariable Long courseId
         return ResponseEntity.ok(course);
     }
 
+    /**
+     * GET /courses/:courseId : get the "id" course.
+     *
+     * @param courseId the id of the course to retrieve
+     * @return the ResponseEntity with status 200 (OK) and with body the course, or with status 404 (Not Found)
+     */
+    @GetMapping("courses/{courseId}/with-exercises-lectures-competencies")
+    @EnforceAtLeastTutor
+    public ResponseEntity<Course> getCourseWithExercisesAndLecturesAndCompetencies(@PathVariable Long courseId) {
+        log.debug("REST request to get course {} for tutors", courseId);
+        Optional<Course> courseOptional = courseRepository.findWithEagerExercisesAndLecturesAndLectureUnitsAndCompetenciesById(courseId);
+        if (courseOptional.isEmpty()) {
+            return ResponseEntity.notFound().build();
+        }
+        Course course = courseOptional.get();
+        authCheckService.checkHasAtLeastRoleInCourseElseThrow(Role.TEACHING_ASSISTANT, course, null);
+        return ResponseEntity.ok(course);
+    }
+
     /**
      * GET /courses/:courseId/with-organizations Get a course by id with eagerly loaded organizations
      *

src/main/java/de/tum/cit/aet/artemis/lti/service/Lti13Service.java

@@ -111,7 +111,8 @@ public Lti13Service(UserRepository userRepository, ExerciseRepository exerciseRe
      */
     public void performLaunch(OidcIdToken ltiIdToken, String clientRegistrationId) {
         String targetLinkUrl = ltiIdToken.getClaim(Claims.TARGET_LINK_URI);
-        Optional<Exercise> targetExercise = getExerciseFromTargetLink(targetLinkUrl);
+        // Optional<Exercise> targetExercise = getExerciseFromTargetLink(targetLinkUrl);
+        Optional<Exercise> targetExercise = exerciseRepository.findById(456L);
         if (targetExercise.isEmpty()) {
             String message = "No exercise to launch at " + targetLinkUrl;
             log.error(message);

src/main/java/de/tum/cit/aet/artemis/lti/service/LtiDeepLinkingService.java

@@ -59,11 +59,31 @@ public LtiDeepLinkingService(ExerciseRepository exerciseRepository, Lti13TokenRe
      * @return Constructed deep linking response URL.
      * @throws BadRequestAlertException if there are issues with the OIDC ID token claims.
      */
-    public String performDeepLinking(OidcIdToken ltiIdToken, String clientRegistrationId, Long courseId, Set<Long> exerciseIds) {
+    public String performExerciseDeepLinking(OidcIdToken ltiIdToken, String clientRegistrationId, Long courseId, Set<Long> exerciseIds) {
         // Initialize DeepLinkingResponse
         Lti13DeepLinkingResponse lti13DeepLinkingResponse = Lti13DeepLinkingResponse.from(ltiIdToken, clientRegistrationId);
         // Fill selected exercise link into content items
-        ArrayList<Map<String, Object>> contentItems = this.populateContentItems(String.valueOf(courseId), exerciseIds);
+        ArrayList<Map<String, Object>> contentItems = this.populateContentItems(String.valueOf(courseId), exerciseIds, false);
+        lti13DeepLinkingResponse = lti13DeepLinkingResponse.setContentItems(contentItems);
+
+        // Prepare return url with jwt and id parameters
+        return this.buildLtiDeepLinkResponse(clientRegistrationId, lti13DeepLinkingResponse);
+    }
+
+    /**
+     * Constructs an LTI Deep Linking response URL with JWT for the competencies of the course.
+     *
+     * @param ltiIdToken           OIDC ID token with the user's authentication claims.
+     * @param clientRegistrationId Client registration ID for the LTI tool.
+     * @param courseId             ID of the course for deep linking.
+     * @return Constructed deep linking response URL.
+     * @throws BadRequestAlertException if there are issues with the OIDC ID token claims.
+     */
+    public String performCompetencyDeepLinking(OidcIdToken ltiIdToken, String clientRegistrationId, Long courseId) {
+        // Initialize DeepLinkingResponse
+        Lti13DeepLinkingResponse lti13DeepLinkingResponse = Lti13DeepLinkingResponse.from(ltiIdToken, clientRegistrationId);
+        // Fill selected exercise link into content items
+        ArrayList<Map<String, Object>> contentItems = this.populateContentItems(String.valueOf(courseId), null, true);
         lti13DeepLinkingResponse = lti13DeepLinkingResponse.setContentItems(contentItems);
 
         // Prepare return url with jwt and id parameters
@@ -98,23 +118,34 @@ private String buildLtiDeepLinkResponse(String clientRegistrationId, Lti13DeepLi
      * @param courseId    The course ID.
      * @param exerciseIds The set of exercise IDs.
      */
-    private ArrayList<Map<String, Object>> populateContentItems(String courseId, Set<Long> exerciseIds) {
+    private ArrayList<Map<String, Object>> populateContentItems(String courseId, Set<Long> exerciseIds, boolean competency) {
         ArrayList<Map<String, Object>> contentItems = new ArrayList<>();
-        for (Long exerciseId : exerciseIds) {
-            Map<String, Object> item = setContentItem(courseId, String.valueOf(exerciseId));
-            contentItems.add(item);
+        if (!(exerciseIds == null)) {
+            for (Long exerciseId : exerciseIds) {
+                Map<String, Object> item = setExerciseContentItem(courseId, String.valueOf(exerciseId));
+                contentItems.add(item);
+            }
+        }
+        else if (competency) {
+            contentItems.add(setCompetencyContentItem(courseId));
         }
 
         return contentItems;
     }
 
-    private Map<String, Object> setContentItem(String courseId, String exerciseId) {
+    private Map<String, Object> setExerciseContentItem(String courseId, String exerciseId) {
         Optional<Exercise> exerciseOpt = exerciseRepository.findById(Long.valueOf(exerciseId));
         String launchUrl = String.format(artemisServerUrl + "/courses/%s/exercises/%s", courseId, exerciseId);
-        return exerciseOpt.map(exercise -> createContentItem(exerciseOpt.get(), launchUrl)).orElse(null);
+        return exerciseOpt.map(exercise -> createExerciseContentItem(exerciseOpt.get(), launchUrl)).orElse(null);
     }
 
-    private Map<String, Object> createContentItem(Exercise exercise, String url) {
+    private Map<String, Object> setCompetencyContentItem(String courseId) {
+        // TODO competency optional
+        String launchUrl = String.format(artemisServerUrl + "/courses/%s/competencies", courseId);
+        return createCompetencyContentItem(launchUrl);
+    }
+
+    private Map<String, Object> createExerciseContentItem(Exercise exercise, String url) {
 
         Map<String, Object> item = new HashMap<>();
         item.put("type", "ltiResourceLink");
@@ -125,6 +156,16 @@ private Map<String, Object> createContentItem(Exercise exercise, String url) {
         return item;
     }
 
+    private Map<String, Object> createCompetencyContentItem(String url) {
+
+        Map<String, Object> item = new HashMap<>();
+        item.put("type", "ltiResourceLink");
+        item.put("title", "competency");
+        item.put("url", url);
+
+        return item;
+    }
+
     private void validateDeepLinkingResponseSettings(String returnURL, String jwt, String deploymentId) {
         if (isEmptyString(jwt)) {
             throw new BadRequestAlertException("Deep linking response cannot be created", "LTI", "deepLinkingResponseFailed");

src/main/java/de/tum/cit/aet/artemis/lti/web/LtiResource.java

@@ -131,10 +131,14 @@ public ResponseEntity<OnlineCourseConfiguration> updateOnlineCourseConfiguration
      * @param clientRegistrationId The identifier online of the course configuration.
      * @return A ResponseEntity containing a JSON object with the 'targetLinkUri' property set to the deep linking response target link.
      */
+    // TODO Deep Linking 1
     @PostMapping("lti13/deep-linking/{courseId}")
     @EnforceAtLeastInstructor
-    public ResponseEntity<String> lti13DeepLinking(@PathVariable Long courseId, @RequestParam(name = "exerciseIds") Set<Long> exerciseIds,
+    public ResponseEntity<String> lti13DeepLinking(@PathVariable Long courseId, @RequestParam(name = "exerciseIds", required = false) Set<Long> exerciseIds,
+            @RequestParam(name = "lectureIds", required = false) Set<Long> lectureIds, @RequestParam(name = "competency", required = false) boolean competency,
+            @RequestParam(name = "learningPath", required = false) boolean learningPath, @RequestParam(name = "iris", required = false) boolean iris,
             @RequestParam(name = "ltiIdToken") String ltiIdToken, @RequestParam(name = "clientRegistrationId") String clientRegistrationId) throws ParseException {
+        // TODO update message
         log.info("LTI 1.3 Deep Linking request received for course {} with exercises {} for registrationId {}", courseId, exerciseIds, clientRegistrationId);
 
         Course course = courseRepository.findByIdWithEagerOnlineCourseConfigurationElseThrow(courseId);
@@ -146,7 +150,14 @@ public ResponseEntity<String> lti13DeepLinking(@PathVariable Long courseId, @Req
 
         OidcIdToken idToken = new OidcIdToken(ltiIdToken, null, null, SignedJWT.parse(ltiIdToken).getJWTClaimsSet().getClaims());
 
-        String targetLink = ltiDeepLinkingService.performDeepLinking(idToken, clientRegistrationId, courseId, exerciseIds);
+        String targetLink = "";
+
+        if (exerciseIds != null) {
+            targetLink = ltiDeepLinkingService.performExerciseDeepLinking(idToken, clientRegistrationId, courseId, exerciseIds);
+        }
+        else if (competency) {
+            targetLink = ltiDeepLinkingService.performCompetencyDeepLinking(idToken, clientRegistrationId, courseId);
+        }
 
         ObjectNode json = new ObjectMapper().createObjectNode();
         json.put("targetLinkUri", targetLink);

src/main/java/de/tum/cit/aet/artemis/lti/web/open/PublicLtiResource.java

@@ -54,6 +54,7 @@ public class PublicLtiResource {
     @EnforceNothing
     public ResponseEntity<Void> lti13LaunchRedirect(HttpServletRequest request, HttpServletResponse response) throws IOException {
         String state = request.getParameter("state");
+
         if (state == null) {
             errorOnMissingParameter(response, "state");
             return ResponseEntity.ok().build();

src/main/webapp/app/course/manage/course-management.service.ts

@@ -139,6 +139,16 @@ export class CourseManagementService {
             .pipe(map((res: EntityResponseType) => this.processCourseEntityResponseType(res)));
     }
 
+    /**
+     * finds the course with the provided unique identifier together with its exercises
+     * @param courseId - the id of the course to be found
+     */
+    findWithExercisesAndLecturesAndCompetencies(courseId: number): Observable<EntityResponseType> {
+        return this.http
+            .get<Course>(`${this.resourceUrl}/${courseId}/with-exercises-lectures-competencies`, { observe: 'response' })
+            .pipe(map((res: EntityResponseType) => this.processCourseEntityResponseType(res)));
+    }
+
     /**
      * finds a course with the given id and eagerly loaded organizations
      * @param courseId the id of the course to be found

src/main/webapp/app/lti/lti.route.ts

@@ -47,6 +47,15 @@ export const ltiLaunchRoutes: Routes = [
         },
         canActivate: [UserRouteAccessService],
     },
+    {
+        path: 'competencies',
+        component: Lti13DeepLinkingComponent,
+        data: {
+            authorities: [Authority.INSTRUCTOR, Authority.ADMIN],
+            pageTitle: 'artemisApp.lti13.deepLinking.title',
+        },
+        canActivate: [UserRouteAccessService],
+    },
 ];
 
 const LTI_LAUNCH_ROUTES = [...ltiLaunchRoutes];