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/domain/LtiResourceLaunch.java

@@ -35,7 +35,6 @@ public class LtiResourceLaunch extends DomainObject {
     @ManyToOne
     private User user;
 
-    @NotNull
     @ManyToOne
     private Exercise exercise;
 

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

@@ -62,6 +62,10 @@
 
     private static final String EXERCISE_PATH_PATTERN = "/courses/{courseId}/exercises/{exerciseId}";
 
+    private static final String COMPETENCY_PATH_PATTERN = "/courses/{courseId}/competencies";
+
+    private static final String COURSE_PATH_PATTERN = "/courses/{courseId}";
+
     private static final Logger log = LoggerFactory.getLogger(Lti13Service.class);
 
     private final UserRepository userRepository;
@@ -112,17 +116,18 @@
     public void performLaunch(OidcIdToken ltiIdToken, String clientRegistrationId) {
         String targetLinkUrl = ltiIdToken.getClaim(Claims.TARGET_LINK_URI);
         Optional<Exercise> targetExercise = getExerciseFromTargetLink(targetLinkUrl);
-        if (targetExercise.isEmpty()) {
-            String message = "No exercise to launch at " + targetLinkUrl;
+        Optional<Course> targetCourse = getCourseFromTargetLink(targetLinkUrl);
+
+        if (targetCourse.isEmpty()) {
+            String message = "No course to launch at " + targetLinkUrl;
             log.error(message);
-            throw new BadRequestAlertException("Exercise not found", "LTI", "ltiExerciseNotFound");
+            throw new BadRequestAlertException("Course not found", "LTI", "ltiCourseNotFound");
         }
-        Exercise exercise = targetExercise.get();
 
-        Course course = courseRepository.findByIdWithEagerOnlineCourseConfigurationElseThrow(exercise.getCourseViaExerciseGroupOrCourseMember().getId());
-        OnlineCourseConfiguration onlineCourseConfiguration = course.getOnlineCourseConfiguration();
+        Course course = targetCourse.get();
+        OnlineCourseConfiguration onlineCourseConfiguration = courseRepository.findWithEagerOnlineCourseConfigurationById(course.getId()).getOnlineCourseConfiguration();
         if (onlineCourseConfiguration == null) {
-            String message = "Exercise is not related to course for target link url: " + targetLinkUrl;
+            String message = "LTI is not configured for course with target link URL: " + targetLinkUrl;
             log.error(message);
             throw new BadRequestAlertException("LTI is not configured for this course", "LTI", "ltiNotConfigured");
         }
@@ -133,18 +138,24 @@
         if (!onlineCourseConfiguration.isRequireExistingUser() && optionalUsername.isEmpty()) {
             SecurityContextHolder.getContext().setAuthentication(ltiService.createNewUserFromLaunchRequest(ltiIdToken.getEmail(),
                     createUsernameFromLaunchRequest(ltiIdToken, onlineCourseConfiguration), ltiIdToken.getGivenName(), ltiIdToken.getFamilyName()));
-
         }
 
         String username = optionalUsername.orElseGet(() -> createUsernameFromLaunchRequest(ltiIdToken, onlineCourseConfiguration));
         User user = userRepository.findOneWithGroupsAndAuthoritiesByLogin(username).orElseThrow();
-        ltiService.onSuccessfulLtiAuthentication(user, targetExercise.get());
         Lti13LaunchRequest launchRequest = launchRequestFrom(ltiIdToken, clientRegistrationId);
 
-        createOrUpdateResourceLaunch(launchRequest, user, targetExercise.get());
-
-        ltiService.authenticateLtiUser(ltiIdToken.getEmail(), createUsernameFromLaunchRequest(ltiIdToken, onlineCourseConfiguration), ltiIdToken.getGivenName(),
-                ltiIdToken.getFamilyName(), onlineCourseConfiguration.isRequireExistingUser());
+        if (targetExercise.isPresent()) {
+            Exercise exercise = targetExercise.get();
+            handleLaunchRequest(launchRequest, user, exercise, ltiIdToken, onlineCourseConfiguration);
+        }
+        else if (getCompetencyFromTargetLink(targetLinkUrl)) {
+            handleLaunchRequest(launchRequest, user, null, ltiIdToken, onlineCourseConfiguration);
+        }
+        else {
+            String message = "No exercise or competency to launch at " + targetLinkUrl;
+            log.error(message);
+            throw new BadRequestAlertException("Exercise not found", "LTI", "ltiExerciseNotFound");
+        }
     }
 
     /**
@@ -311,6 +322,59 @@
         return exerciseOpt;
     }
 
+    private Optional<Course> getCourseFromTargetLink(String targetLinkUrl) {
+        AntPathMatcher matcher = new AntPathMatcher();
+
+        String targetLinkPath;
+        try {
+            targetLinkPath = new URI(targetLinkUrl).getPath();
+        }
+        catch (URISyntaxException ex) {
+            log.info("Malformed target link url: {}", targetLinkUrl);
+            return Optional.empty();
+        }
+
+        Map<String, String> pathVariables = null;
+        if (matcher.match(COURSE_PATH_PATTERN, targetLinkPath)) {
+            pathVariables = matcher.extractUriTemplateVariables(COURSE_PATH_PATTERN, targetLinkPath);
+        }
+        else if (matcher.match(COMPETENCY_PATH_PATTERN, targetLinkPath)) {
+            pathVariables = matcher.extractUriTemplateVariables(COMPETENCY_PATH_PATTERN, targetLinkPath);
+        }
+        else if (matcher.match(EXERCISE_PATH_PATTERN, targetLinkPath)) {
+            pathVariables = matcher.extractUriTemplateVariables(EXERCISE_PATH_PATTERN, targetLinkPath);
+        }
+
+        if (pathVariables == null || !pathVariables.containsKey("courseId")) {
+            log.info("Could not extract courseId from target link: {}", targetLinkUrl);
+            return Optional.empty();
+        }
+
+        String courseId = pathVariables.get("courseId");
+        return courseRepository.findById(Long.valueOf(courseId));
+    }
+
+    private boolean getCompetencyFromTargetLink(String targetLinkUrl) {
+        AntPathMatcher matcher = new AntPathMatcher();
+
+        String targetLinkPath;
+        try {
+            targetLinkPath = new URI(targetLinkUrl).getPath();
+        }
+        catch (URISyntaxException ex) {
+            log.info("Malformed target link url: {}", targetLinkUrl);
+            return false;
+        }
+
+        if (!matcher.match(COMPETENCY_PATH_PATTERN, targetLinkPath)) {
+            log.info("Could not extract competency from target link: {}", targetLinkUrl);
+            return false;
+        }
+
+        log.info("Competency link detected: {}", targetLinkUrl);
+        return true;
+    }
+
     private void createOrUpdateResourceLaunch(Lti13LaunchRequest launchRequest, User user, Exercise exercise) {
         Optional<LtiResourceLaunch> launchOpt = launchRepository.findByIssAndSubAndDeploymentIdAndResourceLinkId(launchRequest.iss(), launchRequest.sub(),
                 launchRequest.deploymentId(), launchRequest.resourceLinkId());
@@ -332,6 +396,17 @@
         launchRepository.save(launch);
     }
 
+    private void handleLaunchRequest(Lti13LaunchRequest launchRequest, User user, Exercise exercise, OidcIdToken ltiIdToken, OnlineCourseConfiguration onlineCourseConfiguration) {
+        createOrUpdateResourceLaunch(launchRequest, user, exercise);
+
+        ltiService.authenticateLtiUser(ltiIdToken.getEmail(), createUsernameFromLaunchRequest(ltiIdToken, onlineCourseConfiguration), ltiIdToken.getGivenName(),
+                ltiIdToken.getFamilyName(), onlineCourseConfiguration.isRequireExistingUser());
+
+        if (exercise != null) {
+            ltiService.onSuccessfulLtiAuthentication(user, exercise);
+        }
+    }
+
     /**
      * Build the response for the LTI launch.
      *

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];