merge: fixed merge conflicts with dev

backend/src/data/assignments/assignment-repository.ts

@@ -4,7 +4,7 @@ import { Class } from '../../entities/classes/class.entity.js';
 
 export class AssignmentRepository extends DwengoEntityRepository<Assignment> {
     public async findByClassAndId(within: Class, id: number): Promise<Assignment | null> {
-        return this.findOne({ within: within, id: id });
+        return this.findOne({ within: within, id: id }, { populate: ['groups', 'groups.members'] });
     }
     public async findByClassIdAndAssignmentId(withinClass: string, id: number): Promise<Assignment | null> {
         return this.findOne({ within: { classId: withinClass }, id: id });
@@ -23,7 +23,7 @@ export class AssignmentRepository extends DwengoEntityRepository<Assignment> {
         });
     }
     public async findAllAssignmentsInClass(within: Class): Promise<Assignment[]> {
-        return this.findAll({ where: { within: within } });
+        return this.findAll({ where: { within: within }, populate: ['groups', 'groups.members'] });
     }
     public async deleteByClassAndId(within: Class, id: number): Promise<void> {
         return this.deleteWhere({ within: within, id: id });

backend/src/data/assignments/submission-repository.ts

@@ -61,32 +61,30 @@ export class SubmissionRepository extends DwengoEntityRepository<Submission> {
 
     /**
      * Looks up all submissions for the given learning object which were submitted as part of the given assignment.
-     * When forStudentUsername is set, only the submissions of the given user's group are shown.
      */
-    public async findAllSubmissionsForLearningObjectAndAssignment(
-        loId: LearningObjectIdentifier,
-        assignment: Assignment,
-        forStudentUsername?: string
-    ): Promise<Submission[]> {
-        const onBehalfOf = forStudentUsername
-            ? {
-                  assignment,
-                  members: {
-                      $some: {
-                          username: forStudentUsername,
-                      },
-                  },
-              }
-            : {
-                  assignment,
-              };
-
+    public async findAllSubmissionsForLearningObjectAndAssignment(loId: LearningObjectIdentifier, assignment: Assignment): Promise<Submission[]> {
         return this.findAll({
             where: {
                 learningObjectHruid: loId.hruid,
                 learningObjectLanguage: loId.language,
                 learningObjectVersion: loId.version,
-                onBehalfOf,
+                onBehalfOf: {
+                    assignment,
+                },
+            },
+        });
+    }
+
+    /**
+     * Looks up all submissions for the given learning object which were submitted by the given group
+     */
+    public async findAllSubmissionsForLearningObjectAndGroup(loId: LearningObjectIdentifier, group: Group): Promise<Submission[]> {
+        return this.findAll({
+            where: {
+                learningObjectHruid: loId.hruid,
+                learningObjectLanguage: loId.language,
+                learningObjectVersion: loId.version,
+                onBehalfOf: group,
             },
         });
     }

backend/src/data/content/learning-path-repository.ts

@@ -1,6 +1,10 @@
 import { DwengoEntityRepository } from '../dwengo-entity-repository.js';
 import { LearningPath } from '../../entities/content/learning-path.entity.js';
 import { Language } from '@dwengo-1/common/util/language';
+import { LearningPathNode } from '../../entities/content/learning-path-node.entity.js';
+import { RequiredEntityData } from '@mikro-orm/core';
+import { LearningPathTransition } from '../../entities/content/learning-path-transition.entity.js';
+import { EntityAlreadyExistsException } from '../../exceptions/entity-already-exists-exception.js';
 
 export class LearningPathRepository extends DwengoEntityRepository<LearningPath> {
     public async findByHruidAndLanguage(hruid: string, language: Language): Promise<LearningPath | null> {
@@ -23,4 +27,27 @@ export class LearningPathRepository extends DwengoEntityRepository<LearningPath>
             populate: ['nodes', 'nodes.transitions'],
         });
     }
+
+    public createNode(nodeData: RequiredEntityData<LearningPathNode>): LearningPathNode {
+        return this.em.create(LearningPathNode, nodeData);
+    }
+
+    public createTransition(transitionData: RequiredEntityData<LearningPathTransition>): LearningPathTransition {
+        return this.em.create(LearningPathTransition, transitionData);
+    }
+
+    public async saveLearningPathNodesAndTransitions(
+        path: LearningPath,
+        nodes: LearningPathNode[],
+        transitions: LearningPathTransition[],
+        options?: { preventOverwrite?: boolean }
+    ): Promise<void> {
+        if (options?.preventOverwrite && (await this.findOne(path))) {
+            throw new EntityAlreadyExistsException('A learning path with this hruid/language combination already exists.');
+        }
+        const em = this.getEntityManager();
+        await em.persistAndFlush(path);
+        await Promise.all(nodes.map(async (it) => em.persistAndFlush(it)));
+        await Promise.all(transitions.map(async (it) => em.persistAndFlush(it)));
+    }
 }