Merge pull request #170 from SELab-2/feat/questions-answers-en-submissions-groep-specifiek-maken-#163

feat: `Question`s, `Answer`s en `Submission`s groep-specifiek maken
2025-04-10 21:50:22 +02:00 · 2025-04-10 21:50:22 +02:00 · ec391c9bf0
commit ec391c9bf0
parent 45ca433e09 61424e1ea2
30 changed files with 765 additions and 201 deletions
--- a/backend/src/controllers/questions.ts
+++ b/backend/src/controllers/questions.ts
@ -1,8 +1,15 @@
 import { Request, Response } from 'express';
-import { createQuestion, deleteQuestion, getAllQuestions, getQuestion, updateQuestion } from '../services/questions.js';
+import {
+    createQuestion,
+    deleteQuestion,
+    getAllQuestions,
+    getQuestion,
+    getQuestionsAboutLearningObjectInAssignment,
+    updateQuestion,
+} from '../services/questions.js';
 import { FALLBACK_LANG, FALLBACK_SEQ_NUM, FALLBACK_VERSION_NUM } from '../config.js';
 import { LearningObjectIdentifier } from '../entities/content/learning-object-identifier.js';
-import { QuestionData, QuestionId } from '@dwengo-1/common/interfaces/question';
+import { QuestionData, QuestionDTO, QuestionId } from '@dwengo-1/common/interfaces/question';
 import { Language } from '@dwengo-1/common/util/language';
 import { requireFields } from './error-helper.js';

@ -30,7 +37,18 @@ export async function getAllQuestionsHandler(req: Request, res: Response): Promi

    const learningObjectId = getLearningObjectId(hruid, version, language);

-    const questions = await getAllQuestions(learningObjectId, full);
+    let questions: QuestionDTO[] | QuestionId[];
+    if (req.query.classId && req.query.assignmentId) {
+        questions = await getQuestionsAboutLearningObjectInAssignment(
+            learningObjectId,
+            req.query.classId as string,
+            parseInt(req.query.assignmentId as string),
+            full ?? false,
+            req.query.forStudent as string | undefined
+        );
+    } else {
+        questions = await getAllQuestions(learningObjectId, full ?? false);
+    }

    res.json({ questions });
 }
@ -60,7 +78,8 @@ export async function createQuestionHandler(req: Request, res: Response): Promis

    const author = req.body.author as string;
    const content = req.body.content as string;
-    requireFields({ author, content });
+    const inGroup = req.body.inGroup;
+    requireFields({ author, content, inGroup });

    const questionData = req.body as QuestionData;

--- a/backend/src/controllers/submissions.ts
+++ b/backend/src/controllers/submissions.ts
@ -1,10 +1,32 @@
 import { Request, Response } from 'express';
-import { createSubmission, deleteSubmission, getAllSubmissions, getSubmission } from '../services/submissions.js';
-import { BadRequestException } from '../exceptions/bad-request-exception.js';
-import { LearningObjectIdentifier } from '../entities/content/learning-object-identifier.js';
-import { Language, languageMap } from '@dwengo-1/common/util/language';
+import {
+    createSubmission,
+    deleteSubmission,
+    getAllSubmissions,
+    getSubmission,
+    getSubmissionsForLearningObjectAndAssignment,
+} from '../services/submissions.js';
 import { SubmissionDTO } from '@dwengo-1/common/interfaces/submission';
+import { Language, languageMap } from '@dwengo-1/common/util/language';
+import { BadRequestException } from '../exceptions/bad-request-exception.js';
 import { requireFields } from './error-helper.js';
+import { LearningObjectIdentifier } from '../entities/content/learning-object-identifier.js';
+
+export async function getSubmissionsHandler(req: Request, res: Response): Promise<void> {
+    const loHruid = req.params.hruid;
+    const lang = languageMap[req.query.language as string] || Language.Dutch;
+    const version = parseInt(req.query.version as string) ?? 1;
+
+    const submissions = await getSubmissionsForLearningObjectAndAssignment(
+        loHruid,
+        lang,
+        version,
+        req.query.classId as string,
+        parseInt(req.query.assignmentId as string)
+    );
+
+    res.json(submissions);
+}

 export async function getSubmissionHandler(req: Request, res: Response): Promise<void> {
    const lohruid = req.params.hruid;
--- a/backend/src/data/assignments/assignment-repository.ts
+++ b/backend/src/data/assignments/assignment-repository.ts
@ -6,6 +6,22 @@ export class AssignmentRepository extends DwengoEntityRepository<Assignment> {
    public async findByClassAndId(within: Class, id: number): Promise<Assignment | null> {
        return this.findOne({ within: within, id: id });
    }
+    public async findByClassIdAndAssignmentId(withinClass: string, id: number): Promise<Assignment | null> {
+        return this.findOne({ within: { classId: withinClass }, id: id });
+    }
+    public async findAllByResponsibleTeacher(teacherUsername: string): Promise<Assignment[]> {
+        return this.findAll({
+            where: {
+                within: {
+                    teachers: {
+                        $some: {
+                            username: teacherUsername,
+                        },
+                    },
+                },
+            },
+        });
+    }
    public async findAllAssignmentsInClass(within: Class): Promise<Assignment[]> {
        return this.findAll({ where: { within: within } });
    }
--- a/backend/src/data/assignments/submission-repository.ts
+++ b/backend/src/data/assignments/submission-repository.ts
@ -3,6 +3,7 @@ import { Group } from '../../entities/assignments/group.entity.js';
 import { Submission } from '../../entities/assignments/submission.entity.js';
 import { LearningObjectIdentifier } from '../../entities/content/learning-object-identifier.js';
 import { Student } from '../../entities/users/student.entity.js';
+import { Assignment } from '../../entities/assignments/assignment.entity';

 export class SubmissionRepository extends DwengoEntityRepository<Submission> {
    public async findSubmissionByLearningObjectAndSubmissionNumber(
@ -50,11 +51,58 @@ export class SubmissionRepository extends DwengoEntityRepository<Submission> {
    }

    public async findAllSubmissionsForGroup(group: Group): Promise<Submission[]> {
-        return this.find({ onBehalfOf: group });
+        return this.find(
+            { onBehalfOf: group },
+            {
+                populate: ['onBehalfOf.members'],
+            }
+        );
+    }
+
+    /**
+     * 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,
+              };
+
+        return this.findAll({
+            where: {
+                learningObjectHruid: loId.hruid,
+                learningObjectLanguage: loId.language,
+                learningObjectVersion: loId.version,
+                onBehalfOf,
+            },
+        });
    }

    public async findAllSubmissionsForStudent(student: Student): Promise<Submission[]> {
-        return this.find({ submitter: student });
+        const result = await this.find(
+            { submitter: student },
+            {
+                populate: ['onBehalfOf.members'],
+            }
+        );
+
+        // Workaround: For some reason, without this MikroORM generates an UPDATE query with a syntax error in some tests
+        this.em.clear();
+
+        return result;
    }

    public async deleteSubmissionByLearningObjectAndSubmissionNumber(loId: LearningObjectIdentifier, submissionNumber: number): Promise<void> {
--- a/backend/src/data/questions/question-repository.ts
+++ b/backend/src/data/questions/question-repository.ts
@ -5,14 +5,16 @@ import { Student } from '../../entities/users/student.entity.js';
 import { LearningObject } from '../../entities/content/learning-object.entity.js';
 import { Assignment } from '../../entities/assignments/assignment.entity.js';
 import { Loaded } from '@mikro-orm/core';
+import { Group } from '../../entities/assignments/group.entity';

 export class QuestionRepository extends DwengoEntityRepository<Question> {
-    public async createQuestion(question: { loId: LearningObjectIdentifier; author: Student; content: string }): Promise<Question> {
+    public async createQuestion(question: { loId: LearningObjectIdentifier; author: Student; inGroup: Group; content: string }): Promise<Question> {
        const questionEntity = this.create({
            learningObjectHruid: question.loId.hruid,
            learningObjectLanguage: question.loId.language,
            learningObjectVersion: question.loId.version,
            author: question.author,
+            inGroup: question.inGroup,
            content: question.content,
            timestamp: new Date(),
        });
@ -20,6 +22,7 @@ export class QuestionRepository extends DwengoEntityRepository<Question> {
        questionEntity.learningObjectLanguage = question.loId.language;
        questionEntity.learningObjectVersion = question.loId.version;
        questionEntity.author = question.author;
+        questionEntity.inGroup = question.inGroup;
        questionEntity.content = question.content;
        return this.insert(questionEntity);
    }
@ -59,7 +62,9 @@ export class QuestionRepository extends DwengoEntityRepository<Question> {

    public async findAllByAssignment(assignment: Assignment): Promise<Question[]> {
        return this.find({
-            author: assignment.groups.flatMap((group) => group.members),
+            inGroup: {
+                $contained: assignment.groups,
+            },
            learningObjectHruid: assignment.learningPathHruid,
            learningObjectLanguage: assignment.learningPathLanguage,
        });
@ -72,6 +77,38 @@ export class QuestionRepository extends DwengoEntityRepository<Question> {
        });
    }

+    /**
+     * Looks up all questions for the given learning object which were asked as part of the given assignment.
+     * When forStudentUsername is set, only the questions within the given user's group are shown.
+     */
+    public async findAllQuestionsAboutLearningObjectInAssignment(
+        loId: LearningObjectIdentifier,
+        assignment: Assignment,
+        forStudentUsername?: string
+    ): Promise<Question[]> {
+        const inGroup = forStudentUsername
+            ? {
+                  assignment,
+                  members: {
+                      $some: {
+                          username: forStudentUsername,
+                      },
+                  },
+              }
+            : {
+                  assignment,
+              };
+
+        return this.findAll({
+            where: {
+                learningObjectHruid: loId.hruid,
+                learningObjectLanguage: loId.language,
+                learningObjectVersion: loId.version,
+                inGroup,
+            },
+        });
+    }
+
    public async findByLearningObjectAndSequenceNumber(loId: LearningObjectIdentifier, sequenceNumber: number): Promise<Loaded<Question> | null> {
        return this.findOne({
            learningObjectHruid: loId.hruid,
--- a/backend/src/entities/assignments/assignment.entity.ts
+++ b/backend/src/entities/assignments/assignment.entity.ts
@ -1,4 +1,4 @@
-import { Entity, Enum, ManyToOne, OneToMany, PrimaryKey, Property } from '@mikro-orm/core';
+import { Collection, Entity, Enum, ManyToOne, OneToMany, PrimaryKey, Property } from '@mikro-orm/core';
 import { Class } from '../classes/class.entity.js';
 import { Group } from './group.entity.js';
 import { Language } from '@dwengo-1/common/util/language';
@ -35,5 +35,5 @@ export class Assignment {
        entity: () => Group,
        mappedBy: 'assignment',
    })
-    groups!: Group[];
+    groups!: Collection<Group>;
 }
--- a/backend/src/entities/assignments/group.entity.ts
+++ b/backend/src/entities/assignments/group.entity.ts
@ -1,4 +1,4 @@
-import { Entity, ManyToMany, ManyToOne, PrimaryKey } from '@mikro-orm/core';
+import { Collection, Entity, ManyToMany, ManyToOne, PrimaryKey } from '@mikro-orm/core';
 import { Assignment } from './assignment.entity.js';
 import { Student } from '../users/student.entity.js';
 import { GroupRepository } from '../../data/assignments/group-repository.js';
@ -19,5 +19,5 @@ export class Group {
    @ManyToMany({
        entity: () => Student,
    })
-    members!: Student[];
+    members!: Collection<Student>;
 }
--- a/backend/src/entities/assignments/submission.entity.ts
+++ b/backend/src/entities/assignments/submission.entity.ts
@ -21,6 +21,11 @@ export class Submission {
    @PrimaryKey({ type: 'integer', autoincrement: true })
    submissionNumber?: number;

+    @ManyToOne({
+        entity: () => Group,
+    })
+    onBehalfOf!: Group;
+
    @ManyToOne({
        entity: () => Student,
    })
@ -29,12 +34,6 @@ export class Submission {
    @Property({ type: 'datetime' })
    submissionTime!: Date;

-    @ManyToOne({
-        entity: () => Group,
-        nullable: true,
-    })
-    onBehalfOf?: Group;
-
    @Property({ type: 'json' })
    content!: string;
 }
--- a/backend/src/entities/questions/question.entity.ts
+++ b/backend/src/entities/questions/question.entity.ts
@ -2,6 +2,7 @@ import { Entity, Enum, ManyToOne, PrimaryKey, Property } from '@mikro-orm/core';
 import { Student } from '../users/student.entity.js';
 import { QuestionRepository } from '../../data/questions/question-repository.js';
 import { Language } from '@dwengo-1/common/util/language';
+import { Group } from '../assignments/group.entity.js';

@Entity({ repository: () => QuestionRepository })
 export class Question {
@ -20,6 +21,9 @@ export class Question {
    @PrimaryKey({ type: 'integer', autoincrement: true })
    sequenceNumber?: number;

+    @ManyToOne({ entity: () => Group })
+    inGroup!: Group;
+
    @ManyToOne({
        entity: () => Student,
    })
--- a/backend/src/interfaces/group.ts
+++ b/backend/src/interfaces/group.ts
@ -1,8 +1,24 @@
 import { Group } from '../entities/assignments/group.entity.js';
+import { mapToAssignment } from './assignment.js';
+import { mapToStudent } from './student.js';
 import { mapToAssignmentDTO } from './assignment.js';
-import { mapToClassDTO } from './class.js';
 import { mapToStudentDTO } from './student.js';
 import { GroupDTO } from '@dwengo-1/common/interfaces/group';
+import { getGroupRepository } from '../data/repositories.js';
+import { AssignmentDTO } from '@dwengo-1/common/interfaces/assignment';
+import { Class } from '../entities/classes/class.entity.js';
+import { StudentDTO } from '@dwengo-1/common/interfaces/student';
+import { mapToClassDTO } from './class';
+
+export function mapToGroup(groupDto: GroupDTO, clazz: Class): Group {
+    const assignmentDto = groupDto.assignment as AssignmentDTO;
+
+    return getGroupRepository().create({
+        groupNumber: groupDto.groupNumber,
+        assignment: mapToAssignment(assignmentDto, clazz),
+        members: groupDto.members!.map((studentDto) => mapToStudent(studentDto as StudentDTO)),
+    });
+}

 export function mapToGroupDTO(group: Group): GroupDTO {
    return {
@ -14,6 +30,17 @@ export function mapToGroupDTO(group: Group): GroupDTO {
 }

 export function mapToGroupDTOId(group: Group): GroupDTO {
+    return {
+        class: group.assignment.within.classId!,
+        assignment: group.assignment.id!,
+        groupNumber: group.groupNumber!,
+    };
+}
+
+/**
+ * Map to group DTO where other objects are only referenced by their id.
+ */
+export function mapToShallowGroupDTO(group: Group): GroupDTO {
    return {
        class: group.assignment.within.classId!,
        assignment: group.assignment.id!,
--- a/backend/src/interfaces/question.ts
+++ b/backend/src/interfaces/question.ts
@ -3,6 +3,7 @@ import { mapToStudentDTO } from './student.js';
 import { QuestionDTO, QuestionId } from '@dwengo-1/common/interfaces/question';
 import { LearningObjectIdentifierDTO } from '@dwengo-1/common/interfaces/learning-content';
 import { LearningObjectIdentifier } from '../entities/content/learning-object-identifier.js';
+import { mapToGroupDTOId } from './group.js';

 function getLearningObjectIdentifier(question: Question): LearningObjectIdentifierDTO {
    return {
@ -30,6 +31,7 @@ export function mapToQuestionDTO(question: Question): QuestionDTO {
        learningObjectIdentifier,
        sequenceNumber: question.sequenceNumber!,
        author: mapToStudentDTO(question.author),
+        inGroup: mapToGroupDTOId(question.inGroup),
        timestamp: question.timestamp.toISOString(),
        content: question.content,
    };
--- a/backend/src/interfaces/submission.ts
+++ b/backend/src/interfaces/submission.ts
@ -1,10 +1,10 @@
-import { getSubmissionRepository } from '../data/repositories.js';
-import { Group } from '../entities/assignments/group.entity.js';
 import { Submission } from '../entities/assignments/submission.entity.js';
-import { Student } from '../entities/users/student.entity.js';
 import { mapToGroupDTO } from './group.js';
 import { mapToStudentDTO } from './student.js';
 import { SubmissionDTO, SubmissionDTOId } from '@dwengo-1/common/interfaces/submission';
+import { getSubmissionRepository } from '../data/repositories';
+import { Student } from '../entities/users/student.entity';
+import { Group } from '../entities/assignments/group.entity';

 export function mapToSubmissionDTO(submission: Submission): SubmissionDTO {
    return {
@ -17,7 +17,7 @@ export function mapToSubmissionDTO(submission: Submission): SubmissionDTO {
        submissionNumber: submission.submissionNumber,
        submitter: mapToStudentDTO(submission.submitter),
        time: submission.submissionTime,
-        group: submission.onBehalfOf ? mapToGroupDTO(submission.onBehalfOf) : undefined,
+        group: mapToGroupDTO(submission.onBehalfOf),
        content: submission.content,
    };
 }
@ -32,7 +32,7 @@ export function mapToSubmissionDTOId(submission: Submission): SubmissionDTOId {
    };
 }

-export function mapToSubmission(submissionDTO: SubmissionDTO, submitter: Student, onBehalfOf: Group | undefined): Submission {
+export function mapToSubmission(submissionDTO: SubmissionDTO, submitter: Student, onBehalfOf: Group): Submission {
    return getSubmissionRepository().create({
        learningObjectHruid: submissionDTO.learningObjectIdentifier.hruid,
        learningObjectLanguage: submissionDTO.learningObjectIdentifier.language,
--- a/backend/src/routes/submissions.ts
+++ b/backend/src/routes/submissions.ts
@ -1,9 +1,9 @@
 import express from 'express';
-import { createSubmissionHandler, deleteSubmissionHandler, getAllSubmissionsHandler, getSubmissionHandler } from '../controllers/submissions.js';
+import { createSubmissionHandler, deleteSubmissionHandler, getSubmissionHandler, getSubmissionsHandler } from '../controllers/submissions.js';
 const router = express.Router({ mergeParams: true });

 // Root endpoint used to search objects
-router.get('/', getAllSubmissionsHandler);
+router.get('/', getSubmissionsHandler);

 router.post('/:id', createSubmissionHandler);

--- a/backend/src/services/groups.ts
+++ b/backend/src/services/groups.ts
@ -1,7 +1,7 @@
 import { EntityDTO } from '@mikro-orm/core';
 import { getGroupRepository, getStudentRepository, getSubmissionRepository } from '../data/repositories.js';
 import { Group } from '../entities/assignments/group.entity.js';
-import { mapToGroupDTO, mapToGroupDTOId } from '../interfaces/group.js';
+import { mapToGroupDTO, mapToShallowGroupDTO } from '../interfaces/group.js';
 import { mapToSubmissionDTO, mapToSubmissionDTOId } from '../interfaces/submission.js';
 import { GroupDTO } from '@dwengo-1/common/interfaces/group';
 import { SubmissionDTO, SubmissionDTOId } from '@dwengo-1/common/interfaces/submission';
@ -88,7 +88,7 @@ export async function getAllGroups(classId: string, assignmentNumber: number, fu
        return groups.map(mapToGroupDTO);
    }

-    return groups.map(mapToGroupDTOId);
+    return groups.map(mapToShallowGroupDTO);
 }

 export async function getGroupSubmissions(
--- a/backend/src/services/questions.ts
+++ b/backend/src/services/questions.ts
@ -1,12 +1,34 @@
-import { getQuestionRepository } from '../data/repositories.js';
+import { getAnswerRepository, getAssignmentRepository, getClassRepository, getGroupRepository, getQuestionRepository } from '../data/repositories.js';
 import { mapToLearningObjectID, mapToQuestionDTO, mapToQuestionDTOId } from '../interfaces/question.js';
 import { Question } from '../entities/questions/question.entity.js';
+import { Answer } from '../entities/questions/answer.entity.js';
+import { mapToAnswerDTO, mapToAnswerDTOId } from '../interfaces/answer.js';
 import { QuestionRepository } from '../data/questions/question-repository.js';
 import { LearningObjectIdentifier } from '../entities/content/learning-object-identifier.js';
 import { QuestionData, QuestionDTO, QuestionId } from '@dwengo-1/common/interfaces/question';
-import { NotFoundException } from '../exceptions/not-found-exception.js';
-import { FALLBACK_VERSION_NUM } from '../config.js';
+import { AnswerDTO, AnswerId } from '@dwengo-1/common/interfaces/answer';
+import { mapToAssignment } from '../interfaces/assignment.js';
+import { AssignmentDTO } from '@dwengo-1/common/interfaces/assignment';
 import { fetchStudent } from './students.js';
+import { NotFoundException } from '../exceptions/not-found-exception';
+import { FALLBACK_VERSION_NUM } from '../config.js';
+
+export async function getQuestionsAboutLearningObjectInAssignment(
+    loId: LearningObjectIdentifier,
+    classId: string,
+    assignmentId: number,
+    full: boolean,
+    studentUsername?: string
+): Promise<QuestionDTO[] | QuestionId[]> {
+    const assignment = await getAssignmentRepository().findByClassIdAndAssignmentId(classId, assignmentId);
+
+    const questions = await getQuestionRepository().findAllQuestionsAboutLearningObjectInAssignment(loId, assignment!, studentUsername);
+
+    if (full) {
+        return questions.map((q) => mapToQuestionDTO(q));
+    }
+    return questions.map((q) => mapToQuestionDTOId(q));
+}

 export async function getAllQuestions(id: LearningObjectIdentifier, full: boolean): Promise<QuestionDTO[] | QuestionId[]> {
    const questionRepository: QuestionRepository = getQuestionRepository();
@ -38,14 +60,40 @@ export async function getQuestion(questionId: QuestionId): Promise<QuestionDTO>
    return mapToQuestionDTO(question);
 }

+export async function getAnswersByQuestion(questionId: QuestionId, full: boolean): Promise<AnswerDTO[] | AnswerId[]> {
+    const answerRepository = getAnswerRepository();
+    const question = await fetchQuestion(questionId);
+
+    if (!question) {
+        return [];
+    }
+
+    const answers: Answer[] = await answerRepository.findAllAnswersToQuestion(question);
+
+    if (!answers) {
+        return [];
+    }
+
+    if (full) {
+        return answers.map(mapToAnswerDTO);
+    }
+
+    return answers.map(mapToAnswerDTOId);
+}
+
 export async function createQuestion(loId: LearningObjectIdentifier, questionData: QuestionData): Promise<QuestionDTO> {
    const questionRepository = getQuestionRepository();
    const author = await fetchStudent(questionData.author!);
    const content = questionData.content;

+    const clazz = await getClassRepository().findById((questionData.inGroup.assignment as AssignmentDTO).within);
+    const assignment = mapToAssignment(questionData.inGroup.assignment as AssignmentDTO, clazz!);
+    const inGroup = await getGroupRepository().findByAssignmentAndGroupNumber(assignment, questionData.inGroup.groupNumber);
+
    const question = await questionRepository.createQuestion({
        loId,
        author,
+        inGroup: inGroup!,
        content,
    });

--- a/backend/src/services/students.ts
+++ b/backend/src/services/students.ts
@ -7,7 +7,7 @@ import {
    getSubmissionRepository,
 } from '../data/repositories.js';
 import { mapToClassDTO } from '../interfaces/class.js';
-import { mapToGroupDTO, mapToGroupDTOId } from '../interfaces/group.js';
+import { mapToGroupDTO, mapToShallowGroupDTO } from '../interfaces/group.js';
 import { mapToStudent, mapToStudentDTO } from '../interfaces/student.js';
 import { mapToSubmissionDTO, mapToSubmissionDTOId } from '../interfaces/submission.js';
 import { getAllAssignments } from './assignments.js';
@ -24,6 +24,7 @@ import { SubmissionDTO, SubmissionDTOId } from '@dwengo-1/common/interfaces/subm
 import { QuestionDTO, QuestionId } from '@dwengo-1/common/interfaces/question';
 import { ClassJoinRequestDTO } from '@dwengo-1/common/interfaces/class-join-request';
 import { ConflictException } from '../exceptions/conflict-exception.js';
+import { Submission } from '../entities/assignments/submission.entity';

 export async function getAllStudents(full: boolean): Promise<StudentDTO[] | string[]> {
    const studentRepository = getStudentRepository();
@ -101,14 +102,15 @@ export async function getStudentGroups(username: string, full: boolean): Promise
        return groups.map(mapToGroupDTO);
    }

-    return groups.map(mapToGroupDTOId);
+    return groups.map(mapToShallowGroupDTO);
 }

 export async function getStudentSubmissions(username: string, full: boolean): Promise<SubmissionDTO[] | SubmissionDTOId[]> {
    const student = await fetchStudent(username);

    const submissionRepository = getSubmissionRepository();
-    const submissions = await submissionRepository.findAllSubmissionsForStudent(student);
+
+    const submissions: Submission[] = await submissionRepository.findAllSubmissionsForStudent(student);

    if (full) {
        return submissions.map(mapToSubmissionDTO);
--- a/backend/src/services/submissions.ts
+++ b/backend/src/services/submissions.ts
@ -1,4 +1,4 @@
-import { 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';
@ -6,6 +6,7 @@ import { SubmissionDTO } from '@dwengo-1/common/interfaces/submission';
 import { fetchStudent } from './students.js';
 import { getExistingGroupFromGroupDTO } from './groups.js';
 import { Submission } from '../entities/assignments/submission.entity.js';
+import { Language } from '@dwengo-1/common/util/language';

 export async function fetchSubmission(loId: LearningObjectIdentifier, submissionNumber: number): Promise<Submission> {
    const submissionRepository = getSubmissionRepository();
@ -32,7 +33,7 @@ export async function getAllSubmissions(loId: LearningObjectIdentifier): Promise

 export async function createSubmission(submissionDTO: SubmissionDTO): Promise<SubmissionDTO> {
    const submitter = await fetchStudent(submissionDTO.submitter.username);
-    const group = submissionDTO.group ? await getExistingGroupFromGroupDTO(submissionDTO.group) : undefined;
+    const group = await getExistingGroupFromGroupDTO(submissionDTO.group);

    const submissionRepository = getSubmissionRepository();
    const submission = mapToSubmission(submissionDTO, submitter, group);
@ -49,3 +50,22 @@ export async function deleteSubmission(loId: LearningObjectIdentifier, submissio

    return mapToSubmissionDTO(submission);
 }
+
+/**
+ * Returns all the submissions made by on behalf of any group the given student is in.
+ */
+export async function getSubmissionsForLearningObjectAndAssignment(
+    learningObjectHruid: string,
+    language: Language,
+    version: number,
+    classId: string,
+    assignmentId: number,
+    studentUsername?: string
+): Promise<SubmissionDTO[]> {
+    const loId = new LearningObjectIdentifier(learningObjectHruid, language, version);
+    const assignment = await getAssignmentRepository().findByClassIdAndAssignmentId(classId, assignmentId);
+
+    const submissions = await getSubmissionRepository().findAllSubmissionsForLearningObjectAndAssignment(loId, assignment!, studentUsername);
+
+    return submissions.map((s) => mapToSubmissionDTO(s));
+}
--- a/backend/tests/data/assignments/assignments.test.ts
+++ b/backend/tests/data/assignments/assignments.test.ts
@ -31,6 +31,13 @@ describe('AssignmentRepository', () => {
        expect(assignments[0].title).toBe('tool');
    });

+    it('should find all by username of the responsible teacher', async () => {
+        const result = await assignmentRepository.findAllByResponsibleTeacher('testleerkracht1');
+        const resultIds = result.map((it) => it.id).sort((a, b) => (a ?? 0) - (b ?? 0));
+
+        expect(resultIds).toEqual([1, 3, 4]);
+    });
+
    it('should not find removed assignment', async () => {
        const class_ = await classRepository.findById('id01');
        await assignmentRepository.deleteByClassAndId(class_!, 3);
--- a/backend/tests/data/assignments/submissions.test.ts
+++ b/backend/tests/data/assignments/submissions.test.ts
@ -14,6 +14,9 @@ import { StudentRepository } from '../../../src/data/users/student-repository';
 import { GroupRepository } from '../../../src/data/assignments/group-repository';
 import { AssignmentRepository } from '../../../src/data/assignments/assignment-repository';
 import { ClassRepository } from '../../../src/data/classes/class-repository';
+import { Submission } from '../../../src/entities/assignments/submission.entity';
+import { Class } from '../../../src/entities/classes/class.entity';
+import { Assignment } from '../../../src/entities/assignments/assignment.entity';

 describe('SubmissionRepository', () => {
    let submissionRepository: SubmissionRepository;
@ -59,6 +62,49 @@ describe('SubmissionRepository', () => {
        expect(submission?.submissionTime.getDate()).toBe(25);
    });

+    let clazz: Class | null;
+    let assignment: Assignment | null;
+    let loId: LearningObjectIdentifier;
+    it('should find all submissions for a certain learning object and assignment', async () => {
+        clazz = await classRepository.findById('8764b861-90a6-42e5-9732-c0d9eb2f55f9');
+        assignment = await assignmentRepository.findByClassAndId(clazz!, 1);
+        loId = {
+            hruid: 'id02',
+            language: Language.English,
+            version: 1,
+        };
+        const result = await submissionRepository.findAllSubmissionsForLearningObjectAndAssignment(loId, assignment!);
+        sortSubmissions(result);
+
+        expect(result).toHaveLength(3);
+
+        // Submission3 should be found (for learning object 'id02' by group #1 for Assignment #1 in class 'id01')
+        expect(result[0].learningObjectHruid).toBe(loId.hruid);
+        expect(result[0].submissionNumber).toBe(1);
+
+        // Submission4 should be found (for learning object 'id02' by group #1 for Assignment #1 in class 'id01')
+        expect(result[1].learningObjectHruid).toBe(loId.hruid);
+        expect(result[1].submissionNumber).toBe(2);
+
+        // Submission8 should be found (for learning object 'id02' by group #2 for Assignment #1 in class 'id01')
+        expect(result[2].learningObjectHruid).toBe(loId.hruid);
+        expect(result[2].submissionNumber).toBe(3);
+    });
+
+    it("should find only the submissions for a certain learning object and assignment made for the user's group", async () => {
+        const result = await submissionRepository.findAllSubmissionsForLearningObjectAndAssignment(loId, assignment!, 'Tool');
+        // (student Tool is in group #2)
+
+        expect(result).toHaveLength(1);
+
+        // Submission8 should be found (for learning object 'id02' by group #2 for Assignment #1 in class 'id01')
+        expect(result[0].learningObjectHruid).toBe(loId.hruid);
+        expect(result[0].submissionNumber).toBe(3);
+
+        // The other submissions found in the previous test case should not be found anymore as they were made on
+        // Behalf of group #1 which Tool is no member of.
+    });
+
    it('should not find a deleted submission', async () => {
        const id = new LearningObjectIdentifier('id01', Language.English, 1);
        await submissionRepository.deleteSubmissionByLearningObjectAndSubmissionNumber(id, 1);
@ -68,3 +114,15 @@ describe('SubmissionRepository', () => {
        expect(submission).toBeNull();
    });
 });
+
+function sortSubmissions(submissions: Submission[]): void {
+    submissions.sort((a, b) => {
+        if (a.learningObjectHruid < b.learningObjectHruid) {
+            return -1;
+        }
+        if (a.learningObjectHruid > b.learningObjectHruid) {
+            return 1;
+        }
+        return a.submissionNumber! - b.submissionNumber!;
+    });
+}
--- a/backend/tests/data/questions/questions.test.ts
+++ b/backend/tests/data/questions/questions.test.ts
@ -1,10 +1,19 @@
 import { beforeAll, describe, expect, it } from 'vitest';
 import { setupTestApp } from '../../setup-tests';
 import { QuestionRepository } from '../../../src/data/questions/question-repository';
-import { getQuestionRepository, getStudentRepository } from '../../../src/data/repositories';
+import {
+    getAssignmentRepository,
+    getClassRepository,
+    getGroupRepository,
+    getQuestionRepository,
+    getStudentRepository,
+} from '../../../src/data/repositories';
 import { StudentRepository } from '../../../src/data/users/student-repository';
 import { LearningObjectIdentifier } from '../../../src/entities/content/learning-object-identifier';
 import { Language } from '@dwengo-1/common/util/language';
+import { Question } from '../../../src/entities/questions/question.entity';
+import { Class } from '../../../src/entities/classes/class.entity';
+import { Assignment } from '../../../src/entities/assignments/assignment.entity';

 describe('QuestionRepository', () => {
    let questionRepository: QuestionRepository;
@ -21,14 +30,19 @@ describe('QuestionRepository', () => {
        const questions = await questionRepository.findAllQuestionsAboutLearningObject(id);

        expect(questions).toBeTruthy();
-        expect(questions).toHaveLength(2);
+        expect(questions).toHaveLength(4);
    });

    it('should create new question', async () => {
        const id = new LearningObjectIdentifier('id03', Language.English, 1);
        const student = await studentRepository.findByUsername('Noordkaap');
+
+        const clazz = await getClassRepository().findById('8764b861-90a6-42e5-9732-c0d9eb2f55f9');
+        const assignment = await getAssignmentRepository().findByClassAndId(clazz!, 1);
+        const group = await getGroupRepository().findByAssignmentAndGroupNumber(assignment!, 1);
        await questionRepository.createQuestion({
            loId: id,
+            inGroup: group!,
            author: student!,
            content: 'question?',
        });
@ -38,6 +52,52 @@ describe('QuestionRepository', () => {
        expect(question).toHaveLength(1);
    });

+    let clazz: Class | null;
+    let assignment: Assignment | null;
+    let loId: LearningObjectIdentifier;
+    it('should find all questions for a certain learning object and assignment', async () => {
+        clazz = await getClassRepository().findById('8764b861-90a6-42e5-9732-c0d9eb2f55f9');
+        assignment = await getAssignmentRepository().findByClassAndId(clazz!, 1);
+        loId = {
+            hruid: 'id05',
+            language: Language.English,
+            version: 1,
+        };
+        const result = await questionRepository.findAllQuestionsAboutLearningObjectInAssignment(loId, assignment!);
+        sortQuestions(result);
+
+        expect(result).toHaveLength(3);
+
+        // Question01: About learning object 'id05', in group #1 for Assignment #1 in class 'id01'
+        expect(result[0].learningObjectHruid).toEqual(loId.hruid);
+        expect(result[0].sequenceNumber).toEqual(1);
+
+        // Question02: About learning object 'id05', in group #1 for Assignment #1 in class 'id01'
+        expect(result[1].learningObjectHruid).toEqual(loId.hruid);
+        expect(result[1].sequenceNumber).toEqual(2);
+
+        // Question05: About learning object 'id05', in group #2 for Assignment #1 in class 'id01'
+        expect(result[2].learningObjectHruid).toEqual(loId.hruid);
+        expect(result[2].sequenceNumber).toEqual(3);
+
+        // Question06: About learning object 'id05', but for Assignment #2 in class 'id01' => not expected.
+    });
+
+    it("should find only the questions for a certain learning object and assignment asked by the user's group", async () => {
+        const result = await questionRepository.findAllQuestionsAboutLearningObjectInAssignment(loId, assignment!, 'Tool');
+        // (student Tool is in group #2)
+
+        expect(result).toHaveLength(1);
+
+        // Question01 and question02 are in group #1 => not displayed.
+
+        // Question05: About learning object 'id05', in group #2 for Assignment #1 in class 'id01'
+        expect(result[0].learningObjectHruid).toEqual(loId.hruid);
+        expect(result[0].sequenceNumber).toEqual(3);
+
+        // Question06: About learning object 'id05', but for Assignment #2 in class 'id01' => not expected.
+    });
+
    it('should not find removed question', async () => {
        const id = new LearningObjectIdentifier('id04', Language.English, 1);
        await questionRepository.removeQuestionByLearningObjectAndSequenceNumber(id, 1);
@ -47,3 +107,14 @@ describe('QuestionRepository', () => {
        expect(question).toHaveLength(0);
    });
 });
+
+function sortQuestions(questions: Question[]): void {
+    questions.sort((a, b) => {
+        if (a.learningObjectHruid < b.learningObjectHruid) {
+            return -1;
+        } else if (a.learningObjectHruid > b.learningObjectHruid) {
+            return 1;
+        }
+        return a.sequenceNumber! - b.sequenceNumber!;
+    });
+}
--- a/backend/tests/services/learning-path/database-learning-path-provider.test.ts
+++ b/backend/tests/services/learning-path/database-learning-path-provider.test.ts
@ -3,6 +3,9 @@ import { LearningObject } from '../../../src/entities/content/learning-object.en
 import { setupTestApp } from '../../setup-tests.js';
 import { LearningPath } from '../../../src/entities/content/learning-path.entity.js';
 import {
+    getAssignmentRepository,
+    getClassRepository,
+    getGroupRepository,
    getLearningObjectRepository,
    getLearningPathRepository,
    getStudentRepository,
@ -22,6 +25,10 @@ import { Student } from '../../../src/entities/users/student.entity.js';

 import { LearningObjectNode, LearningPathResponse } from '@dwengo-1/common/interfaces/learning-content';

+const STUDENT_A_USERNAME = 'student_a';
+const STUDENT_B_USERNAME = 'student_b';
+const CLASS_NAME = 'test_class';
+
 async function initExampleData(): Promise<{ learningObject: LearningObject; learningPath: LearningPath }> {
    const learningObjectRepo = getLearningObjectRepository();
    const learningPathRepo = getLearningPathRepository();
@ -38,6 +45,9 @@ async function initPersonalizationTestData(): Promise<{
    studentB: Student;
 }> {
    const studentRepo = getStudentRepository();
+    const classRepo = getClassRepository();
+    const assignmentRepo = getAssignmentRepository();
+    const groupRepo = getGroupRepository();
    const submissionRepo = getSubmissionRepository();
    const learningPathRepo = getLearningPathRepository();
    const learningObjectRepo = getLearningObjectRepository();
@ -47,32 +57,69 @@ async function initPersonalizationTestData(): Promise<{
    await learningObjectRepo.save(learningContent.extraExerciseObject);
    await learningPathRepo.save(learningContent.learningPath);

+    // Create students
    const studentA = studentRepo.create({
-        username: 'student_a',
+        username: STUDENT_A_USERNAME,
        firstName: 'Aron',
        lastName: 'Student',
    });
    await studentRepo.save(studentA);
+
+    const studentB = studentRepo.create({
+        username: STUDENT_B_USERNAME,
+        firstName: 'Bill',
+        lastName: 'Student',
+    });
+    await studentRepo.save(studentB);
+
+    // Create class for students
+    const testClass = classRepo.create({
+        classId: CLASS_NAME,
+        displayName: 'Test class',
+    });
+    await classRepo.save(testClass);
+
+    // Create assignment for students and assign them to different groups
+    const assignment = assignmentRepo.create({
+        id: 0,
+        title: 'Test assignment',
+        description: 'Test description',
+        learningPathHruid: learningContent.learningPath.hruid,
+        learningPathLanguage: learningContent.learningPath.language,
+        within: testClass,
+    });
+
+    const groupA = groupRepo.create({
+        groupNumber: 0,
+        members: [studentA],
+        assignment,
+    });
+    await groupRepo.save(groupA);
+
+    const groupB = groupRepo.create({
+        groupNumber: 1,
+        members: [studentB],
+        assignment,
+    });
+    await groupRepo.save(groupB);
+
+    // Let each of the students make a submission in his own group.
    const submissionA = submissionRepo.create({
        learningObjectHruid: learningContent.branchingObject.hruid,
        learningObjectLanguage: learningContent.branchingObject.language,
        learningObjectVersion: learningContent.branchingObject.version,
+        onBehalfOf: groupA,
        submitter: studentA,
        submissionTime: new Date(),
        content: '[0]',
    });
    await submissionRepo.save(submissionA);

-    const studentB = studentRepo.create({
-        username: 'student_b',
-        firstName: 'Bill',
-        lastName: 'Student',
-    });
-    await studentRepo.save(studentB);
    const submissionB = submissionRepo.create({
        learningObjectHruid: learningContent.branchingObject.hruid,
        learningObjectLanguage: learningContent.branchingObject.language,
        learningObjectVersion: learningContent.branchingObject.version,
+        onBehalfOf: groupA,
        submitter: studentB,
        submissionTime: new Date(),
        content: '[1]',
--- a/backend/tests/setup-tests.ts
+++ b/backend/tests/setup-tests.ts
@ -37,7 +37,7 @@ export async function setupTestApp(): Promise<void> {

    learningObjects[1].attachments = attachments;

-    const questions = makeTestQuestions(em, students);
+    const questions = makeTestQuestions(em, students, groups);
    const answers = makeTestAnswers(em, teachers, questions);
    const submissions = makeTestSubmissions(em, students, groups);

--- a/backend/tests/test_assets/assignments/assignments.testdata.ts
+++ b/backend/tests/test_assets/assignments/assignments.testdata.ts
@ -34,5 +34,15 @@ export function makeTestAssignemnts(em: EntityManager, classes: Class[]): Assign
        groups: [],
    });

-    return [assignment01, assignment02, assignment03];
+    const assignment04 = em.create(Assignment, {
+        within: classes[0],
+        id: 4,
+        title: 'another assignment',
+        description: 'with a description',
+        learningPathHruid: 'id01',
+        learningPathLanguage: Language.English,
+        groups: [],
+    });
+
+    return [assignment01, assignment02, assignment03, assignment04];
 }
--- a/backend/tests/test_assets/assignments/groups.testdata.ts
+++ b/backend/tests/test_assets/assignments/groups.testdata.ts
@ -4,29 +4,55 @@ import { Assignment } from '../../../src/entities/assignments/assignment.entity'
 import { Student } from '../../../src/entities/users/student.entity';

 export function makeTestGroups(em: EntityManager, students: Student[], assignments: Assignment[]): Group[] {
+    /*
+     * Group #1 for Assignment #1 in class 'id01'
+     * => Assigned to do learning path 'id02'
+     */
    const group01 = em.create(Group, {
        assignment: assignments[0],
        groupNumber: 1,
        members: students.slice(0, 2),
    });

+    /*
+     * Group #2 for Assignment #1 in class 'id01'
+     * => Assigned to do learning path 'id02'
+     */
    const group02 = em.create(Group, {
        assignment: assignments[0],
        groupNumber: 2,
        members: students.slice(2, 4),
    });

+    /*
+     * Group #3 for Assignment #1 in class 'id01'
+     * => Assigned to do learning path 'id02'
+     */
    const group03 = em.create(Group, {
        assignment: assignments[0],
        groupNumber: 3,
        members: students.slice(4, 6),
    });

+    /*
+     * Group #4 for Assignment #2 in class 'id02'
+     * => Assigned to do learning path 'id01'
+     */
    const group04 = em.create(Group, {
        assignment: assignments[1],
        groupNumber: 4,
        members: students.slice(3, 4),
    });

-    return [group01, group02, group03, group04];
+    /*
+     * Group #5 for Assignment #4 in class 'id01'
+     * => Assigned to do learning path 'id01'
+     */
+    const group05 = em.create(Group, {
+        assignment: assignments[3],
+        groupNumber: 1,
+        members: students.slice(0, 2),
+    });
+
+    return [group01, group02, group03, group04, group05];
 }
--- a/backend/tests/test_assets/assignments/submission.testdata.ts
+++ b/backend/tests/test_assets/assignments/submission.testdata.ts
@ -12,7 +12,7 @@ export function makeTestSubmissions(em: EntityManager, students: Student[], grou
        submissionNumber: 1,
        submitter: students[0],
        submissionTime: new Date(2025, 2, 20),
-        onBehalfOf: groups[0],
+        onBehalfOf: groups[0], // Group #1 for Assignment #1 in class 'id01'
        content: 'sub1',
    });

@ -23,7 +23,7 @@ export function makeTestSubmissions(em: EntityManager, students: Student[], grou
        submissionNumber: 2,
        submitter: students[0],
        submissionTime: new Date(2025, 2, 25),
-        onBehalfOf: groups[0],
+        onBehalfOf: groups[0], // Group #1 for Assignment #1 in class 'id01'
        content: '',
    });

@ -34,6 +34,7 @@ export function makeTestSubmissions(em: EntityManager, students: Student[], grou
        submissionNumber: 1,
        submitter: students[0],
        submissionTime: new Date(2025, 2, 20),
+        onBehalfOf: groups[0], // Group #1 for Assignment #1 in class 'id01'
        content: '',
    });

@ -44,6 +45,7 @@ export function makeTestSubmissions(em: EntityManager, students: Student[], grou
        submissionNumber: 2,
        submitter: students[0],
        submissionTime: new Date(2025, 2, 25),
+        onBehalfOf: groups[0], // Group #1 for Assignment #1 in class 'id01'
        content: '',
    });

@ -54,8 +56,42 @@ export function makeTestSubmissions(em: EntityManager, students: Student[], grou
        submissionNumber: 1,
        submitter: students[1],
        submissionTime: new Date(2025, 2, 20),
+        onBehalfOf: groups[1], // Group #2 for Assignment #1 in class 'id01'
        content: '',
    });

-    return [submission01, submission02, submission03, submission04, submission05];
+    const submission06 = em.create(Submission, {
+        learningObjectHruid: 'id01',
+        learningObjectLanguage: Language.English,
+        learningObjectVersion: 1,
+        submissionNumber: 2,
+        submitter: students[1],
+        submissionTime: new Date(2025, 2, 25),
+        onBehalfOf: groups[4], // Group #5 for Assignment #4 in class 'id01'
+        content: '',
+    });
+
+    const submission07 = em.create(Submission, {
+        learningObjectHruid: 'id01',
+        learningObjectLanguage: Language.English,
+        learningObjectVersion: 1,
+        submissionNumber: 3,
+        submitter: students[3],
+        submissionTime: new Date(2025, 3, 25),
+        onBehalfOf: groups[3], // Group #4 for Assignment #2 in class 'id02'
+        content: '',
+    });
+
+    const submission08 = em.create(Submission, {
+        learningObjectHruid: 'id02',
+        learningObjectLanguage: Language.English,
+        learningObjectVersion: 1,
+        submissionNumber: 3,
+        submitter: students[1],
+        submissionTime: new Date(2025, 4, 7),
+        onBehalfOf: groups[1], // Group #2 for Assignment #1 in class 'id01'
+        content: '',
+    });
+
+    return [submission01, submission02, submission03, submission04, submission05, submission06, submission07, submission08];
 }
--- a/backend/tests/test_assets/questions/questions.testdata.ts
+++ b/backend/tests/test_assets/questions/questions.testdata.ts
@ -2,12 +2,14 @@ import { EntityManager } from '@mikro-orm/core';
 import { Question } from '../../../src/entities/questions/question.entity';
 import { Language } from '@dwengo-1/common/util/language';
 import { Student } from '../../../src/entities/users/student.entity';
+import { Group } from '../../../src/entities/assignments/group.entity';

-export function makeTestQuestions(em: EntityManager, students: Student[]): Question[] {
+export function makeTestQuestions(em: EntityManager, students: Student[], groups: Group[]): Question[] {
    const question01 = em.create(Question, {
        learningObjectLanguage: Language.English,
        learningObjectVersion: 1,
        learningObjectHruid: 'id05',
+        inGroup: groups[0], // Group #1 for Assignment #1 in class 'id01'
        sequenceNumber: 1,
        author: students[0],
        timestamp: new Date(),
@ -18,6 +20,7 @@ export function makeTestQuestions(em: EntityManager, students: Student[]): Quest
        learningObjectLanguage: Language.English,
        learningObjectVersion: 1,
        learningObjectHruid: 'id05',
+        inGroup: groups[0], // Group #1 for Assignment #1 in class 'id01'
        sequenceNumber: 2,
        author: students[2],
        timestamp: new Date(),
@ -30,6 +33,7 @@ export function makeTestQuestions(em: EntityManager, students: Student[]): Quest
        learningObjectHruid: 'id04',
        sequenceNumber: 1,
        author: students[0],
+        inGroup: groups[0], // Group #1 for Assignment #1 in class 'id01'
        timestamp: new Date(),
        content: 'question',
    });
@ -40,9 +44,32 @@ export function makeTestQuestions(em: EntityManager, students: Student[]): Quest
        learningObjectHruid: 'id01',
        sequenceNumber: 1,
        author: students[1],
+        inGroup: groups[1], // Group #2 for Assignment #1 in class 'id01'
        timestamp: new Date(),
        content: 'question',
    });

-    return [question01, question02, question03, question04];
+    const question05 = em.create(Question, {
+        learningObjectLanguage: Language.English,
+        learningObjectVersion: 1,
+        learningObjectHruid: 'id05',
+        sequenceNumber: 3,
+        author: students[1],
+        inGroup: groups[1], // Group #2 for Assignment #1 in class 'id01'
+        timestamp: new Date(),
+        content: 'question',
+    });
+
+    const question06 = em.create(Question, {
+        learningObjectLanguage: Language.English,
+        learningObjectVersion: 1,
+        learningObjectHruid: 'id05',
+        sequenceNumber: 4,
+        author: students[2],
+        inGroup: groups[3], // Group #4 for Assignment #2 in class 'id02'
+        timestamp: new Date(),
+        content: 'question',
+    });
+
+    return [question01, question02, question03, question04, question05, question06];
 }
--- a/common/src/interfaces/group.ts
+++ b/common/src/interfaces/group.ts
@ -6,5 +6,5 @@ export interface GroupDTO {
    class: string | ClassDTO;
    assignment: number | AssignmentDTO;
    groupNumber: number;
-    members: string[] | StudentDTO[];
+    members?: string[] | StudentDTO[];
 }
--- a/common/src/interfaces/question.ts
+++ b/common/src/interfaces/question.ts
@ -1,10 +1,12 @@
 import { LearningObjectIdentifierDTO } from './learning-content';
 import { StudentDTO } from './student';
+import { GroupDTO } from './group';

 export interface QuestionDTO {
    learningObjectIdentifier: LearningObjectIdentifierDTO;
    sequenceNumber?: number;
    author: StudentDTO;
+    inGroup: GroupDTO;
    timestamp: string;
    content: string;
 }
@ -12,6 +14,7 @@ export interface QuestionDTO {
 export interface QuestionData {
    author?: string;
    content: string;
+    inGroup: GroupDTO;
 }

 export interface QuestionId {
--- a/common/src/interfaces/submission.ts
+++ b/common/src/interfaces/submission.ts
@ -9,7 +9,7 @@ export interface SubmissionDTO {
    submissionNumber?: number;
    submitter: StudentDTO;
    time?: Date;
-    group?: GroupDTO;
+    group: GroupDTO;
    content: string;
 }

--- a/package-lock.json
+++ b/package-lock.json
@ -72,6 +72,133 @@
                "vitest": "^3.0.6"
            }
        },
+        "backend/node_modules/@mikro-orm/cli": {
+            "version": "6.4.9",
+            "resolved": "https://registry.npmjs.org/@mikro-orm/cli/-/cli-6.4.9.tgz",
+            "integrity": "sha512-LQzVsmar/0DoJkPGyz3OpB8pa9BCQtvYreEC71h0O+RcizppJjgBQNTkj5tJd2Iqvh4hSaMv6qTv0l5UK6F2Vw==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "@jercle/yargonaut": "1.1.5",
+                "@mikro-orm/core": "6.4.9",
+                "@mikro-orm/knex": "6.4.9",
+                "fs-extra": "11.3.0",
+                "tsconfig-paths": "4.2.0",
+                "yargs": "17.7.2"
+            },
+            "bin": {
+                "mikro-orm": "cli",
+                "mikro-orm-esm": "esm"
+            },
+            "engines": {
+                "node": ">= 18.12.0"
+            }
+        },
+        "backend/node_modules/@mikro-orm/core": {
+            "version": "6.4.9",
+            "resolved": "https://registry.npmjs.org/@mikro-orm/core/-/core-6.4.9.tgz",
+            "integrity": "sha512-osB2TbvSH4ZL1s62LCBQFAnxPqLycX5fakPHOoztudixqfbVD5QQydeGizJXMMh2zKP6vRCwIJy3MeSuFxPjHg==",
+            "license": "MIT",
+            "dependencies": {
+                "dataloader": "2.2.3",
+                "dotenv": "16.4.7",
+                "esprima": "4.0.1",
+                "fs-extra": "11.3.0",
+                "globby": "11.1.0",
+                "mikro-orm": "6.4.9",
+                "reflect-metadata": "0.2.2"
+            },
+            "engines": {
+                "node": ">= 18.12.0"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/b4nan"
+            }
+        },
+        "backend/node_modules/@mikro-orm/knex": {
+            "version": "6.4.9",
+            "resolved": "https://registry.npmjs.org/@mikro-orm/knex/-/knex-6.4.9.tgz",
+            "integrity": "sha512-iGXJfe/TziVOQsWuxMIqkOpurysWzQA6kj3+FDtOkHJAijZhqhjSBnfUVHHY/JzU9o0M0rgLrDVJFry/uEaJEA==",
+            "license": "MIT",
+            "dependencies": {
+                "fs-extra": "11.3.0",
+                "knex": "3.1.0",
+                "sqlstring": "2.3.3"
+            },
+            "engines": {
+                "node": ">= 18.12.0"
+            },
+            "peerDependencies": {
+                "@mikro-orm/core": "^6.0.0",
+                "better-sqlite3": "*",
+                "libsql": "*",
+                "mariadb": "*"
+            },
+            "peerDependenciesMeta": {
+                "better-sqlite3": {
+                    "optional": true
+                },
+                "libsql": {
+                    "optional": true
+                },
+                "mariadb": {
+                    "optional": true
+                }
+            }
+        },
+        "backend/node_modules/@mikro-orm/postgresql": {
+            "version": "6.4.9",
+            "resolved": "https://registry.npmjs.org/@mikro-orm/postgresql/-/postgresql-6.4.9.tgz",
+            "integrity": "sha512-ZdVVFAL/TSbzpEmChGdH0oUpy2KiHLjNIeItZHRQgInn1X9p0qx28VVDR78p8qgRGkQ3LquxGTkvmWI0w7qi3A==",
+            "license": "MIT",
+            "dependencies": {
+                "@mikro-orm/knex": "6.4.9",
+                "pg": "8.13.3",
+                "postgres-array": "3.0.4",
+                "postgres-date": "2.1.0",
+                "postgres-interval": "4.0.2"
+            },
+            "engines": {
+                "node": ">= 18.12.0"
+            },
+            "peerDependencies": {
+                "@mikro-orm/core": "^6.0.0"
+            }
+        },
+        "backend/node_modules/@mikro-orm/reflection": {
+            "version": "6.4.9",
+            "resolved": "https://registry.npmjs.org/@mikro-orm/reflection/-/reflection-6.4.9.tgz",
+            "integrity": "sha512-fgY7yLrcZm3J/8dv9reUC4PQo7C2muImU31jmzz1SxmNKPJFDJl7OzcDZlM5NOisXzsWUBrcNdCyuQiWViVc3A==",
+            "license": "MIT",
+            "dependencies": {
+                "globby": "11.1.0",
+                "ts-morph": "25.0.1"
+            },
+            "engines": {
+                "node": ">= 18.12.0"
+            },
+            "peerDependencies": {
+                "@mikro-orm/core": "^6.0.0"
+            }
+        },
+        "backend/node_modules/@mikro-orm/sqlite": {
+            "version": "6.4.9",
+            "resolved": "https://registry.npmjs.org/@mikro-orm/sqlite/-/sqlite-6.4.9.tgz",
+            "integrity": "sha512-O7Jy/5DrTWpJI/3qkhRJHl+OcECx1N625LHDODAAauOK3+MJB/bj80TrvQhe6d/CHZMmvxZ7m2GzaL1NulKxRw==",
+            "license": "MIT",
+            "dependencies": {
+                "@mikro-orm/knex": "6.4.9",
+                "fs-extra": "11.3.0",
+                "sqlite3": "5.1.7",
+                "sqlstring-sqlite": "0.1.1"
+            },
+            "engines": {
+                "node": ">= 18.12.0"
+            },
+            "peerDependencies": {
+                "@mikro-orm/core": "^6.0.0"
+            }
+        },
        "backend/node_modules/globals": {
            "version": "15.15.0",
            "resolved": "https://registry.npmjs.org/globals/-/globals-15.15.0.tgz",
@ -85,6 +212,48 @@
                "url": "https://github.com/sponsors/sindresorhus"
            }
        },
+        "backend/node_modules/mikro-orm": {
+            "version": "6.4.9",
+            "resolved": "https://registry.npmjs.org/mikro-orm/-/mikro-orm-6.4.9.tgz",
+            "integrity": "sha512-XwVrWNT4NNwS6kHIKFNDfvy8L1eWcBBEHeTVzFFYcnb2ummATaLxqeVkNEmKA68jmdtfQdUmWBqGdbcIPwtL2Q==",
+            "license": "MIT",
+            "engines": {
+                "node": ">= 18.12.0"
+            }
+        },
+        "backend/node_modules/pg": {
+            "version": "8.13.3",
+            "resolved": "https://registry.npmjs.org/pg/-/pg-8.13.3.tgz",
+            "integrity": "sha512-P6tPt9jXbL9HVu/SSRERNYaYG++MjnscnegFh9pPHihfoBSujsrka0hyuymMzeJKFWrcG8wvCKy8rCe8e5nDUQ==",
+            "license": "MIT",
+            "dependencies": {
+                "pg-connection-string": "^2.7.0",
+                "pg-pool": "^3.7.1",
+                "pg-protocol": "^1.7.1",
+                "pg-types": "^2.1.0",
+                "pgpass": "1.x"
+            },
+            "engines": {
+                "node": ">= 8.0.0"
+            },
+            "optionalDependencies": {
+                "pg-cloudflare": "^1.1.1"
+            },
+            "peerDependencies": {
+                "pg-native": ">=3.0.1"
+            },
+            "peerDependenciesMeta": {
+                "pg-native": {
+                    "optional": true
+                }
+            }
+        },
+        "backend/node_modules/pg-connection-string": {
+            "version": "2.7.0",
+            "resolved": "https://registry.npmjs.org/pg-connection-string/-/pg-connection-string-2.7.0.tgz",
+            "integrity": "sha512-PI2W9mv53rXJQEOb8xNR8lH7Hr+EKa6oJa38zsK0S/ky2er16ios1wLKhZyxzD7jUReiWokc9WK5nxSnC7W1TA==",
+            "license": "MIT"
+        },
        "common": {
            "name": "@dwengo-1/common",
            "version": "0.1.1"
@ -1816,133 +1985,6 @@
                "jsep": "^0.4.0||^1.0.0"
            }
        },
-        "node_modules/@mikro-orm/cli": {
-            "version": "6.4.9",
-            "resolved": "https://registry.npmjs.org/@mikro-orm/cli/-/cli-6.4.9.tgz",
-            "integrity": "sha512-LQzVsmar/0DoJkPGyz3OpB8pa9BCQtvYreEC71h0O+RcizppJjgBQNTkj5tJd2Iqvh4hSaMv6qTv0l5UK6F2Vw==",
-            "dev": true,
-            "license": "MIT",
-            "dependencies": {
-                "@jercle/yargonaut": "1.1.5",
-                "@mikro-orm/core": "6.4.9",
-                "@mikro-orm/knex": "6.4.9",
-                "fs-extra": "11.3.0",
-                "tsconfig-paths": "4.2.0",
-                "yargs": "17.7.2"
-            },
-            "bin": {
-                "mikro-orm": "cli",
-                "mikro-orm-esm": "esm"
-            },
-            "engines": {
-                "node": ">= 18.12.0"
-            }
-        },
-        "node_modules/@mikro-orm/core": {
-            "version": "6.4.9",
-            "resolved": "https://registry.npmjs.org/@mikro-orm/core/-/core-6.4.9.tgz",
-            "integrity": "sha512-osB2TbvSH4ZL1s62LCBQFAnxPqLycX5fakPHOoztudixqfbVD5QQydeGizJXMMh2zKP6vRCwIJy3MeSuFxPjHg==",
-            "license": "MIT",
-            "dependencies": {
-                "dataloader": "2.2.3",
-                "dotenv": "16.4.7",
-                "esprima": "4.0.1",
-                "fs-extra": "11.3.0",
-                "globby": "11.1.0",
-                "mikro-orm": "6.4.9",
-                "reflect-metadata": "0.2.2"
-            },
-            "engines": {
-                "node": ">= 18.12.0"
-            },
-            "funding": {
-                "url": "https://github.com/sponsors/b4nan"
-            }
-        },
-        "node_modules/@mikro-orm/knex": {
-            "version": "6.4.9",
-            "resolved": "https://registry.npmjs.org/@mikro-orm/knex/-/knex-6.4.9.tgz",
-            "integrity": "sha512-iGXJfe/TziVOQsWuxMIqkOpurysWzQA6kj3+FDtOkHJAijZhqhjSBnfUVHHY/JzU9o0M0rgLrDVJFry/uEaJEA==",
-            "license": "MIT",
-            "dependencies": {
-                "fs-extra": "11.3.0",
-                "knex": "3.1.0",
-                "sqlstring": "2.3.3"
-            },
-            "engines": {
-                "node": ">= 18.12.0"
-            },
-            "peerDependencies": {
-                "@mikro-orm/core": "^6.0.0",
-                "better-sqlite3": "*",
-                "libsql": "*",
-                "mariadb": "*"
-            },
-            "peerDependenciesMeta": {
-                "better-sqlite3": {
-                    "optional": true
-                },
-                "libsql": {
-                    "optional": true
-                },
-                "mariadb": {
-                    "optional": true
-                }
-            }
-        },
-        "node_modules/@mikro-orm/postgresql": {
-            "version": "6.4.9",
-            "resolved": "https://registry.npmjs.org/@mikro-orm/postgresql/-/postgresql-6.4.9.tgz",
-            "integrity": "sha512-ZdVVFAL/TSbzpEmChGdH0oUpy2KiHLjNIeItZHRQgInn1X9p0qx28VVDR78p8qgRGkQ3LquxGTkvmWI0w7qi3A==",
-            "license": "MIT",
-            "dependencies": {
-                "@mikro-orm/knex": "6.4.9",
-                "pg": "8.13.3",
-                "postgres-array": "3.0.4",
-                "postgres-date": "2.1.0",
-                "postgres-interval": "4.0.2"
-            },
-            "engines": {
-                "node": ">= 18.12.0"
-            },
-            "peerDependencies": {
-                "@mikro-orm/core": "^6.0.0"
-            }
-        },
-        "node_modules/@mikro-orm/reflection": {
-            "version": "6.4.9",
-            "resolved": "https://registry.npmjs.org/@mikro-orm/reflection/-/reflection-6.4.9.tgz",
-            "integrity": "sha512-fgY7yLrcZm3J/8dv9reUC4PQo7C2muImU31jmzz1SxmNKPJFDJl7OzcDZlM5NOisXzsWUBrcNdCyuQiWViVc3A==",
-            "license": "MIT",
-            "dependencies": {
-                "globby": "11.1.0",
-                "ts-morph": "25.0.1"
-            },
-            "engines": {
-                "node": ">= 18.12.0"
-            },
-            "peerDependencies": {
-                "@mikro-orm/core": "^6.0.0"
-            }
-        },
-        "node_modules/@mikro-orm/sqlite": {
-            "version": "6.4.9",
-            "resolved": "https://registry.npmjs.org/@mikro-orm/sqlite/-/sqlite-6.4.9.tgz",
-            "integrity": "sha512-O7Jy/5DrTWpJI/3qkhRJHl+OcECx1N625LHDODAAauOK3+MJB/bj80TrvQhe6d/CHZMmvxZ7m2GzaL1NulKxRw==",
-            "license": "MIT",
-            "dependencies": {
-                "@mikro-orm/knex": "6.4.9",
-                "fs-extra": "11.3.0",
-                "sqlite3": "5.1.7",
-                "sqlstring-sqlite": "0.1.1"
-            },
-            "engines": {
-                "node": ">= 18.12.0"
-            },
-            "peerDependencies": {
-                "@mikro-orm/core": "^6.0.0"
-            }
-        },
        "node_modules/@napi-rs/snappy-android-arm-eabi": {
            "version": "7.2.2",
            "resolved": "https://registry.npmjs.org/@napi-rs/snappy-android-arm-eabi/-/snappy-android-arm-eabi-7.2.2.tgz",
@ -7849,15 +7891,6 @@
                "node": ">=8.6"
            }
        },
-        "node_modules/mikro-orm": {
-            "version": "6.4.9",
-            "resolved": "https://registry.npmjs.org/mikro-orm/-/mikro-orm-6.4.9.tgz",
-            "integrity": "sha512-XwVrWNT4NNwS6kHIKFNDfvy8L1eWcBBEHeTVzFFYcnb2ummATaLxqeVkNEmKA68jmdtfQdUmWBqGdbcIPwtL2Q==",
-            "license": "MIT",
-            "engines": {
-                "node": ">= 18.12.0"
-            }
-        },
        "node_modules/mime-db": {
            "version": "1.54.0",
            "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.54.0.tgz",
@ -8649,14 +8682,15 @@
            "license": "MIT"
        },
        "node_modules/pg": {
-            "version": "8.13.3",
-            "resolved": "https://registry.npmjs.org/pg/-/pg-8.13.3.tgz",
-            "integrity": "sha512-P6tPt9jXbL9HVu/SSRERNYaYG++MjnscnegFh9pPHihfoBSujsrka0hyuymMzeJKFWrcG8wvCKy8rCe8e5nDUQ==",
+            "version": "8.14.1",
+            "resolved": "https://registry.npmjs.org/pg/-/pg-8.14.1.tgz",
+            "integrity": "sha512-0TdbqfjwIun9Fm/r89oB7RFQ0bLgduAhiIqIXOsyKoiC/L54DbuAAzIEN/9Op0f1Po9X7iCPXGoa/Ah+2aI8Xw==",
            "license": "MIT",
+            "peer": true,
            "dependencies": {
                "pg-connection-string": "^2.7.0",
-                "pg-pool": "^3.7.1",
-                "pg-protocol": "^1.7.1",
+                "pg-pool": "^3.8.0",
+                "pg-protocol": "^1.8.0",
                "pg-types": "^2.1.0",
                "pgpass": "1.x"
            },
@ -8762,7 +8796,8 @@
            "version": "2.7.0",
            "resolved": "https://registry.npmjs.org/pg-connection-string/-/pg-connection-string-2.7.0.tgz",
            "integrity": "sha512-PI2W9mv53rXJQEOb8xNR8lH7Hr+EKa6oJa38zsK0S/ky2er16ios1wLKhZyxzD7jUReiWokc9WK5nxSnC7W1TA==",
-            "license": "MIT"
+            "license": "MIT",
+            "peer": true
        },
        "node_modules/pgpass": {
            "version": "1.0.5",