Adaptive learning: Allow creating and updating prerequisite competencies

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

@@ -36,6 +36,7 @@
 
 import de.tum.in.www1.artemis.domain.competency.Competency;
 import de.tum.in.www1.artemis.domain.competency.LearningPath;
+import de.tum.in.www1.artemis.domain.competency.Prerequisite;
 import de.tum.in.www1.artemis.domain.enumeration.CourseInformationSharingConfiguration;
 import de.tum.in.www1.artemis.domain.enumeration.Language;
 import de.tum.in.www1.artemis.domain.enumeration.ProgrammingLanguage;
@@ -248,11 +249,10 @@ public class Course extends DomainObject {
     @JsonIgnoreProperties("course")
     private Set<Organization> organizations = new HashSet<>();
 
-    @ManyToMany
-    @JoinTable(name = "competency_course", joinColumns = @JoinColumn(name = "course_id", referencedColumnName = "id"), inverseJoinColumns = @JoinColumn(name = "competency_id", referencedColumnName = "id"))
-    @Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
-    @JsonIgnoreProperties("consecutiveCourses")
-    private Set<Competency> prerequisites = new HashSet<>();
+    @OneToMany(mappedBy = "course", cascade = CascadeType.REMOVE, orphanRemoval = true, fetch = FetchType.LAZY)
+    @JsonIgnoreProperties("course")
+    @OrderBy("title")
+    private Set<Prerequisite> prerequisites = new HashSet<>();
 
     @OneToOne(cascade = CascadeType.REMOVE, orphanRemoval = true, fetch = FetchType.LAZY)
     @JoinColumn(name = "tutorial_groups_configuration_id")
@@ -700,24 +700,14 @@ public void setOrganizations(Set<Organization> organizations) {
         this.organizations = organizations;
     }
 
-    public Set<Competency> getPrerequisites() {
+    public Set<Prerequisite> getPrerequisites() {
         return prerequisites;
     }
 
-    public void setPrerequisites(Set<Competency> prerequisites) {
+    public void setPrerequisites(Set<Prerequisite> prerequisites) {
         this.prerequisites = prerequisites;
     }
 
-    public void addPrerequisite(Competency competency) {
-        this.prerequisites.add(competency);
-        competency.getConsecutiveCourses().add(this);
-    }
-
-    public void removePrerequisite(Competency competency) {
-        this.prerequisites.remove(competency);
-        competency.getConsecutiveCourses().remove(this);
-    }
-
     @Override
     public String toString() {
         return "Course{" + "id=" + getId() + ", title='" + getTitle() + "'" + ", description='" + getDescription() + "'" + ", shortName='" + getShortName() + "'"

src/main/java/de/tum/in/www1/artemis/domain/competency/BaseCompetency.java

@@ -8,6 +8,10 @@
 
 import de.tum.in.www1.artemis.domain.DomainObject;
 
+/**
+ * BaseCompetency is an abstract class that contains basic information shared between all competency types.
+ * It is extended by {@link CourseCompetency} and {@link StandardizedCompetency}
+ */
 @MappedSuperclass
 public abstract class BaseCompetency extends DomainObject {
 

src/main/java/de/tum/in/www1/artemis/domain/competency/Competency.java

@@ -5,50 +5,31 @@
 import java.util.Set;
 
 import jakarta.persistence.CascadeType;
-import jakarta.persistence.Column;
+import jakarta.persistence.DiscriminatorValue;
 import jakarta.persistence.Entity;
 import jakarta.persistence.FetchType;
 import jakarta.persistence.JoinColumn;
-import jakarta.persistence.JoinTable;
 import jakarta.persistence.ManyToMany;
 import jakarta.persistence.ManyToOne;
 import jakarta.persistence.OneToMany;
 import jakarta.persistence.PrePersist;
 import jakarta.persistence.PreUpdate;
-import jakarta.persistence.Table;
 
-import org.hibernate.annotations.Cache;
-import org.hibernate.annotations.CacheConcurrencyStrategy;
-
-import com.fasterxml.jackson.annotation.JsonIgnore;
 import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
 
-import de.tum.in.www1.artemis.domain.Course;
 import de.tum.in.www1.artemis.domain.Exercise;
 import de.tum.in.www1.artemis.domain.lecture.ExerciseUnit;
 import de.tum.in.www1.artemis.domain.lecture.LectureUnit;
 
 @Entity
-@Table(name = "competency")
-@Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
-public class Competency extends BaseCompetency {
-
-    @JsonIgnore
-    public static final int DEFAULT_MASTERY_THRESHOLD = 50;
-
-    @Column(name = "soft_due_date")
-    private ZonedDateTime softDueDate;
-
-    @Column(name = "mastery_threshold")
-    private Integer masteryThreshold;
-
-    @Column(name = "optional")
-    private boolean optional;
+@DiscriminatorValue("C")
+public class Competency extends CourseCompetency {
 
+    // TODO: move properties (linkedStandardizedCompetency, exercises, lectureUnits, userProgress, learningPaths) to CourseCompetency when refactoring
     @ManyToOne
-    @JoinColumn(name = "course_id")
-    @JsonIgnoreProperties({ "competencies", "prerequisites" })
-    private Course course;
+    @JoinColumn(name = "linked_standardized_competency_id")
+    @JsonIgnoreProperties({ "competencies" })
+    private StandardizedCompetency linkedStandardizedCompetency;
 
     @ManyToMany(mappedBy = "competencies")
     @JsonIgnoreProperties({ "competencies", "course" })
@@ -58,15 +39,6 @@ public class Competency extends BaseCompetency {
     @JsonIgnoreProperties("competencies")
     private Set<LectureUnit> lectureUnits = new HashSet<>();
 
-    /**
-     * A set of courses for which this competency is a prerequisite for.
-     */
-    @ManyToMany
-    @JoinTable(name = "competency_course", joinColumns = @JoinColumn(name = "competency_id", referencedColumnName = "id"), inverseJoinColumns = @JoinColumn(name = "course_id", referencedColumnName = "id"))
-    @JsonIgnoreProperties({ "competencies", "prerequisites" })
-    @Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
-    private Set<Course> consecutiveCourses = new HashSet<>();
-
     @OneToMany(mappedBy = "competency", fetch = FetchType.LAZY, cascade = CascadeType.REMOVE, orphanRemoval = true)
     @JsonIgnoreProperties({ "user", "competency" })
     private Set<CompetencyProgress> userProgress = new HashSet<>();
@@ -75,54 +47,22 @@ public class Competency extends BaseCompetency {
     @JsonIgnoreProperties({ "competencies", "course" })
     private Set<LearningPath> learningPaths = new HashSet<>();
 
-    @ManyToOne
-    @JoinColumn(name = "linked_standardized_competency_id")
-    @JsonIgnoreProperties({ "competencies" })
-    private StandardizedCompetency linkedStandardizedCompetency;
-
     @OneToMany(mappedBy = "competency", fetch = FetchType.LAZY, cascade = CascadeType.ALL, orphanRemoval = true)
     private Set<CompetencyJol> competencyJols = new HashSet<>();
 
     public Competency() {
     }
 
     public Competency(String title, String description, ZonedDateTime softDueDate, Integer masteryThreshold, CompetencyTaxonomy taxonomy, boolean optional) {
-        super(title, description, taxonomy);
-        this.softDueDate = softDueDate;
-        this.masteryThreshold = masteryThreshold;
-        this.optional = optional;
-    }
-
-    public ZonedDateTime getSoftDueDate() {
-        return softDueDate;
-    }
-
-    public void setSoftDueDate(ZonedDateTime dueDate) {
-        this.softDueDate = dueDate;
-    }
-
-    public int getMasteryThreshold() {
-        return masteryThreshold == null ? 100 : this.masteryThreshold;
-    }
-
-    public void setMasteryThreshold(Integer masteryThreshold) {
-        this.masteryThreshold = masteryThreshold;
+        super(title, description, softDueDate, masteryThreshold, taxonomy, optional);
     }
 
-    public boolean isOptional() {
-        return optional;
-    }
-
-    public void setOptional(boolean optional) {
-        this.optional = optional;
-    }
-
-    public Course getCourse() {
-        return course;
+    public StandardizedCompetency getLinkedStandardizedCompetency() {
+        return linkedStandardizedCompetency;
     }
 
-    public void setCourse(Course course) {
-        this.course = course;
+    public void setLinkedStandardizedCompetency(StandardizedCompetency linkedStandardizedCompetency) {
+        this.linkedStandardizedCompetency = linkedStandardizedCompetency;
     }
 
     public Set<Exercise> getExercises() {
@@ -163,7 +103,7 @@ public void addLectureUnit(LectureUnit lectureUnit) {
 
     /**
      * Removes the lecture unit from the competency (bidirectional)
-     * Note: ExerciseUnits are not accepted, should be set via the connected exercise (see {@link #removeExercise(Exercise)})
+     * Note: ExerciseUnits are not accepted, should be set via the connected exercise
      *
      * @param lectureUnit The lecture unit to remove
      */
@@ -176,10 +116,6 @@ public void removeLectureUnit(LectureUnit lectureUnit) {
         lectureUnit.getCompetencies().remove(this);
     }
 
-    public Set<Course> getConsecutiveCourses() {
-        return consecutiveCourses;
-    }
-
     public Set<CompetencyProgress> getUserProgress() {
         return userProgress;
     }
@@ -196,14 +132,6 @@ public void setLearningPaths(Set<LearningPath> learningPaths) {
         this.learningPaths = learningPaths;
     }
 
-    public StandardizedCompetency getLinkedStandardizedCompetency() {
-        return linkedStandardizedCompetency;
-    }
-
-    public void setLinkedStandardizedCompetency(StandardizedCompetency linkedStandardizedCompetency) {
-        this.linkedStandardizedCompetency = linkedStandardizedCompetency;
-    }
-
     /**
      * Ensure that exercise units are connected to competencies through the corresponding exercise
      */

src/main/java/de/tum/in/www1/artemis/domain/competency/CourseCompetency.java

@@ -0,0 +1,109 @@
+package de.tum.in.www1.artemis.domain.competency;
+
+import java.time.ZonedDateTime;
+
+import jakarta.persistence.Column;
+import jakarta.persistence.DiscriminatorColumn;
+import jakarta.persistence.DiscriminatorType;
+import jakarta.persistence.Entity;
+import jakarta.persistence.Inheritance;
+import jakarta.persistence.InheritanceType;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.ManyToOne;
+import jakarta.persistence.Table;
+
+import org.hibernate.annotations.Cache;
+import org.hibernate.annotations.CacheConcurrencyStrategy;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+
+import de.tum.in.www1.artemis.domain.Course;
+
+/**
+ * CourseCompetency is an abstract class for all competency types that are part of a course.
+ * It is extended by {@link Competency} and {@link Prerequisite}
+ */
+@Entity
+@Table(name = "competency")
+@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
+@DiscriminatorColumn(name = "discriminator", discriminatorType = DiscriminatorType.STRING)
+@Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
+public abstract class CourseCompetency extends BaseCompetency {
+
+    @JsonIgnore
+    public static final int DEFAULT_MASTERY_THRESHOLD = 100;
+
+    @JsonIgnore
+    public static final int MAX_TITLE_LENGTH = 255;
+
+    @Column(name = "soft_due_date")
+    private ZonedDateTime softDueDate;
+
+    @Column(name = "mastery_threshold")
+    private int masteryThreshold;
+
+    @Column(name = "optional")
+    private boolean optional;
+
+    @ManyToOne
+    @JoinColumn(name = "course_id")
+    @JsonIgnoreProperties({ "competencies", "prerequisites" })
+    private Course course;
+
+    @ManyToOne
+    @JoinColumn(name = "linked_course_competency_id")
+    @JsonIgnoreProperties({ "competencies" })
+    private CourseCompetency linkedCourseCompetency;
+
+    public CourseCompetency() {
+    }
+
+    public CourseCompetency(String title, String description, ZonedDateTime softDueDate, Integer masteryThreshold, CompetencyTaxonomy taxonomy, boolean optional) {
+        super(title, description, taxonomy);
+        this.softDueDate = softDueDate;
+        this.masteryThreshold = masteryThreshold;
+        this.optional = optional;
+    }
+
+    public ZonedDateTime getSoftDueDate() {
+        return softDueDate;
+    }
+
+    public void setSoftDueDate(ZonedDateTime softDueDate) {
+        this.softDueDate = softDueDate;
+    }
+
+    public int getMasteryThreshold() {
+        return masteryThreshold;
+    }
+
+    public void setMasteryThreshold(int masteryThreshold) {
+        this.masteryThreshold = masteryThreshold;
+    }
+
+    public boolean isOptional() {
+        return optional;
+    }
+
+    public void setOptional(boolean optional) {
+        this.optional = optional;
+    }
+
+    @ManyToOne
+    public Course getCourse() {
+        return course;
+    }
+
+    public void setCourse(Course course) {
+        this.course = course;
+    }
+
+    public CourseCompetency getLinkedCourseCompetency() {
+        return linkedCourseCompetency;
+    }
+
+    public void setLinkedCourseCompetency(CourseCompetency linkedCourseCompetency) {
+        this.linkedCourseCompetency = linkedCourseCompetency;
+    }
+}

src/main/java/de/tum/in/www1/artemis/domain/competency/Prerequisite.java

@@ -0,0 +1,21 @@
+package de.tum.in.www1.artemis.domain.competency;
+
+import java.time.ZonedDateTime;
+
+import jakarta.persistence.DiscriminatorValue;
+import jakarta.persistence.Entity;
+
+/**
+ * A competency that students are expected to have mastered before participating in a course.
+ */
+@Entity
+@DiscriminatorValue("P")
+public class Prerequisite extends CourseCompetency {
+
+    public Prerequisite(String title, String description, ZonedDateTime softDueDate, Integer masteryThreshold, CompetencyTaxonomy taxonomy, boolean optional) {
+        super(title, description, softDueDate, masteryThreshold, taxonomy, optional);
+    }
+
+    public Prerequisite() {
+    }
+}