fix(backend): MikroORM-probleem bij het opvragen en dan toevoegen van submissions opgelost.

MikroORM genereerde een query met een syntaxfout wanneer men eerst een submission opvraagt en dan toevoegt.

backend/src/controllers/submissions.ts

@@ -4,7 +4,7 @@ import {
     deleteSubmission,
     getAllSubmissions,
     getSubmission,
-    getSubmissionsForLearningObjectAndAssignment, getSubmissionsForLearningObjectAndGroup,
+    getSubmissionsForLearningObjectAndAssignment,
 } from '../services/submissions.js';
 import { SubmissionDTO } from '@dwengo-1/common/interfaces/submission';
 import { Language, languageMap } from '@dwengo-1/common/util/language';
@@ -17,25 +17,17 @@ export async function getSubmissionsHandler(req: Request, res: Response): Promis
     const lang = languageMap[req.query.language as string] || Language.Dutch;
     const version = parseInt(req.query.version as string) ?? 1;
 
+    const forGroup = req.query.forGroup as string | undefined;
+
     let submissions: SubmissionDTO[]
-    if (req.query.groupId) {
-        submissions = await getSubmissionsForLearningObjectAndGroup(
-            loHruid,
-            lang,
-            version,
-            req.query.classId as string,
-            parseInt(req.query.assignmentId as string),
-            parseInt(req.query.groupId as string)
-        );
-    } else {
-        submissions = await getSubmissionsForLearningObjectAndAssignment(
-            loHruid,
-            lang,
-            version,
-            req.query.classId as string,
-            parseInt(req.query.assignmentId as string)
-        )
-    }
+    submissions = await getSubmissionsForLearningObjectAndAssignment(
+        loHruid,
+        lang,
+        version,
+        req.query.classId as string,
+        parseInt(req.query.assignmentId as string),
+        forGroup ? parseInt(forGroup) : undefined
+    );
 
     res.json({ submissions });
 }

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

@@ -61,21 +61,17 @@ 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.
+     * When forGroup is set, only the submissions of the given group are shown.
      */
     public async findAllSubmissionsForLearningObjectAndAssignment(
         loId: LearningObjectIdentifier,
         assignment: Assignment,
-        forStudentUsername?: string
+        forGroup?: number
     ): Promise<Submission[]> {
-        const onBehalfOf = forStudentUsername
+        const onBehalfOf = forGroup
             ? {
                   assignment,
-                  members: {
-                      $some: {
-                          username: forStudentUsername,
-                      },
-                  },
+                  groupNumber: forGroup
               }
             : {
                   assignment,

backend/src/entities/assignments/submission.entity.ts

@@ -18,7 +18,7 @@ export class Submission {
     })
     learningObjectLanguage!: Language;
 
-    @PrimaryKey({ type: 'numeric' })
+    @PrimaryKey({ type: 'numeric', autoincrement: false })
     learningObjectVersion = 1;
 
     @ManyToOne({

backend/src/services/submissions.ts

@@ -1,4 +1,4 @@
-import {getAssignmentRepository, getGroupRepository, getSubmissionRepository} from '../data/repositories.js';
+import {getAssignmentRepository, getSubmissionRepository} from '../data/repositories.js';
 import { LearningObjectIdentifier } from '../entities/content/learning-object-identifier.js';
 import { NotFoundException } from '../exceptions/not-found-exception.js';
 import { mapToSubmission, mapToSubmissionDTO } from '../interfaces/submission.js';
@@ -37,7 +37,11 @@ export async function createSubmission(submissionDTO: SubmissionDTO): Promise<Su
 
     const submissionRepository = getSubmissionRepository();
     const submission = mapToSubmission(submissionDTO, submitter, group);
-    await submissionRepository.save(submission);
+    try {
+        await submissionRepository.save(submission);
+    } catch (e) {
+        "test"
+    }
 
     return mapToSubmissionDTO(submission);
 }
@@ -60,33 +64,12 @@ export async function getSubmissionsForLearningObjectAndAssignment(
     version: number,
     classId: string,
     assignmentId: number,
-    studentUsername?: string
+    groupId?: number
 ): Promise<SubmissionDTO[]> {
     const loId = new LearningObjectIdentifier(learningObjectHruid, language, version);
     const assignment = await getAssignmentRepository().findByClassIdAndAssignmentId(classId, assignmentId);
 
-    const submissions = await getSubmissionRepository().findAllSubmissionsForLearningObjectAndAssignment(loId, assignment!, studentUsername);
+    const submissions = await getSubmissionRepository().findAllSubmissionsForLearningObjectAndAssignment(loId, assignment!, groupId);
 
     return submissions.map((s) => mapToSubmissionDTO(s));
 }
-
-export async function getSubmissionsForLearningObjectAndGroup(
-    learningObjectHruid: string,
-    language: Language,
-    version: number,
-    classId: string,
-    assignmentNo: number,
-    groupNumber: number
-): Promise<SubmissionDTO[]> {
-    const loId = new LearningObjectIdentifier(learningObjectHruid, language, version);
-    const assignment = await getAssignmentRepository().findByClassIdAndAssignmentId(classId, assignmentNo);
-    if (!assignment) {
-        throw new NotFoundException("Assignment not found!");
-    }
-    const group = await getGroupRepository().findByAssignmentAndGroupNumber(assignment, groupNumber);
-    if (!group) {
-        throw new NotFoundException("Group not found!");
-    }
-    const submissions = await getSubmissionRepository().findAllSubmissionsForGroup(group);
-    return submissions.map((s) => mapToSubmissionDTO(s));
-}