Merge remote-tracking branch 'origin/dev' into feat/indieningen-kunnen-posten-en-bekijken-#194

# Conflicts: # backend/tests/setup-tests.ts
2025-04-16 16:31:18 +02:00 · 2025-04-16 16:31:18 +02:00 · dd2cdf3fe9
commit dd2cdf3fe9
parent 63d1ed8bd2 ab1bc42619
46 changed files with 1670 additions and 123 deletions
--- a/backend/src/controllers/learning-paths.ts
+++ b/backend/src/controllers/learning-paths.ts
@ -6,7 +6,7 @@ import { Language } from '@dwengo-1/common/util/language';
 import { BadRequestException } from '../exceptions/bad-request-exception.js';
 import { NotFoundException } from '../exceptions/not-found-exception.js';
 import {Group} from "../entities/assignments/group.entity";
-import {getGroupRepository} from "../data/repositories";
+import {getAssignmentRepository, getGroupRepository} from "../data/repositories";

 /**
 * Fetch learning paths based on query parameters.
@ -27,15 +27,14 @@ export async function getLearningPaths(req: Request, res: Response): Promise<voi
        if (!assignmentNo || !classId) {
            throw new BadRequestException('If forGroupNo is specified, assignmentNo and classId must also be specified.');
        }
-        forGroup = await getGroupRepository().findOne({
-            assignment: {
-                id: parseInt(assignmentNo),
-                within: {
-                    classId
-                }
-            },
-            groupNumber: parseInt(forGroupNo)
-        }) ?? undefined;
+        const assignment = await getAssignmentRepository().findByClassIdAndAssignmentId(
+            classId, parseInt(assignmentNo)
+        );
+        if (assignment) {
+            forGroup = await getGroupRepository().findByAssignmentAndGroupNumber(
+                assignment, parseInt(forGroupNo)
+            ) ?? undefined;
+        }
    }

    let hruidList;
--- a/backend/src/controllers/submissions.ts
+++ b/backend/src/controllers/submissions.ts
@ -4,7 +4,7 @@ import {
    deleteSubmission,
    getAllSubmissions,
    getSubmission,
-    getSubmissionsForLearningObjectAndAssignment,
+    getSubmissionsForLearningObjectAndAssignment, getSubmissionsForLearningObjectAndGroup,
 } from '../services/submissions.js';
 import { SubmissionDTO } from '@dwengo-1/common/interfaces/submission';
 import { Language, languageMap } from '@dwengo-1/common/util/language';
@ -17,13 +17,25 @@ 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 submissions = await getSubmissionsForLearningObjectAndAssignment(
-        loHruid,
-        lang,
-        version,
-        req.query.classId as string,
-        parseInt(req.query.assignmentId as string)
-    );
+    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)
+        )
+    }

    res.json(submissions);
 }
--- a/backend/src/controllers/teacher-invitations.ts
+++ b/backend/src/controllers/teacher-invitations.ts
@ -0,0 +1,66 @@
+import { Request, Response } from 'express';
+import { requireFields } from './error-helper';
+import { createInvitation, deleteInvitation, getAllInvitations, getInvitation, updateInvitation } from '../services/teacher-invitations';
+import { TeacherInvitationData } from '@dwengo-1/common/interfaces/teacher-invitation';
+
+export async function getAllInvitationsHandler(req: Request, res: Response): Promise<void> {
+    const username = req.params.username;
+    const by = req.query.sent === 'true';
+    requireFields({ username });
+
+    const invitations = await getAllInvitations(username, by);
+
+    res.json({ invitations });
+}
+
+export async function getInvitationHandler(req: Request, res: Response): Promise<void> {
+    const sender = req.params.sender;
+    const receiver = req.params.receiver;
+    const classId = req.params.classId;
+    requireFields({ sender, receiver, classId });
+
+    const invitation = await getInvitation(sender, receiver, classId);
+
+    res.json({ invitation });
+}
+
+export async function createInvitationHandler(req: Request, res: Response): Promise<void> {
+    const sender = req.body.sender;
+    const receiver = req.body.receiver;
+    const classId = req.body.class;
+    requireFields({ sender, receiver, classId });
+
+    const data = req.body as TeacherInvitationData;
+    const invitation = await createInvitation(data);
+
+    res.json({ invitation });
+}
+
+export async function updateInvitationHandler(req: Request, res: Response): Promise<void> {
+    const sender = req.body.sender;
+    const receiver = req.body.receiver;
+    const classId = req.body.class;
+    req.body.accepted = req.body.accepted !== 'false';
+    requireFields({ sender, receiver, classId });
+
+    const data = req.body as TeacherInvitationData;
+    const invitation = await updateInvitation(data);
+
+    res.json({ invitation });
+}
+
+export async function deleteInvitationHandler(req: Request, res: Response): Promise<void> {
+    const sender = req.params.sender;
+    const receiver = req.params.receiver;
+    const classId = req.params.classId;
+    requireFields({ sender, receiver, classId });
+
+    const data: TeacherInvitationData = {
+        sender,
+        receiver,
+        class: classId,
+    };
+    const invitation = await deleteInvitation(data);
+
+    res.json({ invitation });
+}
--- a/backend/src/data/classes/class-join-request-repository.ts
+++ b/backend/src/data/classes/class-join-request-repository.ts
@ -2,14 +2,14 @@ import { DwengoEntityRepository } from '../dwengo-entity-repository.js';
 import { Class } from '../../entities/classes/class.entity.js';
 import { ClassJoinRequest } from '../../entities/classes/class-join-request.entity.js';
 import { Student } from '../../entities/users/student.entity.js';
-import { ClassJoinRequestStatus } from '@dwengo-1/common/util/class-join-request';
+import { ClassStatus } from '@dwengo-1/common/util/class-join-request';

 export class ClassJoinRequestRepository extends DwengoEntityRepository<ClassJoinRequest> {
    public async findAllRequestsBy(requester: Student): Promise<ClassJoinRequest[]> {
        return this.findAll({ where: { requester: requester } });
    }
    public async findAllOpenRequestsTo(clazz: Class): Promise<ClassJoinRequest[]> {
-        return this.findAll({ where: { class: clazz, status: ClassJoinRequestStatus.Open } }); // TODO check if works like this
+        return this.findAll({ where: { class: clazz, status: ClassStatus.Open } }); // TODO check if works like this
    }
    public async findByStudentAndClass(requester: Student, clazz: Class): Promise<ClassJoinRequest | null> {
        return this.findOne({ requester, class: clazz });
--- a/backend/src/data/classes/teacher-invitation-repository.ts
+++ b/backend/src/data/classes/teacher-invitation-repository.ts
@ -2,6 +2,7 @@ import { DwengoEntityRepository } from '../dwengo-entity-repository.js';
 import { Class } from '../../entities/classes/class.entity.js';
 import { TeacherInvitation } from '../../entities/classes/teacher-invitation.entity.js';
 import { Teacher } from '../../entities/users/teacher.entity.js';
+import { ClassStatus } from '@dwengo-1/common/util/class-join-request';

 export class TeacherInvitationRepository extends DwengoEntityRepository<TeacherInvitation> {
    public async findAllInvitationsForClass(clazz: Class): Promise<TeacherInvitation[]> {
@ -11,7 +12,7 @@ export class TeacherInvitationRepository extends DwengoEntityRepository<TeacherI
        return this.findAll({ where: { sender: sender } });
    }
    public async findAllInvitationsFor(receiver: Teacher): Promise<TeacherInvitation[]> {
-        return this.findAll({ where: { receiver: receiver } });
+        return this.findAll({ where: { receiver: receiver, status: ClassStatus.Open } });
    }
    public async deleteBy(clazz: Class, sender: Teacher, receiver: Teacher): Promise<void> {
        return this.deleteWhere({
@ -20,4 +21,11 @@ export class TeacherInvitationRepository extends DwengoEntityRepository<TeacherI
            class: clazz,
        });
    }
+    public async findBy(clazz: Class, sender: Teacher, receiver: Teacher): Promise<TeacherInvitation | null> {
+        return this.findOne({
+            sender: sender,
+            receiver: receiver,
+            class: clazz,
+        });
+    }
 }
--- a/backend/src/entities/assignments/submission.entity.ts
+++ b/backend/src/entities/assignments/submission.entity.ts
@ -6,6 +6,9 @@ import { Language } from '@dwengo-1/common/util/language';

@Entity({ repository: () => SubmissionRepository })
 export class Submission {
+    @PrimaryKey({ type: 'integer', autoincrement: true })
+    submissionNumber?: number;
+
    @PrimaryKey({ type: 'string' })
    learningObjectHruid!: string;

@ -18,9 +21,6 @@ export class Submission {
    @PrimaryKey({ type: 'numeric' })
    learningObjectVersion = 1;

-    @PrimaryKey({ type: 'integer', autoincrement: true })
-    submissionNumber?: number;
-
    @ManyToOne({
        entity: () => Group,
    })
--- a/backend/src/entities/classes/class-join-request.entity.ts
+++ b/backend/src/entities/classes/class-join-request.entity.ts
@ -2,7 +2,7 @@ import { Entity, Enum, ManyToOne } from '@mikro-orm/core';
 import { Student } from '../users/student.entity.js';
 import { Class } from './class.entity.js';
 import { ClassJoinRequestRepository } from '../../data/classes/class-join-request-repository.js';
-import { ClassJoinRequestStatus } from '@dwengo-1/common/util/class-join-request';
+import { ClassStatus } from '@dwengo-1/common/util/class-join-request';

@Entity({
    repository: () => ClassJoinRequestRepository,
@ -20,6 +20,6 @@ export class ClassJoinRequest {
    })
    class!: Class;

-    @Enum(() => ClassJoinRequestStatus)
-    status!: ClassJoinRequestStatus;
+    @Enum(() => ClassStatus)
+    status!: ClassStatus;
 }
--- a/backend/src/entities/classes/teacher-invitation.entity.ts
+++ b/backend/src/entities/classes/teacher-invitation.entity.ts
@ -1,7 +1,8 @@
-import { Entity, ManyToOne } from '@mikro-orm/core';
+import { Entity, Enum, ManyToOne } from '@mikro-orm/core';
 import { Teacher } from '../users/teacher.entity.js';
 import { Class } from './class.entity.js';
 import { TeacherInvitationRepository } from '../../data/classes/teacher-invitation-repository.js';
+import { ClassStatus } from '@dwengo-1/common/util/class-join-request';

 /**
 * Invitation of a teacher into a class (in order to teach it).
@ -25,4 +26,7 @@ export class TeacherInvitation {
        primary: true,
    })
    class!: Class;
+
+    @Enum(() => ClassStatus)
+    status!: ClassStatus;
 }
--- a/backend/src/interfaces/student-request.ts
+++ b/backend/src/interfaces/student-request.ts
@ -4,7 +4,7 @@ import { getClassJoinRequestRepository } from '../data/repositories.js';
 import { Student } from '../entities/users/student.entity.js';
 import { Class } from '../entities/classes/class.entity.js';
 import { ClassJoinRequestDTO } from '@dwengo-1/common/interfaces/class-join-request';
-import { ClassJoinRequestStatus } from '@dwengo-1/common/util/class-join-request';
+import { ClassStatus } from '@dwengo-1/common/util/class-join-request';

 export function mapToStudentRequestDTO(request: ClassJoinRequest): ClassJoinRequestDTO {
    return {
@ -18,6 +18,6 @@ export function mapToStudentRequest(student: Student, cls: Class): ClassJoinRequ
    return getClassJoinRequestRepository().create({
        requester: student,
        class: cls,
-        status: ClassJoinRequestStatus.Open,
+        status: ClassStatus.Open,
    });
 }
--- a/backend/src/interfaces/teacher-invitation.ts
+++ b/backend/src/interfaces/teacher-invitation.ts
@ -1,13 +1,17 @@
 import { TeacherInvitation } from '../entities/classes/teacher-invitation.entity.js';
-import { mapToClassDTO } from './class.js';
 import { mapToUserDTO } from './user.js';
 import { TeacherInvitationDTO } from '@dwengo-1/common/interfaces/teacher-invitation';
+import { getTeacherInvitationRepository } from '../data/repositories';
+import { Teacher } from '../entities/users/teacher.entity';
+import { Class } from '../entities/classes/class.entity';
+import { ClassStatus } from '@dwengo-1/common/util/class-join-request';

 export function mapToTeacherInvitationDTO(invitation: TeacherInvitation): TeacherInvitationDTO {
    return {
        sender: mapToUserDTO(invitation.sender),
        receiver: mapToUserDTO(invitation.receiver),
-        class: mapToClassDTO(invitation.class),
+        classId: invitation.class.classId!,
+        status: invitation.status,
    };
 }

@ -15,6 +19,16 @@ export function mapToTeacherInvitationDTOIds(invitation: TeacherInvitation): Tea
    return {
        sender: invitation.sender.username,
        receiver: invitation.receiver.username,
-        class: invitation.class.classId!,
+        classId: invitation.class.classId!,
+        status: invitation.status,
    };
 }
+
+export function mapToInvitation(sender: Teacher, receiver: Teacher, cls: Class): TeacherInvitation {
+    return getTeacherInvitationRepository().create({
+        sender,
+        receiver,
+        class: cls,
+        status: ClassStatus.Open,
+    });
+}
--- a/backend/src/routes/submissions.ts
+++ b/backend/src/routes/submissions.ts
@ -5,7 +5,7 @@ const router = express.Router({ mergeParams: true });
 // Root endpoint used to search objects
 router.get('/', getSubmissionsHandler);

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

 // Information about an submission with id 'id'
 router.get('/:id', getSubmissionHandler);
--- a/backend/src/routes/teacher-invitations.ts
+++ b/backend/src/routes/teacher-invitations.ts
@ -0,0 +1,22 @@
+import express from 'express';
+import {
+    createInvitationHandler,
+    deleteInvitationHandler,
+    getAllInvitationsHandler,
+    getInvitationHandler,
+    updateInvitationHandler,
+} from '../controllers/teacher-invitations';
+
+const router = express.Router({ mergeParams: true });
+
+router.get('/:username', getAllInvitationsHandler);
+
+router.get('/:sender/:receiver/:classId', getInvitationHandler);
+
+router.post('/', createInvitationHandler);
+
+router.put('/', updateInvitationHandler);
+
+router.delete('/:sender/:receiver/:classId', deleteInvitationHandler);
+
+export default router;
--- a/backend/src/routes/teachers.ts
+++ b/backend/src/routes/teachers.ts
@ -10,6 +10,8 @@ import {
    getTeacherStudentHandler,
    updateStudentJoinRequestHandler,
 } from '../controllers/teachers.js';
+import invitationRouter from './teacher-invitations.js';
+
 const router = express.Router();

 // Root endpoint used to search objects
@ -32,10 +34,6 @@ router.get('/:username/joinRequests/:classId', getStudentJoinRequestHandler);
 router.put('/:username/joinRequests/:classId/:studentUsername', updateStudentJoinRequestHandler);

 // Invitations to other classes a teacher received
-router.get('/:id/invitations', (_req, res) => {
-    res.json({
-        invitations: ['0'],
-    });
-});
+router.get('/invitations', invitationRouter);

 export default router;
--- a/backend/src/services/learning-paths/database-learning-path-provider.ts
+++ b/backend/src/services/learning-paths/database-learning-path-provider.ts
@ -111,6 +111,7 @@ async function convertNode(
        updatedAt: node.updatedAt.toISOString(),
        learningobject_hruid: node.learningObjectHruid,
        version: learningObject.version,
+        done: personalizedFor ? lastSubmission !== null : undefined,
        transitions,
    };
 }
--- a/backend/src/services/submissions.ts
+++ b/backend/src/services/submissions.ts
@ -1,4 +1,4 @@
-import { getAssignmentRepository, getSubmissionRepository } from '../data/repositories.js';
+import {getAssignmentRepository, getGroupRepository, 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';
@ -69,3 +69,24 @@ export async function getSubmissionsForLearningObjectAndAssignment(

    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));
+}
--- a/backend/src/services/teacher-invitations.ts
+++ b/backend/src/services/teacher-invitations.ts
@ -0,0 +1,87 @@
+import { fetchTeacher } from './teachers';
+import { getTeacherInvitationRepository } from '../data/repositories';
+import { mapToInvitation, mapToTeacherInvitationDTO } from '../interfaces/teacher-invitation';
+import { addClassTeacher, fetchClass } from './classes';
+import { TeacherInvitationData, TeacherInvitationDTO } from '@dwengo-1/common/interfaces/teacher-invitation';
+import { ConflictException } from '../exceptions/conflict-exception';
+import { NotFoundException } from '../exceptions/not-found-exception';
+import { TeacherInvitation } from '../entities/classes/teacher-invitation.entity';
+import { ClassStatus } from '@dwengo-1/common/util/class-join-request';
+
+export async function getAllInvitations(username: string, sent: boolean): Promise<TeacherInvitationDTO[]> {
+    const teacher = await fetchTeacher(username);
+    const teacherInvitationRepository = getTeacherInvitationRepository();
+
+    let invitations;
+    if (sent) {
+        invitations = await teacherInvitationRepository.findAllInvitationsBy(teacher);
+    } else {
+        invitations = await teacherInvitationRepository.findAllInvitationsFor(teacher);
+    }
+    return invitations.map(mapToTeacherInvitationDTO);
+}
+
+export async function createInvitation(data: TeacherInvitationData): Promise<TeacherInvitationDTO> {
+    const teacherInvitationRepository = getTeacherInvitationRepository();
+    const sender = await fetchTeacher(data.sender);
+    const receiver = await fetchTeacher(data.receiver);
+
+    const cls = await fetchClass(data.class);
+
+    if (!cls.teachers.contains(sender)) {
+        throw new ConflictException('The teacher sending the invite is not part of the class');
+    }
+
+    const newInvitation = mapToInvitation(sender, receiver, cls);
+    await teacherInvitationRepository.save(newInvitation, { preventOverwrite: true });
+
+    return mapToTeacherInvitationDTO(newInvitation);
+}
+
+async function fetchInvitation(usernameSender: string, usernameReceiver: string, classId: string): Promise<TeacherInvitation> {
+    const sender = await fetchTeacher(usernameSender);
+    const receiver = await fetchTeacher(usernameReceiver);
+    const cls = await fetchClass(classId);
+
+    const teacherInvitationRepository = getTeacherInvitationRepository();
+    const invite = await teacherInvitationRepository.findBy(cls, sender, receiver);
+
+    if (!invite) {
+        throw new NotFoundException('Teacher invite not found');
+    }
+
+    return invite;
+}
+
+export async function getInvitation(sender: string, receiver: string, classId: string): Promise<TeacherInvitationDTO> {
+    const invitation = await fetchInvitation(sender, receiver, classId);
+    return mapToTeacherInvitationDTO(invitation);
+}
+
+export async function updateInvitation(data: TeacherInvitationData): Promise<TeacherInvitationDTO> {
+    const invitation = await fetchInvitation(data.sender, data.receiver, data.class);
+    invitation.status = ClassStatus.Declined;
+
+    if (data.accepted) {
+        invitation.status = ClassStatus.Accepted;
+        await addClassTeacher(data.class, data.receiver);
+    }
+
+    const teacherInvitationRepository = getTeacherInvitationRepository();
+    await teacherInvitationRepository.save(invitation);
+
+    return mapToTeacherInvitationDTO(invitation);
+}
+
+export async function deleteInvitation(data: TeacherInvitationData): Promise<TeacherInvitationDTO> {
+    const invitation = await fetchInvitation(data.sender, data.receiver, data.class);
+
+    const sender = await fetchTeacher(data.sender);
+    const receiver = await fetchTeacher(data.receiver);
+    const cls = await fetchClass(data.class);
+
+    const teacherInvitationRepository = getTeacherInvitationRepository();
+    await teacherInvitationRepository.deleteBy(cls, sender, receiver);
+
+    return mapToTeacherInvitationDTO(invitation);
+}
--- a/backend/src/services/teachers.ts
+++ b/backend/src/services/teachers.ts
@ -28,7 +28,7 @@ import { ClassDTO } from '@dwengo-1/common/interfaces/class';
 import { StudentDTO } from '@dwengo-1/common/interfaces/student';
 import { QuestionDTO, QuestionId } from '@dwengo-1/common/interfaces/question';
 import { ClassJoinRequestDTO } from '@dwengo-1/common/interfaces/class-join-request';
-import { ClassJoinRequestStatus } from '@dwengo-1/common/util/class-join-request';
+import { ClassStatus } from '@dwengo-1/common/util/class-join-request';
 import { ConflictException } from '../exceptions/conflict-exception.js';

 export async function getAllTeachers(full: boolean): Promise<TeacherDTO[] | string[]> {
@ -160,10 +160,10 @@ export async function updateClassJoinRequestStatus(studentUsername: string, clas
        throw new NotFoundException('Join request not found');
    }

-    request.status = ClassJoinRequestStatus.Declined;
+    request.status = ClassStatus.Declined;

    if (accepted) {
-        request.status = ClassJoinRequestStatus.Accepted;
+        request.status = ClassStatus.Accepted;
        await addClassStudent(classId, studentUsername);
    }

--- a/backend/tests/controllers/teacher-invitations.test.ts
+++ b/backend/tests/controllers/teacher-invitations.test.ts
@ -0,0 +1,123 @@
+import { beforeAll, beforeEach, describe, expect, it, Mock, vi } from 'vitest';
+import { Request, Response } from 'express';
+import { setupTestApp } from '../setup-tests.js';
+import {
+    createInvitationHandler,
+    deleteInvitationHandler,
+    getAllInvitationsHandler,
+    getInvitationHandler,
+    updateInvitationHandler,
+} from '../../src/controllers/teacher-invitations';
+import { TeacherInvitationData } from '@dwengo-1/common/interfaces/teacher-invitation';
+import { getClassHandler } from '../../src/controllers/classes';
+import { BadRequestException } from '../../src/exceptions/bad-request-exception';
+import { ClassStatus } from '@dwengo-1/common/util/class-join-request';
+
+describe('Teacher controllers', () => {
+    let req: Partial<Request>;
+    let res: Partial<Response>;
+
+    let jsonMock: Mock;
+
+    beforeAll(async () => {
+        await setupTestApp();
+    });
+
+    beforeEach(() => {
+        jsonMock = vi.fn();
+        res = {
+            json: jsonMock,
+        };
+    });
+
+    it('Get teacher invitations by', async () => {
+        req = { params: { username: 'LimpBizkit' }, query: { sent: 'true' } };
+
+        await getAllInvitationsHandler(req as Request, res as Response);
+
+        expect(jsonMock).toHaveBeenCalledWith(expect.objectContaining({ invitations: expect.anything() }));
+
+        const result = jsonMock.mock.lastCall?.[0];
+        // Console.log(result.invitations);
+        expect(result.invitations).to.have.length.greaterThan(0);
+    });
+
+    it('Get teacher invitations for', async () => {
+        req = { params: { username: 'FooFighters' }, query: { by: 'false' } };
+
+        await getAllInvitationsHandler(req as Request, res as Response);
+
+        expect(jsonMock).toHaveBeenCalledWith(expect.objectContaining({ invitations: expect.anything() }));
+
+        const result = jsonMock.mock.lastCall?.[0];
+        expect(result.invitations).to.have.length.greaterThan(0);
+    });
+
+    it('Create and delete invitation', async () => {
+        const body = {
+            sender: 'LimpBizkit',
+            receiver: 'testleerkracht1',
+            class: '34d484a1-295f-4e9f-bfdc-3e7a23d86a89',
+        } as TeacherInvitationData;
+        req = { body };
+
+        await createInvitationHandler(req as Request, res as Response);
+
+        req = {
+            params: {
+                sender: 'LimpBizkit',
+                receiver: 'testleerkracht1',
+                classId: '34d484a1-295f-4e9f-bfdc-3e7a23d86a89',
+            },
+            body: { accepted: 'false' },
+        };
+
+        await deleteInvitationHandler(req as Request, res as Response);
+    });
+
+    it('Get invitation', async () => {
+        req = {
+            params: {
+                sender: 'LimpBizkit',
+                receiver: 'FooFighters',
+                classId: '34d484a1-295f-4e9f-bfdc-3e7a23d86a89',
+            },
+        };
+        await getInvitationHandler(req as Request, res as Response);
+
+        expect(jsonMock).toHaveBeenCalledWith(expect.objectContaining({ invitation: expect.anything() }));
+    });
+
+    it('Get invitation error', async () => {
+        req = {
+            params: { no: 'no params' },
+        };
+
+        await expect(async () => getInvitationHandler(req as Request, res as Response)).rejects.toThrowError(BadRequestException);
+    });
+
+    it('Accept invitation', async () => {
+        const body = {
+            sender: 'LimpBizkit',
+            receiver: 'FooFighters',
+            class: '34d484a1-295f-4e9f-bfdc-3e7a23d86a89',
+        } as TeacherInvitationData;
+        req = { body };
+
+        await updateInvitationHandler(req as Request, res as Response);
+
+        const result1 = jsonMock.mock.lastCall?.[0];
+        expect(result1.invitation.status).toEqual(ClassStatus.Accepted);
+
+        req = {
+            params: {
+                id: '34d484a1-295f-4e9f-bfdc-3e7a23d86a89',
+            },
+        };
+
+        await getClassHandler(req as Request, res as Response);
+
+        const result = jsonMock.mock.lastCall?.[0];
+        expect(result.class.teachers).toContain('FooFighters');
+    });
+});
--- a/backend/tests/test_assets/assignments/assignments.testdata.ts
+++ b/backend/tests/test_assets/assignments/assignments.testdata.ts
@ -2,9 +2,11 @@ import { EntityManager } from '@mikro-orm/core';
 import { Assignment } from '../../../src/entities/assignments/assignment.entity';
 import { Class } from '../../../src/entities/classes/class.entity';
 import { Language } from '@dwengo-1/common/util/language';
+import {testLearningPathWithConditions} from "../content/learning-paths.testdata";
+import {getClassWithTestleerlingAndTestleerkracht} from "../classes/classes.testdata";

 export function makeTestAssignemnts(em: EntityManager, classes: Class[]): Assignment[] {
-    const assignment01 = em.create(Assignment, {
+    assignment01 = em.create(Assignment, {
        within: classes[0],
        id: 1,
        title: 'dire straits',
@ -14,7 +16,7 @@ export function makeTestAssignemnts(em: EntityManager, classes: Class[]): Assign
        groups: [],
    });

-    const assignment02 = em.create(Assignment, {
+    assignment02 = em.create(Assignment, {
        within: classes[1],
        id: 2,
        title: 'tool',
@ -24,7 +26,7 @@ export function makeTestAssignemnts(em: EntityManager, classes: Class[]): Assign
        groups: [],
    });

-    const assignment03 = em.create(Assignment, {
+    assignment03 = em.create(Assignment, {
        within: classes[0],
        id: 3,
        title: 'delete',
@ -34,7 +36,7 @@ export function makeTestAssignemnts(em: EntityManager, classes: Class[]): Assign
        groups: [],
    });

-    const assignment04 = em.create(Assignment, {
+    assignment04 = em.create(Assignment, {
        within: classes[0],
        id: 4,
        title: 'another assignment',
@ -44,5 +46,41 @@ export function makeTestAssignemnts(em: EntityManager, classes: Class[]): Assign
        groups: [],
    });

-    return [assignment01, assignment02, assignment03, assignment04];
+    conditionalPathAssignment = em.create(Assignment, {
+        within: getClassWithTestleerlingAndTestleerkracht(),
+        id: 1,
+        title: 'Assignment: Conditional Learning Path',
+        description: 'You have to do the testing learning path with a condition.',
+        learningPathHruid: testLearningPathWithConditions.hruid,
+        learningPathLanguage: testLearningPathWithConditions.language as Language,
+        groups: [],
+    });
+
+    return [assignment01, assignment02, assignment03, assignment04, conditionalPathAssignment];
+}
+
+let assignment01: Assignment;
+let assignment02: Assignment;
+let assignment03: Assignment;
+let assignment04: Assignment;
+let conditionalPathAssignment: Assignment;
+
+export function getAssignment01(): Assignment {
+    return assignment01;
+}
+
+export function getAssignment02(): Assignment {
+    return assignment02;
+}
+
+export function getAssignment03(): Assignment {
+    return assignment03;
+}
+
+export function getAssignment04(): Assignment {
+    return assignment04;
+}
+
+export function getConditionalPathAssignment(): Assignment {
+    return conditionalPathAssignment;
 }
--- a/backend/tests/test_assets/assignments/groups.testdata.ts
+++ b/backend/tests/test_assets/assignments/groups.testdata.ts
@ -2,6 +2,8 @@ import {EntityManager} from '@mikro-orm/core';
 import { Group } from '../../../src/entities/assignments/group.entity';
 import { Assignment } from '../../../src/entities/assignments/assignment.entity';
 import { Student } from '../../../src/entities/users/student.entity';
+import {getConditionalPathAssignment} from "./assignments.testdata";
+import {getTestleerling1} from "../users/students.testdata";

 export function makeTestGroups(em: EntityManager, students: Student[], assignments: Assignment[]): Group[] {
    /*
@ -54,7 +56,16 @@ export function makeTestGroups(em: EntityManager, students: Student[], assignmen
        members: students.slice(0, 2),
    });

-    return [group01, group02, group03, group04, group05];
+    /**
+     * Group 1 for the assignment of the testing learning path with conditions.
+     */
+    group1ConditionalLearningPath = em.create(Group, {
+        assignment: getConditionalPathAssignment(),
+        groupNumber: 1,
+        members: [getTestleerling1()]
+    })
+
+    return [group01, group02, group03, group04, group05, group1ConditionalLearningPath];
 }

 let group01: Group;
@ -62,6 +73,7 @@ let group02: Group;
 let group03: Group;
 let group04: Group;
 let group05: Group;
+let group1ConditionalLearningPath: Group;

 export function getTestGroup01() {
    return group01;
@ -83,3 +95,6 @@ export function getTestGroup05() {
    return group05;
 }

+export function getGroup1ConditionalLearningPath() {
+    return group1ConditionalLearningPath;
+}
--- a/backend/tests/test_assets/classes/class-join-requests.testdata.ts
+++ b/backend/tests/test_assets/classes/class-join-requests.testdata.ts
@ -2,31 +2,31 @@ import { EntityManager } from '@mikro-orm/core';
 import { ClassJoinRequest } from '../../../src/entities/classes/class-join-request.entity';
 import { Student } from '../../../src/entities/users/student.entity';
 import { Class } from '../../../src/entities/classes/class.entity';
-import { ClassJoinRequestStatus } from '@dwengo-1/common/util/class-join-request';
+import { ClassStatus } from '@dwengo-1/common/util/class-join-request';

 export function makeTestClassJoinRequests(em: EntityManager, students: Student[], classes: Class[]): ClassJoinRequest[] {
    const classJoinRequest01 = em.create(ClassJoinRequest, {
        requester: students[4],
        class: classes[1],
-        status: ClassJoinRequestStatus.Open,
+        status: ClassStatus.Open,
    });

    const classJoinRequest02 = em.create(ClassJoinRequest, {
        requester: students[2],
        class: classes[1],
-        status: ClassJoinRequestStatus.Open,
+        status: ClassStatus.Open,
    });

    const classJoinRequest03 = em.create(ClassJoinRequest, {
        requester: students[4],
        class: classes[2],
-        status: ClassJoinRequestStatus.Open,
+        status: ClassStatus.Open,
    });

    const classJoinRequest04 = em.create(ClassJoinRequest, {
        requester: students[3],
        class: classes[2],
-        status: ClassJoinRequestStatus.Open,
+        status: ClassStatus.Open,
    });

    return [classJoinRequest01, classJoinRequest02, classJoinRequest03, classJoinRequest04];
--- a/backend/tests/test_assets/classes/classes.testdata.ts
+++ b/backend/tests/test_assets/classes/classes.testdata.ts
@ -2,12 +2,14 @@ import { EntityManager } from '@mikro-orm/core';
 import { Class } from '../../../src/entities/classes/class.entity';
 import { Student } from '../../../src/entities/users/student.entity';
 import { Teacher } from '../../../src/entities/users/teacher.entity';
+import {getTestleerkracht1} from "../users/teachers.testdata";
+import {getTestleerling1} from "../users/students.testdata";

 export function makeTestClasses(em: EntityManager, students: Student[], teachers: Teacher[]): Class[] {
    const studentsClass01 = students.slice(0, 8);
    const teacherClass01: Teacher[] = teachers.slice(4, 5);

-    const class01 = em.create(Class, {
+    class01 = em.create(Class, {
        classId: '8764b861-90a6-42e5-9732-c0d9eb2f55f9',
        displayName: 'class01',
        teachers: teacherClass01,
@ -17,7 +19,7 @@ export function makeTestClasses(em: EntityManager, students: Student[], teachers
    const studentsClass02: Student[] = students.slice(0, 2).concat(students.slice(3, 4));
    const teacherClass02: Teacher[] = teachers.slice(1, 2);

-    const class02 = em.create(Class, {
+    class02 = em.create(Class, {
        classId: '34d484a1-295f-4e9f-bfdc-3e7a23d86a89',
        displayName: 'class02',
        teachers: teacherClass02,
@ -27,7 +29,7 @@ export function makeTestClasses(em: EntityManager, students: Student[], teachers
    const studentsClass03: Student[] = students.slice(1, 4);
    const teacherClass03: Teacher[] = teachers.slice(2, 3);

-    const class03 = em.create(Class, {
+    class03 = em.create(Class, {
        classId: '80dcc3e0-1811-4091-9361-42c0eee91cfa',
        displayName: 'class03',
        teachers: teacherClass03,
@ -37,12 +39,45 @@ export function makeTestClasses(em: EntityManager, students: Student[], teachers
    const studentsClass04: Student[] = students.slice(0, 2);
    const teacherClass04: Teacher[] = teachers.slice(2, 3);

-    const class04 = em.create(Class, {
+    class04 = em.create(Class, {
        classId: '33d03536-83b8-4880-9982-9bbf2f908ddf',
        displayName: 'class04',
        teachers: teacherClass04,
        students: studentsClass04,
    });

-    return [class01, class02, class03, class04];
+    classWithTestleerlingAndTestleerkracht = em.create(Class, {
+        classId: "a75298b5-18aa-471d-8eeb-5d77eb989393",
+        displayName: 'Testklasse',
+        teachers: [getTestleerkracht1()],
+        students: [getTestleerling1()]
+    });
+
+    return [class01, class02, class03, class04, classWithTestleerlingAndTestleerkracht];
+}
+
+let class01: Class;
+let class02: Class;
+let class03: Class;
+let class04: Class;
+let classWithTestleerlingAndTestleerkracht: Class;
+
+export function getClass01(): Class {
+    return class01;
+}
+
+export function getClass02(): Class {
+    return class02;
+}
+
+export function getClass03(): Class {
+    return class03;
+}
+
+export function getClass04(): Class {
+    return class04;
+}
+
+export function getClassWithTestleerlingAndTestleerkracht(): Class {
+    return classWithTestleerlingAndTestleerkracht;
 }
--- a/backend/tests/test_assets/classes/teacher-invitations.testdata.ts
+++ b/backend/tests/test_assets/classes/teacher-invitations.testdata.ts
@ -2,30 +2,35 @@ import { EntityManager } from '@mikro-orm/core';
 import { TeacherInvitation } from '../../../src/entities/classes/teacher-invitation.entity';
 import { Teacher } from '../../../src/entities/users/teacher.entity';
 import { Class } from '../../../src/entities/classes/class.entity';
+import { ClassStatus } from '@dwengo-1/common/util/class-join-request';

 export function makeTestTeacherInvitations(em: EntityManager, teachers: Teacher[], classes: Class[]): TeacherInvitation[] {
    const teacherInvitation01 = em.create(TeacherInvitation, {
        sender: teachers[1],
        receiver: teachers[0],
        class: classes[1],
+        status: ClassStatus.Open,
    });

    const teacherInvitation02 = em.create(TeacherInvitation, {
        sender: teachers[1],
        receiver: teachers[2],
        class: classes[1],
+        status: ClassStatus.Open,
    });

    const teacherInvitation03 = em.create(TeacherInvitation, {
        sender: teachers[2],
        receiver: teachers[0],
        class: classes[2],
+        status: ClassStatus.Open,
    });

    const teacherInvitation04 = em.create(TeacherInvitation, {
        sender: teachers[0],
        receiver: teachers[1],
        class: classes[0],
+        status: ClassStatus.Open,
    });

    return [teacherInvitation01, teacherInvitation02, teacherInvitation03, teacherInvitation04];
--- a/backend/tests/test_assets/users/students.testdata.ts
+++ b/backend/tests/test_assets/users/students.testdata.ts
@ -15,7 +15,14 @@ export const TEST_STUDENTS = [
    { username: 'testleerling1', firstName: 'Gerald', lastName: 'Schmittinger' },
 ];

+let testStudents: Student[];
+
 // 🏗️ Functie die ORM entities maakt uit de data array
 export function makeTestStudents(em: EntityManager): Student[] {
-    return TEST_STUDENTS.map((data) => em.create(Student, data));
+    testStudents = TEST_STUDENTS.map((data) => em.create(Student, data));
+    return testStudents;
+}
+
+export function getTestleerling1(): Student {
+    return testStudents.find(it => it.username == "testleerling1");
 }
--- a/backend/tests/test_assets/users/teachers.testdata.ts
+++ b/backend/tests/test_assets/users/teachers.testdata.ts
@ -2,37 +2,64 @@ import { Teacher } from '../../../src/entities/users/teacher.entity';
 import { EntityManager } from '@mikro-orm/core';

 export function makeTestTeachers(em: EntityManager): Teacher[] {
-    const teacher01 = em.create(Teacher, {
+    teacher01 = em.create(Teacher, {
        username: 'FooFighters',
        firstName: 'Dave',
        lastName: 'Grohl',
    });

-    const teacher02 = em.create(Teacher, {
+    teacher02 = em.create(Teacher, {
        username: 'LimpBizkit',
        firstName: 'Fred',
        lastName: 'Durst',
    });

-    const teacher03 = em.create(Teacher, {
+    teacher03 = em.create(Teacher, {
        username: 'Staind',
        firstName: 'Aaron',
        lastName: 'Lewis',
    });

    // Should not be used, gets deleted in a unit test
-    const teacher04 = em.create(Teacher, {
+    teacher04 = em.create(Teacher, {
        username: 'ZesdeMetaal',
        firstName: 'Wannes',
        lastName: 'Cappelle',
    });

    // Makes sure when logged in as testleerkracht1, there exists a corresponding user
-    const teacher05 = em.create(Teacher, {
+    testleerkracht1 = em.create(Teacher, {
        username: 'testleerkracht1',
-        firstName: 'Bob',
-        lastName: 'Dylan',
+        firstName: 'Kris',
+        lastName: 'Coolsaet',
    });

-    return [teacher01, teacher02, teacher03, teacher04, teacher05];
+    return [teacher01, teacher02, teacher03, teacher04, testleerkracht1];
 }
+
+let teacher01: Teacher;
+let teacher02: Teacher;
+let teacher03: Teacher;
+let teacher04: Teacher;
+let testleerkracht1: Teacher;
+
+export function getTeacher01(): Teacher {
+    return teacher01;
+}
+
+export function getTeacher02(): Teacher {
+    return teacher02;
+}
+
+export function getTeacher03(): Teacher {
+    return teacher03;
+}
+
+export function getTeacher04(): Teacher {
+    return teacher04;
+}
+
+export function getTestleerkracht1(): Teacher {
+    return testleerkracht1;
+}
+
--- a/backend/tool/seed.ts
+++ b/backend/tool/seed.ts
@ -49,7 +49,6 @@ export async function seedDatabase(): Promise<void> {
    const answers = makeTestAnswers(em, teachers, questions);
    const submissions = makeTestSubmissions(em, students, groups);

-
    // Persist all entities
    await em.persistAndFlush([
        ...students,
--- a/common/src/interfaces/class-join-request.ts
+++ b/common/src/interfaces/class-join-request.ts
@ -1,8 +1,8 @@
 import { StudentDTO } from './student';
-import { ClassJoinRequestStatus } from '../util/class-join-request';
+import { ClassStatus } from '../util/class-join-request';

 export interface ClassJoinRequestDTO {
    requester: StudentDTO;
    class: string;
-    status: ClassJoinRequestStatus;
+    status: ClassStatus;
 }
--- a/common/src/interfaces/teacher-invitation.ts
+++ b/common/src/interfaces/teacher-invitation.ts
@ -1,8 +1,16 @@
 import { UserDTO } from './user';
-import { ClassDTO } from './class';
+import { ClassStatus } from '../util/class-join-request';

 export interface TeacherInvitationDTO {
    sender: string | UserDTO;
    receiver: string | UserDTO;
-    class: string | ClassDTO;
+    classId: string;
+    status: ClassStatus;
+}
+
+export interface TeacherInvitationData {
+    sender: string;
+    receiver: string;
+    class: string;
+    accepted?: boolean; // Use for put requests, else skip
 }
--- a/common/src/util/class-join-request.ts
+++ b/common/src/util/class-join-request.ts
@ -1,4 +1,4 @@
-export enum ClassJoinRequestStatus {
+export enum ClassStatus {
    Open = 'open',
    Accepted = 'accepted',
    Declined = 'declined',
--- a/frontend/package.json
+++ b/frontend/package.json
@ -17,6 +17,7 @@
        "test:unit": "vitest --run"
    },
    "dependencies": {
+        "@dwengo-1/common": "^0.1.1",
        "@tanstack/react-query": "^5.69.0",
        "@tanstack/vue-query": "^5.69.0",
        "axios": "^1.8.2",
--- a/frontend/src/controllers/classes.ts
+++ b/frontend/src/controllers/classes.ts
@ -2,8 +2,8 @@ import { BaseController } from "./base-controller";
 import type { ClassDTO } from "@dwengo-1/common/interfaces/class";
 import type { StudentsResponse } from "./students";
 import type { AssignmentsResponse } from "./assignments";
-import type { TeacherInvitationDTO } from "@dwengo-1/common/interfaces/teacher-invitation";
 import type { TeachersResponse } from "@/controllers/teachers.ts";
+import type { TeacherInvitationsResponse } from "@/controllers/teacher-invitations.ts";

 export interface ClassesResponse {
    classes: ClassDTO[] | string[];
@ -13,14 +13,6 @@ export interface ClassResponse {
    class: ClassDTO;
 }

-export interface TeacherInvitationsResponse {
-    invites: TeacherInvitationDTO[];
-}
-
-export interface TeacherInvitationResponse {
-    invite: TeacherInvitationDTO;
-}
-
 export class ClassController extends BaseController {
    constructor() {
        super("class");
--- a/frontend/src/controllers/groups.ts
+++ b/frontend/src/controllers/groups.ts
@ -36,11 +36,11 @@ export class GroupController extends BaseController {
        return this.put<GroupResponse>(`/${num}`, data);
    }

-    async getSubmissions(groupNumber: number, full = true): Promise<SubmissionsResponse> {
-        return this.get<SubmissionsResponse>(`/${groupNumber}/submissions`, { full });
+    async getSubmissions(num: number, full = true): Promise<SubmissionsResponse> {
+        return this.get<SubmissionsResponse>(`/${num}/submissions`, { full });
    }

-    async getQuestions(groupNumber: number, full = true): Promise<QuestionsResponse> {
-        return this.get<QuestionsResponse>(`/${groupNumber}/questions`, { full });
+    async getQuestions(num: number, full = true): Promise<QuestionsResponse> {
+        return this.get<QuestionsResponse>(`/${num}/questions`, { full });
    }
 }
--- a/frontend/src/controllers/learning-paths.ts
+++ b/frontend/src/controllers/learning-paths.ts
@ -15,13 +15,14 @@ export class LearningPathController extends BaseController {
    async getBy(
        hruid: string,
        language: Language,
-        options?: { forGroup?: string; forStudent?: string },
+        forGroup?: { forGroup: number, assignmentNo: number, classId: string },
    ): Promise<LearningPath> {
        const dtos = await this.get<LearningPathDTO[]>("/", {
            hruid,
            language,
-            forGroup: options?.forGroup,
-            forStudent: options?.forStudent,
+            forGroup: forGroup?.forGroup,
+            assignmentNo: forGroup?.assignmentNo,
+            classId: forGroup?.classId
        });
        return LearningPath.fromDTO(single(dtos));
    }
--- a/frontend/src/controllers/submissions.ts
+++ b/frontend/src/controllers/submissions.ts
@ -1,5 +1,6 @@
 import { BaseController } from "./base-controller";
 import type { SubmissionDTO, SubmissionDTOId } from "@dwengo-1/common/interfaces/submission";
+import type {Language} from "@dwengo-1/common/util/language";

 export interface SubmissionsResponse {
    submissions: SubmissionDTO[] | SubmissionDTOId[];
@ -10,19 +11,35 @@ export interface SubmissionResponse {
 }

 export class SubmissionController extends BaseController {
-    constructor(classid: string, assignmentNumber: number, groupNumber: number) {
-        super(`class/${classid}/assignments/${assignmentNumber}/groups/${groupNumber}`);
+
+    constructor(hruid: string) {
+        super(`learningObject/${hruid}/submissions`);
    }

-    async getAll(full = true): Promise<SubmissionsResponse> {
-        return this.get<SubmissionsResponse>(`/`, { full });
+    async getAll(
+        language: Language, version: number, classId: string, assignmentId: number, groupId?: number, full = true
+    ): Promise<SubmissionsResponse> {
+        return this.get<SubmissionsResponse>(
+            `/`,
+            { language, version, classId, assignmentId, groupId, full }
+        );
    }

-    async getByNumber(submissionNumber: number): Promise<SubmissionResponse> {
-        return this.get<SubmissionResponse>(`/${submissionNumber}`);
+    async getByNumber(
+        language: Language,
+        version: number,
+        classId: string,
+        assignmentId: number,
+        groupId: number,
+        submissionNumber: number
+    ): Promise<SubmissionResponse> {
+        return this.get<SubmissionResponse>(
+            `/${submissionNumber}`,
+            { language, version, classId, assignmentId, groupId },
+        );
    }

-    async createSubmission(data: unknown): Promise<SubmissionResponse> {
+    async createSubmission(data: SubmissionDTO): Promise<SubmissionResponse> {
        return this.post<SubmissionResponse>(`/`, data);
    }

--- a/frontend/src/controllers/teacher-invitations.ts
+++ b/frontend/src/controllers/teacher-invitations.ts
@ -0,0 +1,36 @@
+import { BaseController } from "@/controllers/base-controller.ts";
+import type { TeacherInvitationData, TeacherInvitationDTO } from "@dwengo-1/common/interfaces/teacher-invitation";
+
+export interface TeacherInvitationsResponse {
+    invitations: TeacherInvitationDTO[];
+}
+
+export interface TeacherInvitationResponse {
+    invitation: TeacherInvitationDTO;
+}
+
+export class TeacherInvitationController extends BaseController {
+    constructor() {
+        super("teachers/invitations");
+    }
+
+    async getAll(username: string, sent: boolean): Promise<TeacherInvitationsResponse> {
+        return this.get<TeacherInvitationsResponse>(`/${username}`, { sent });
+    }
+
+    async getBy(data: TeacherInvitationData): Promise<TeacherInvitationResponse> {
+        return this.get<TeacherInvitationResponse>(`/${data.sender}/${data.receiver}/${data.class}`);
+    }
+
+    async create(data: TeacherInvitationData): Promise<TeacherInvitationResponse> {
+        return this.post<TeacherInvitationResponse>("/", data);
+    }
+
+    async remove(data: TeacherInvitationData): Promise<TeacherInvitationResponse> {
+        return this.delete<TeacherInvitationResponse>(`/${data.sender}/${data.receiver}/${data.class}`);
+    }
+
+    async respond(data: TeacherInvitationData): Promise<TeacherInvitationResponse> {
+        return this.put<TeacherInvitationResponse>("/", data);
+    }
+}
--- a/frontend/src/queries/assignments.ts
+++ b/frontend/src/queries/assignments.ts
@ -0,0 +1,188 @@
+import { AssignmentController, type AssignmentResponse, type AssignmentsResponse } from "@/controllers/assignments";
+import type { QuestionsResponse } from "@/controllers/questions";
+import type { SubmissionsResponse } from "@/controllers/submissions";
+import {
+    useMutation,
+    useQuery,
+    useQueryClient,
+    type UseMutationReturnType,
+    type UseQueryReturnType,
+} from "@tanstack/vue-query";
+import { computed, toValue, type MaybeRefOrGetter } from "vue";
+import { groupsQueryKey, invalidateAllGroupKeys } from "./groups";
+import type { GroupsResponse } from "@/controllers/groups";
+import type { AssignmentDTO } from "@dwengo-1/common/interfaces/assignment";
+import type { QueryClient } from "@tanstack/react-query";
+import { invalidateAllSubmissionKeys } from "./submissions";
+
+function assignmentsQueryKey(classid: string, full: boolean) {
+    return ["assignments", classid, full];
+}
+function assignmentQueryKey(classid: string, assignmentNumber: number) {
+    return ["assignment", classid, assignmentNumber];
+}
+function assignmentSubmissionsQueryKey(classid: string, assignmentNumber: number, full: boolean) {
+    return ["assignment-submissions", classid, assignmentNumber, full];
+}
+function assignmentQuestionsQueryKey(classid: string, assignmentNumber: number, full: boolean) {
+    return ["assignment-questions", classid, assignmentNumber, full];
+}
+
+export async function invalidateAllAssignmentKeys(
+    queryClient: QueryClient,
+    classid?: string,
+    assignmentNumber?: number,
+) {
+    const keys = ["assignment", "assignment-submissions", "assignment-questions"];
+
+    for (const key of keys) {
+        const queryKey = [key, classid, assignmentNumber].filter((arg) => arg !== undefined);
+        await queryClient.invalidateQueries({ queryKey: queryKey });
+    }
+
+    await queryClient.invalidateQueries({ queryKey: ["assignments", classid].filter((arg) => arg !== undefined) });
+}
+
+function checkEnabled(
+    classid: string | undefined,
+    assignmentNumber: number | undefined,
+    groupNumber: number | undefined,
+): boolean {
+    return Boolean(classid) && !isNaN(Number(groupNumber)) && !isNaN(Number(assignmentNumber));
+}
+function toValues(
+    classid: MaybeRefOrGetter<string | undefined>,
+    assignmentNumber: MaybeRefOrGetter<number | undefined>,
+    groupNumber: MaybeRefOrGetter<number | undefined>,
+    full: MaybeRefOrGetter<boolean>,
+) {
+    return { cid: toValue(classid), an: toValue(assignmentNumber), gn: toValue(groupNumber), f: toValue(full) };
+}
+
+export function useAssignmentsQuery(
+    classid: MaybeRefOrGetter<string | undefined>,
+    full: MaybeRefOrGetter<boolean> = true,
+): UseQueryReturnType<AssignmentsResponse, Error> {
+    const { cid, f } = toValues(classid, 1, 1, full);
+
+    return useQuery({
+        queryKey: computed(() => assignmentsQueryKey(cid!, f)),
+        queryFn: async () => new AssignmentController(cid!).getAll(f),
+        enabled: () => checkEnabled(cid, 1, 1),
+    });
+}
+
+export function useAssignmentQuery(
+    classid: MaybeRefOrGetter<string | undefined>,
+    assignmentNumber: MaybeRefOrGetter<number | undefined>,
+): UseQueryReturnType<AssignmentsResponse, Error> {
+    const { cid, an } = toValues(classid, assignmentNumber, 1, true);
+
+    return useQuery({
+        queryKey: computed(() => assignmentQueryKey(cid!, an!)),
+        queryFn: async () => new AssignmentController(cid!).getByNumber(an!),
+        enabled: () => checkEnabled(cid, an, 1),
+    });
+}
+
+export function useCreateAssignmentMutation(): UseMutationReturnType<
+    AssignmentResponse,
+    Error,
+    { cid: string; data: AssignmentDTO },
+    unknown
+> {
+    const queryClient = useQueryClient();
+
+    return useMutation({
+        mutationFn: async ({ cid, data }) => new AssignmentController(cid).createAssignment(data),
+        onSuccess: async (_) => {
+            await queryClient.invalidateQueries({ queryKey: ["assignments"] });
+        },
+    });
+}
+
+export function useDeleteAssignmentMutation(): UseMutationReturnType<
+    AssignmentResponse,
+    Error,
+    { cid: string; an: number },
+    unknown
+> {
+    const queryClient = useQueryClient();
+
+    return useMutation({
+        mutationFn: async ({ cid, an }) => new AssignmentController(cid).deleteAssignment(an),
+        onSuccess: async (response) => {
+            const cid = response.assignment.within;
+            const an = response.assignment.id;
+
+            await invalidateAllAssignmentKeys(queryClient, cid, an);
+            await invalidateAllGroupKeys(queryClient, cid, an);
+            await invalidateAllSubmissionKeys(queryClient, cid, an);
+        },
+    });
+}
+
+export function useUpdateAssignmentMutation(): UseMutationReturnType<
+    AssignmentResponse,
+    Error,
+    { cid: string; an: number; data: Partial<AssignmentDTO> },
+    unknown
+> {
+    const queryClient = useQueryClient();
+
+    return useMutation({
+        mutationFn: async ({ cid, an, data }) => new AssignmentController(cid).updateAssignment(an, data),
+        onSuccess: async (response) => {
+            const cid = response.assignment.within;
+            const an = response.assignment.id;
+
+            await invalidateAllGroupKeys(queryClient, cid, an);
+            await queryClient.invalidateQueries({ queryKey: ["assignments"] });
+        },
+    });
+}
+
+export function useAssignmentSubmissionsQuery(
+    classid: MaybeRefOrGetter<string | undefined>,
+    assignmentNumber: MaybeRefOrGetter<number | undefined>,
+    groupNumber: MaybeRefOrGetter<number | undefined>,
+    full: MaybeRefOrGetter<boolean> = true,
+): UseQueryReturnType<SubmissionsResponse, Error> {
+    const { cid, an, gn, f } = toValues(classid, assignmentNumber, groupNumber, full);
+
+    return useQuery({
+        queryKey: computed(() => assignmentSubmissionsQueryKey(cid!, an!, f)),
+        queryFn: async () => new AssignmentController(cid!).getSubmissions(gn!, f),
+        enabled: () => checkEnabled(cid, an, gn),
+    });
+}
+
+export function useAssignmentQuestionsQuery(
+    classid: MaybeRefOrGetter<string | undefined>,
+    assignmentNumber: MaybeRefOrGetter<number | undefined>,
+    groupNumber: MaybeRefOrGetter<number | undefined>,
+    full: MaybeRefOrGetter<boolean> = true,
+): UseQueryReturnType<QuestionsResponse, Error> {
+    const { cid, an, gn, f } = toValues(classid, assignmentNumber, groupNumber, full);
+
+    return useQuery({
+        queryKey: computed(() => assignmentQuestionsQueryKey(cid!, an!, f)),
+        queryFn: async () => new AssignmentController(cid!).getQuestions(gn!, f),
+        enabled: () => checkEnabled(cid, an, gn),
+    });
+}
+
+export function useAssignmentGroupsQuery(
+    classid: MaybeRefOrGetter<string | undefined>,
+    assignmentNumber: MaybeRefOrGetter<number | undefined>,
+    groupNumber: MaybeRefOrGetter<number | undefined>,
+    full: MaybeRefOrGetter<boolean> = true,
+): UseQueryReturnType<GroupsResponse, Error> {
+    const { cid, an, gn, f } = toValues(classid, assignmentNumber, groupNumber, full);
+
+    return useQuery({
+        queryKey: computed(() => groupsQueryKey(cid!, an!, f)),
+        queryFn: async () => new AssignmentController(cid!).getQuestions(gn!, f),
+        enabled: () => checkEnabled(cid, an, gn),
+    });
+}
--- a/frontend/src/queries/classes.ts
+++ b/frontend/src/queries/classes.ts
@ -0,0 +1,224 @@
+import { ClassController, type ClassesResponse, type ClassResponse } from "@/controllers/classes";
+import type { StudentsResponse } from "@/controllers/students";
+import type { ClassDTO } from "@dwengo-1/common/interfaces/class";
+import {
+    QueryClient,
+    useMutation,
+    useQuery,
+    useQueryClient,
+    type UseMutationReturnType,
+    type UseQueryReturnType,
+} from "@tanstack/vue-query";
+import { computed, toValue, type MaybeRefOrGetter } from "vue";
+import { invalidateAllAssignmentKeys } from "./assignments";
+import { invalidateAllGroupKeys } from "./groups";
+import { invalidateAllSubmissionKeys } from "./submissions";
+
+const classController = new ClassController();
+
+/* Query cache keys */
+function classesQueryKey(full: boolean) {
+    return ["classes", full];
+}
+function classQueryKey(classid: string) {
+    return ["class", classid];
+}
+function classStudentsKey(classid: string, full: boolean) {
+    return ["class-students", classid, full];
+}
+function classTeachersKey(classid: string, full: boolean) {
+    return ["class-teachers", classid, full];
+}
+function classTeacherInvitationsKey(classid: string, full: boolean) {
+    return ["class-teacher-invitations", classid, full];
+}
+function classAssignmentsKey(classid: string, full: boolean) {
+    return ["class-assignments", classid, full];
+}
+
+export async function invalidateAllClassKeys(queryClient: QueryClient, classid?: string) {
+    const keys = ["class", "class-students", "class-teachers", "class-teacher-invitations", "class-assignments"];
+
+    for (const key of keys) {
+        const queryKey = [key, classid].filter((arg) => arg !== undefined);
+        await queryClient.invalidateQueries({ queryKey: queryKey });
+    }
+
+    await queryClient.invalidateQueries({ queryKey: ["classes"] });
+}
+
+/* Queries */
+export function useClassesQuery(full: MaybeRefOrGetter<boolean> = true): UseQueryReturnType<ClassesResponse, Error> {
+    return useQuery({
+        queryKey: computed(() => classesQueryKey(toValue(full))),
+        queryFn: async () => classController.getAll(toValue(full)),
+    });
+}
+
+export function useClassQuery(id: MaybeRefOrGetter<string | undefined>): UseQueryReturnType<ClassResponse, Error> {
+    return useQuery({
+        queryKey: computed(() => classQueryKey(toValue(id)!)),
+        queryFn: async () => classController.getById(toValue(id)!),
+        enabled: () => Boolean(toValue(id)),
+    });
+}
+
+export function useCreateClassMutation(): UseMutationReturnType<ClassResponse, Error, ClassDTO, unknown> {
+    const queryClient = useQueryClient();
+
+    return useMutation({
+        mutationFn: async (data) => classController.createClass(data),
+        onSuccess: async () => {
+            await queryClient.invalidateQueries({ queryKey: ["classes"] });
+        },
+    });
+}
+
+export function useDeleteClassMutation(): UseMutationReturnType<ClassResponse, Error, string, unknown> {
+    const queryClient = useQueryClient();
+
+    return useMutation({
+        mutationFn: async (id) => classController.deleteClass(id),
+        onSuccess: async (data) => {
+            await invalidateAllClassKeys(queryClient, data.class.id);
+            await invalidateAllAssignmentKeys(queryClient, data.class.id);
+            await invalidateAllGroupKeys(queryClient, data.class.id);
+            await invalidateAllSubmissionKeys(queryClient, data.class.id);
+        },
+    });
+}
+
+export function useUpdateClassMutation(): UseMutationReturnType<
+    ClassResponse,
+    Error,
+    { cid: string; data: Partial<ClassDTO> },
+    unknown
+> {
+    const queryClient = useQueryClient();
+
+    return useMutation({
+        mutationFn: async ({ cid, data }) => classController.updateClass(cid, data),
+        onSuccess: async (data) => {
+            await invalidateAllClassKeys(queryClient, data.class.id);
+            await invalidateAllAssignmentKeys(queryClient, data.class.id);
+            await invalidateAllGroupKeys(queryClient, data.class.id);
+            await invalidateAllSubmissionKeys(queryClient, data.class.id);
+        },
+    });
+}
+
+export function useClassStudentsQuery(
+    id: MaybeRefOrGetter<string | undefined>,
+    full: MaybeRefOrGetter<boolean> = true,
+): UseQueryReturnType<StudentsResponse, Error> {
+    return useQuery({
+        queryKey: computed(() => classStudentsKey(toValue(id)!, toValue(full))),
+        queryFn: async () => classController.getStudents(toValue(id)!, toValue(full)),
+        enabled: () => Boolean(toValue(id)),
+    });
+}
+
+export function useClassAddStudentMutation(): UseMutationReturnType<
+    ClassResponse,
+    Error,
+    { id: string; username: string },
+    unknown
+> {
+    const queryClient = useQueryClient();
+
+    return useMutation({
+        mutationFn: async ({ id, username }) => classController.addStudent(id, username),
+        onSuccess: async (data) => {
+            await queryClient.invalidateQueries({ queryKey: classQueryKey(data.class.id) });
+            await queryClient.invalidateQueries({ queryKey: classStudentsKey(data.class.id, true) });
+            await queryClient.invalidateQueries({ queryKey: classStudentsKey(data.class.id, false) });
+        },
+    });
+}
+
+export function useClassDeleteStudentMutation(): UseMutationReturnType<
+    ClassResponse,
+    Error,
+    { id: string; username: string },
+    unknown
+> {
+    const queryClient = useQueryClient();
+
+    return useMutation({
+        mutationFn: async ({ id, username }) => classController.deleteStudent(id, username),
+        onSuccess: async (data) => {
+            await queryClient.invalidateQueries({ queryKey: classQueryKey(data.class.id) });
+            await queryClient.invalidateQueries({ queryKey: classStudentsKey(data.class.id, true) });
+            await queryClient.invalidateQueries({ queryKey: classStudentsKey(data.class.id, false) });
+        },
+    });
+}
+
+export function useClassTeachersQuery(
+    id: MaybeRefOrGetter<string | undefined>,
+    full: MaybeRefOrGetter<boolean> = true,
+): UseQueryReturnType<StudentsResponse, Error> {
+    return useQuery({
+        queryKey: computed(() => classTeachersKey(toValue(id)!, toValue(full))),
+        queryFn: async () => classController.getTeachers(toValue(id)!, toValue(full)),
+        enabled: () => Boolean(toValue(id)),
+    });
+}
+
+export function useClassAddTeacherMutation(): UseMutationReturnType<
+    ClassResponse,
+    Error,
+    { id: string; username: string },
+    unknown
+> {
+    const queryClient = useQueryClient();
+
+    return useMutation({
+        mutationFn: async ({ id, username }) => classController.addTeacher(id, username),
+        onSuccess: async (data) => {
+            await queryClient.invalidateQueries({ queryKey: classQueryKey(data.class.id) });
+            await queryClient.invalidateQueries({ queryKey: classTeachersKey(data.class.id, true) });
+            await queryClient.invalidateQueries({ queryKey: classTeachersKey(data.class.id, false) });
+        },
+    });
+}
+
+export function useClassDeleteTeacherMutation(): UseMutationReturnType<
+    ClassResponse,
+    Error,
+    { id: string; username: string },
+    unknown
+> {
+    const queryClient = useQueryClient();
+
+    return useMutation({
+        mutationFn: async ({ id, username }) => classController.deleteTeacher(id, username),
+        onSuccess: async (data) => {
+            await queryClient.invalidateQueries({ queryKey: classQueryKey(data.class.id) });
+            await queryClient.invalidateQueries({ queryKey: classTeachersKey(data.class.id, true) });
+            await queryClient.invalidateQueries({ queryKey: classTeachersKey(data.class.id, false) });
+        },
+    });
+}
+
+export function useClassTeacherInvitationsQuery(
+    id: MaybeRefOrGetter<string | undefined>,
+    full: MaybeRefOrGetter<boolean> = true,
+): UseQueryReturnType<StudentsResponse, Error> {
+    return useQuery({
+        queryKey: computed(() => classTeacherInvitationsKey(toValue(id)!, toValue(full))),
+        queryFn: async () => classController.getTeacherInvitations(toValue(id)!, toValue(full)),
+        enabled: () => Boolean(toValue(id)),
+    });
+}
+
+export function useClassAssignmentsQuery(
+    id: MaybeRefOrGetter<string | undefined>,
+    full: MaybeRefOrGetter<boolean> = true,
+): UseQueryReturnType<StudentsResponse, Error> {
+    return useQuery({
+        queryKey: computed(() => classAssignmentsKey(toValue(id)!, toValue(full))),
+        queryFn: async () => classController.getAssignments(toValue(id)!, toValue(full)),
+        enabled: () => Boolean(toValue(id)),
+    });
+}
--- a/frontend/src/queries/groups.ts
+++ b/frontend/src/queries/groups.ts
@ -0,0 +1,191 @@
+import type { ClassesResponse } from "@/controllers/classes";
+import { GroupController, type GroupResponse, type GroupsResponse } from "@/controllers/groups";
+import type { QuestionsResponse } from "@/controllers/questions";
+import type { SubmissionsResponse } from "@/controllers/submissions";
+import type { GroupDTO } from "@dwengo-1/common/interfaces/group";
+import {
+    QueryClient,
+    useMutation,
+    useQuery,
+    useQueryClient,
+    type UseMutationReturnType,
+    type UseQueryReturnType,
+} from "@tanstack/vue-query";
+import { computed, toValue, type MaybeRefOrGetter } from "vue";
+import { invalidateAllAssignmentKeys } from "./assignments";
+import { invalidateAllSubmissionKeys } from "./submissions";
+
+export function groupsQueryKey(classid: string, assignmentNumber: number, full: boolean) {
+    return ["groups", classid, assignmentNumber, full];
+}
+function groupQueryKey(classid: string, assignmentNumber: number, groupNumber: number) {
+    return ["group", classid, assignmentNumber, groupNumber];
+}
+function groupSubmissionsQueryKey(classid: string, assignmentNumber: number, groupNumber: number, full: boolean) {
+    return ["group-submissions", classid, assignmentNumber, groupNumber, full];
+}
+function groupQuestionsQueryKey(classid: string, assignmentNumber: number, groupNumber: number, full: boolean) {
+    return ["group-questions", classid, assignmentNumber, groupNumber, full];
+}
+
+export async function invalidateAllGroupKeys(
+    queryClient: QueryClient,
+    classid?: string,
+    assignmentNumber?: number,
+    groupNumber?: number,
+) {
+    const keys = ["group", "group-submissions", "group-questions"];
+
+    for (const key of keys) {
+        const queryKey = [key, classid, assignmentNumber, groupNumber].filter((arg) => arg !== undefined);
+        await queryClient.invalidateQueries({ queryKey: queryKey });
+    }
+
+    await queryClient.invalidateQueries({
+        queryKey: ["groups", classid, assignmentNumber].filter((arg) => arg !== undefined),
+    });
+}
+
+function checkEnabled(
+    classid: string | undefined,
+    assignmentNumber: number | undefined,
+    groupNumber: number | undefined,
+): boolean {
+    return Boolean(classid) && !isNaN(Number(groupNumber)) && !isNaN(Number(assignmentNumber));
+}
+function toValues(
+    classid: MaybeRefOrGetter<string | undefined>,
+    assignmentNumber: MaybeRefOrGetter<number | undefined>,
+    groupNumber: MaybeRefOrGetter<number | undefined>,
+    full: MaybeRefOrGetter<boolean>,
+) {
+    return { cid: toValue(classid), an: toValue(assignmentNumber), gn: toValue(groupNumber), f: toValue(full) };
+}
+
+export function useGroupsQuery(
+    classid: MaybeRefOrGetter<string | undefined>,
+    assignmentNumber: MaybeRefOrGetter<number | undefined>,
+    full: MaybeRefOrGetter<boolean> = true,
+): UseQueryReturnType<GroupsResponse, Error> {
+    const { cid, an, f } = toValues(classid, assignmentNumber, 1, full);
+
+    return useQuery({
+        queryKey: computed(() => groupsQueryKey(cid!, an!, f)),
+        queryFn: async () => new GroupController(cid!, an!).getAll(f),
+        enabled: () => checkEnabled(cid, an, 1),
+    });
+}
+
+export function useGroupQuery(
+    classid: MaybeRefOrGetter<string | undefined>,
+    assignmentNumber: MaybeRefOrGetter<number | undefined>,
+    groupNumber: MaybeRefOrGetter<number | undefined>,
+): UseQueryReturnType<GroupResponse, Error> {
+    const { cid, an, gn } = toValues(classid, assignmentNumber, groupNumber, true);
+
+    return useQuery({
+        queryKey: computed(() => groupQueryKey(cid!, an!, gn!)),
+        queryFn: async () => new GroupController(cid!, an!).getByNumber(gn!),
+        enabled: () => checkEnabled(cid, an, gn),
+    });
+}
+
+export function useCreateGroupMutation(): UseMutationReturnType<
+    GroupResponse,
+    Error,
+    { cid: string; an: number; data: GroupDTO },
+    unknown
+> {
+    const queryClient = useQueryClient();
+
+    return useMutation({
+        mutationFn: async ({ cid, an, data }) => new GroupController(cid, an).createGroup(data),
+        onSuccess: async (response) => {
+            const cid = typeof response.group.class === "string" ? response.group.class : response.group.class.id;
+            const an =
+                typeof response.group.assignment === "number"
+                    ? response.group.assignment
+                    : response.group.assignment.id;
+
+            await queryClient.invalidateQueries({ queryKey: groupsQueryKey(cid, an, true) });
+            await queryClient.invalidateQueries({ queryKey: groupsQueryKey(cid, an, false) });
+        },
+    });
+}
+
+export function useDeleteGroupMutation(): UseMutationReturnType<
+    GroupResponse,
+    Error,
+    { cid: string; an: number; gn: number },
+    unknown
+> {
+    const queryClient = useQueryClient();
+
+    return useMutation({
+        mutationFn: async ({ cid, an, gn }) => new GroupController(cid, an).deleteGroup(gn),
+        onSuccess: async (response) => {
+            const cid = typeof response.group.class === "string" ? response.group.class : response.group.class.id;
+            const an =
+                typeof response.group.assignment === "number"
+                    ? response.group.assignment
+                    : response.group.assignment.id;
+            const gn = response.group.groupNumber;
+
+            await invalidateAllGroupKeys(queryClient, cid, an, gn);
+            await invalidateAllSubmissionKeys(queryClient, cid, an, gn);
+        },
+    });
+}
+
+export function useUpdateGroupMutation(): UseMutationReturnType<
+    GroupResponse,
+    Error,
+    { cid: string; an: number; gn: number; data: Partial<GroupDTO> },
+    unknown
+> {
+    const queryClient = useQueryClient();
+
+    return useMutation({
+        mutationFn: async ({ cid, an, gn, data }) => new GroupController(cid, an).updateGroup(gn, data),
+        onSuccess: async (response) => {
+            const cid = typeof response.group.class === "string" ? response.group.class : response.group.class.id;
+            const an =
+                typeof response.group.assignment === "number"
+                    ? response.group.assignment
+                    : response.group.assignment.id;
+            const gn = response.group.groupNumber;
+
+            await invalidateAllGroupKeys(queryClient, cid, an, gn);
+        },
+    });
+}
+
+export function useGroupSubmissionsQuery(
+    classid: MaybeRefOrGetter<string | undefined>,
+    assignmentNumber: MaybeRefOrGetter<number | undefined>,
+    groupNumber: MaybeRefOrGetter<number | undefined>,
+    full: MaybeRefOrGetter<boolean> = true,
+): UseQueryReturnType<SubmissionsResponse, Error> {
+    const { cid, an, gn, f } = toValues(classid, assignmentNumber, groupNumber, full);
+
+    return useQuery({
+        queryKey: computed(() => groupSubmissionsQueryKey(cid!, an!, gn!, f)),
+        queryFn: async () => new GroupController(cid!, an!).getSubmissions(gn!, f),
+        enabled: () => checkEnabled(cid, an, gn),
+    });
+}
+
+export function useGroupQuestionsQuery(
+    classid: MaybeRefOrGetter<string | undefined>,
+    assignmentNumber: MaybeRefOrGetter<number | undefined>,
+    groupNumber: MaybeRefOrGetter<number | undefined>,
+    full: MaybeRefOrGetter<boolean> = true,
+): UseQueryReturnType<QuestionsResponse, Error> {
+    const { cid, an, gn, f } = toValues(classid, assignmentNumber, groupNumber, full);
+
+    return useQuery({
+        queryKey: computed(() => groupQuestionsQueryKey(cid!, an!, gn!, f)),
+        queryFn: async () => new GroupController(cid!, an!).getSubmissions(gn!, f),
+        enabled: () => checkEnabled(cid, an, gn),
+    });
+}
--- a/frontend/src/queries/learning-objects.ts
+++ b/frontend/src/queries/learning-objects.ts
@ -5,7 +5,7 @@ import { getLearningObjectController } from "@/controllers/controllers.ts";
 import type { LearningObject } from "@/data-objects/learning-objects/learning-object.ts";
 import type { LearningPath } from "@/data-objects/learning-paths/learning-path.ts";

-const LEARNING_OBJECT_KEY = "learningObject";
+export const LEARNING_OBJECT_KEY = "learningObject";
 const learningObjectController = getLearningObjectController();

 export function useLearningObjectMetadataQuery(
--- a/frontend/src/queries/learning-paths.ts
+++ b/frontend/src/queries/learning-paths.ts
@ -4,19 +4,21 @@ import { useQuery, type UseQueryReturnType } from "@tanstack/vue-query";
 import { getLearningPathController } from "@/controllers/controllers";
 import type { LearningPath } from "@/data-objects/learning-paths/learning-path.ts";

-const LEARNING_PATH_KEY = "learningPath";
+export const LEARNING_PATH_KEY = "learningPath";
 const learningPathController = getLearningPathController();

 export function useGetLearningPathQuery(
    hruid: MaybeRefOrGetter<string>,
    language: MaybeRefOrGetter<Language>,
-    options?: MaybeRefOrGetter<{ forGroup?: string; forStudent?: string }>,
+    forGroup?: MaybeRefOrGetter<{forGroup: number, assignmentNo: number, classId: string}>,
 ): UseQueryReturnType<LearningPath, Error> {
    return useQuery({
-        queryKey: [LEARNING_PATH_KEY, "get", hruid, language, options],
+        queryKey: [LEARNING_PATH_KEY, "get", toValue(hruid), toValue(language), toValue(forGroup)],
        queryFn: async () => {
-            const [hruidVal, languageVal, optionsVal] = [toValue(hruid), toValue(language), toValue(options)];
-            return learningPathController.getBy(hruidVal, languageVal, optionsVal);
+            console.log("queryKey");
+            console.log([LEARNING_PATH_KEY, "get", toValue(hruid), toValue(language), toValue(forGroup)]);
+            const [hruidVal, languageVal, forGroupVal] = [toValue(hruid), toValue(language), toValue(forGroup)];
+            return learningPathController.getBy(hruidVal, languageVal, forGroupVal);
        },
        enabled: () => Boolean(toValue(hruid)) && Boolean(toValue(language)),
    });
--- a/frontend/src/queries/submissions.ts
+++ b/frontend/src/queries/submissions.ts
@ -0,0 +1,244 @@
+import { SubmissionController, type SubmissionResponse, type SubmissionsResponse } from "@/controllers/submissions";
+import type { SubmissionDTO } from "@dwengo-1/common/interfaces/submission";
+import {
+    QueryClient,
+    useMutation,
+    useQuery,
+    useQueryClient,
+    type UseMutationReturnType,
+    type UseQueryReturnType,
+} from "@tanstack/vue-query";
+import { computed, toValue, type MaybeRefOrGetter } from "vue";
+import {LEARNING_PATH_KEY} from "@/queries/learning-paths.ts";
+import {LEARNING_OBJECT_KEY} from "@/queries/learning-objects.ts";
+import type {Language} from "@dwengo-1/common/util/language";
+import {getEnvVar} from "@dwengo-1/backend/dist/util/envVars.ts";
+
+function submissionsQueryKey(
+    hruid: string,
+    language: Language,
+    version: number,
+    classid: string,
+    assignmentNumber: number,
+    groupNumber?: number,
+    full?: boolean
+) {
+    return ["submissions", hruid, language, version, classid, assignmentNumber, groupNumber, full ?? false];
+}
+
+function submissionQueryKey(
+    hruid: string,
+    language: Language,
+    version: number,
+    classid: string,
+    assignmentNumber: number,
+    groupNumber: number,
+    submissionNumber: number
+) {
+    return ["submission", hruid, language, version, classid, assignmentNumber, groupNumber, submissionNumber];
+}
+
+export async function invalidateAllSubmissionKeys(
+    queryClient: QueryClient,
+    hruid?: string,
+    language?: Language,
+    version?: number,
+    classid?: string,
+    assignmentNumber?: number,
+    groupNumber?: number,
+    submissionNumber?: number,
+) {
+    const keys = ["submission"];
+
+    for (const key of keys) {
+        const queryKey = [
+            key, hruid, language, version, classid, assignmentNumber, groupNumber, submissionNumber
+        ].filter(
+            (arg) => arg !== undefined,
+        );
+        await queryClient.invalidateQueries({ queryKey: queryKey });
+    }
+
+    await queryClient.invalidateQueries({
+        queryKey: ["submissions", hruid, language, version, classid, assignmentNumber, groupNumber]
+            .filter((arg) => arg !== undefined),
+    });
+    await queryClient.invalidateQueries({
+        queryKey: ["group-submissions", hruid, language, version, classid, assignmentNumber, groupNumber]
+            .filter((arg) => arg !== undefined),
+    });
+    await queryClient.invalidateQueries({
+        queryKey: ["assignment-submissions", hruid, language, version,classid, assignmentNumber]
+            .filter((arg) => arg !== undefined),
+    });
+}
+
+function checkEnabled(
+    classid: string | undefined,
+    assignmentNumber: number | undefined,
+    groupNumber: number | undefined,
+    submissionNumber?: number | undefined,
+    submissionNumberRequired: boolean = false
+): boolean {
+    return (
+        Boolean(classid) &&
+        !isNaN(Number(groupNumber)) &&
+        !isNaN(Number(assignmentNumber)) &&
+        (!isNaN(Number(submissionNumber)) || !submissionNumberRequired)
+    );
+}
+
+function toValues(
+    classid: MaybeRefOrGetter<string | undefined>,
+    assignmentNumber: MaybeRefOrGetter<number | undefined>,
+    groupNumber: MaybeRefOrGetter<number | undefined>,
+    submissionNumber: MaybeRefOrGetter<number | undefined>,
+    full: MaybeRefOrGetter<boolean>,
+) {
+    return {
+        cid: toValue(classid),
+        an: toValue(assignmentNumber),
+        gn: toValue(groupNumber),
+        sn: toValue(submissionNumber),
+        f: toValue(full),
+    };
+}
+export function useSubmissionsQuery(
+    hruid: MaybeRefOrGetter<string | undefined>,
+    language: MaybeRefOrGetter<Language | undefined>,
+    version: MaybeRefOrGetter<number | undefined>,
+    classid: MaybeRefOrGetter<string | undefined>,
+    assignmentNumber: MaybeRefOrGetter<number | undefined>,
+    groupNumber: MaybeRefOrGetter<number | undefined>,
+    full: MaybeRefOrGetter<boolean> = true,
+): UseQueryReturnType<SubmissionsResponse, Error> {
+    const hruidVal = toValue(hruid);
+    const languageVal = toValue(language);
+    const versionVal = toValue(version);
+    const classIdVal = toValue(classid);
+    const assignmentNumberVal = toValue(assignmentNumber);
+    const groupNumberVal = toValue(groupNumber);
+    const fullVal = toValue(full);
+
+    return useQuery({
+        queryKey: computed(() =>
+            submissionsQueryKey(
+                hruidVal!,
+                languageVal!,
+                versionVal!,
+                classIdVal!,
+                assignmentNumberVal!,
+                groupNumberVal,
+                fullVal
+            )
+        ),
+        queryFn: async () => new SubmissionController(hruidVal!).getAll(
+            languageVal!, versionVal!, classIdVal!, assignmentNumberVal!, groupNumberVal, fullVal
+        ),
+        enabled: () => !!hruidVal && !!languageVal && !!versionVal && !!classIdVal && !!assignmentNumberVal,
+    });
+}
+
+export function useSubmissionQuery(
+    hruid: MaybeRefOrGetter<string | undefined>,
+    language: MaybeRefOrGetter<Language | undefined>,
+    version: MaybeRefOrGetter<number | undefined>,
+    classid: MaybeRefOrGetter<string | undefined>,
+    assignmentNumber: MaybeRefOrGetter<number | undefined>,
+    groupNumber: MaybeRefOrGetter<number | undefined>,
+    submissionNumber: MaybeRefOrGetter<number | undefined>,
+): UseQueryReturnType<SubmissionResponse, Error> {
+    const { cid, an, gn, sn, f } = toValues(classid, assignmentNumber, groupNumber, submissionNumber, true);
+
+    const hruidVal = toValue(hruid);
+    const languageVal = toValue(language);
+    const versionVal = toValue(version);
+    const classIdVal = toValue(classid);
+    const assignmentNumberVal = toValue(assignmentNumber);
+    const groupNumberVal = toValue(groupNumber);
+    const submissionNumberVal = toValue(submissionNumber);
+
+    return useQuery({
+        queryKey: computed(() => submissionQueryKey(
+            hruidVal!, languageVal!, versionVal!, classIdVal!, assignmentNumberVal!, groupNumberVal!, submissionNumberVal!
+        )),
+        queryFn: async () => new SubmissionController(hruidVal!).getByNumber(
+            languageVal!, versionVal!, classIdVal!, assignmentNumberVal!, groupNumberVal!, submissionNumberVal!
+        ),
+        enabled: () => !!hruidVal && !!languageVal && !!versionVal && !!classIdVal && !!assignmentNumberVal && !!submissionNumber,
+    });
+}
+
+export function useCreateSubmissionMutation(): UseMutationReturnType<
+    SubmissionResponse,
+    Error,
+    { data: SubmissionDTO },
+    unknown
+> {
+    const queryClient = useQueryClient();
+
+    return useMutation({
+        mutationFn: async ({ data }) => new SubmissionController(data.learningObjectIdentifier.hruid).createSubmission(data),
+        onSuccess: async (response) => {
+            if (!response.submission.group) {
+                await invalidateAllSubmissionKeys(queryClient);
+            } else {
+                const cls = response.submission.group.class;
+                const assignment = response.submission.group.assignment;
+
+                const cid = typeof cls === "string" ? cls : cls.id;
+                const an = typeof assignment === "number" ? assignment : assignment.id;
+                const gn = response.submission.group.groupNumber;
+
+                const {hruid, language, version} = response.submission.learningObjectIdentifier;
+                await invalidateAllSubmissionKeys(queryClient, hruid, language, version, cid, an, gn);
+
+                console.log("INVALIDATE");
+                console.log([
+                    LEARNING_PATH_KEY, "get",
+                    response.submission.learningObjectIdentifier.hruid,
+                ]);
+                await queryClient.invalidateQueries({queryKey: [LEARNING_PATH_KEY, "get"]});
+
+                await queryClient.invalidateQueries({
+                    queryKey: [LEARNING_OBJECT_KEY, "metadata", hruid, language, version]
+                });
+            }
+        },
+    });
+}
+
+export function useDeleteSubmissionMutation(): UseMutationReturnType<
+    SubmissionResponse,
+    Error,
+    { cid: string; an: number; gn: number; sn: number },
+    unknown
+> {
+    const queryClient = useQueryClient();
+
+    return useMutation({
+        mutationFn: async ({ cid, an, gn, sn }) => new SubmissionController(cid).deleteSubmission(sn),
+        onSuccess: async (response) => {
+            if (!response.submission.group) {
+                await invalidateAllSubmissionKeys(queryClient);
+            } else {
+                const cls = response.submission.group.class;
+                const assignment = response.submission.group.assignment;
+
+                const cid = typeof cls === "string" ? cls : cls.id;
+                const an = typeof assignment === "number" ? assignment : assignment.id;
+                const gn = response.submission.group.groupNumber;
+
+                const {hruid, language, version} = response.submission.learningObjectIdentifier;
+
+                await invalidateAllSubmissionKeys(
+                    queryClient,
+                    hruid,
+                    language,
+                    version,
+                    cid, an, gn
+                );
+            }
+        },
+    });
+}
--- a/frontend/src/queries/teacher-invitations.ts
+++ b/frontend/src/queries/teacher-invitations.ts
@ -0,0 +1,78 @@
+import { useMutation, useQuery, type UseMutationReturnType, type UseQueryReturnType } from "@tanstack/vue-query";
+import { computed, toValue } from "vue";
+import type { MaybeRefOrGetter } from "vue";
+import {
+    TeacherInvitationController,
+    type TeacherInvitationResponse,
+    type TeacherInvitationsResponse,
+} from "@/controllers/teacher-invitations.ts";
+import type { TeacherInvitationData } from "@dwengo-1/common/interfaces/teacher-invitation";
+import type { TeacherDTO } from "@dwengo-1/common/interfaces/teacher";
+
+const controller = new TeacherInvitationController();
+
+/**
+    All the invitations the teacher sent
+**/
+export function useTeacherInvitationsSentQuery(
+    username: MaybeRefOrGetter<string | undefined>,
+): UseQueryReturnType<TeacherInvitationsResponse, Error> {
+    return useQuery({
+        queryFn: computed(async () => controller.getAll(toValue(username), true)),
+        enabled: () => Boolean(toValue(username)),
+    });
+}
+
+/**
+    All the pending invitations sent to this teacher
+ */
+export function useTeacherInvitationsReceivedQuery(
+    username: MaybeRefOrGetter<string | undefined>,
+): UseQueryReturnType<TeacherInvitationsResponse, Error> {
+    return useQuery({
+        queryFn: computed(async () => controller.getAll(toValue(username), false)),
+        enabled: () => Boolean(toValue(username)),
+    });
+}
+
+export function useTeacherInvitationQuery(
+    data: MaybeRefOrGetter<TeacherInvitationData | undefined>,
+): UseQueryReturnType<TeacherInvitationResponse, Error> {
+    return useQuery({
+        queryFn: computed(async () => controller.getBy(toValue(data))),
+        enabled: () => Boolean(toValue(data)),
+    });
+}
+
+export function useCreateTeacherInvitationMutation(): UseMutationReturnType<
+    TeacherInvitationResponse,
+    Error,
+    TeacherDTO,
+    unknown
+> {
+    return useMutation({
+        mutationFn: async (data: TeacherInvitationData) => controller.create(data),
+    });
+}
+
+export function useRespondTeacherInvitationMutation(): UseMutationReturnType<
+    TeacherInvitationResponse,
+    Error,
+    TeacherDTO,
+    unknown
+> {
+    return useMutation({
+        mutationFn: async (data: TeacherInvitationData) => controller.respond(data),
+    });
+}
+
+export function useDeleteTeacherInvitationMutation(): UseMutationReturnType<
+    TeacherInvitationResponse,
+    Error,
+    TeacherDTO,
+    unknown
+> {
+    return useMutation({
+        mutationFn: async (data: TeacherInvitationData) => controller.remove(data),
+    });
+}
--- a/frontend/src/views/classes/TeacherClasses.vue
+++ b/frontend/src/views/classes/TeacherClasses.vue
@ -276,10 +276,11 @@
                <tbody>
                    <tr
                        v-for="i in invitations"
-                        :key="(i.class as ClassDTO).id"
+                        :key="i.classId"
                    >
                        <td>
-                            {{ (i.class as ClassDTO).displayName }}
+                            {{ i.classId }}
+                            <!-- TODO fetch display name via classId because db only returns classId field -->
                        </td>
                        <td>{{ (i.sender as TeacherDTO).firstName + " " + (i.sender as TeacherDTO).lastName }}</td>
                        <td class="text-right">
--- a/frontend/src/views/learning-paths/LearningObjectView.vue
+++ b/frontend/src/views/learning-paths/LearningObjectView.vue
@ -3,10 +3,24 @@
    import type { UseQueryReturnType } from "@tanstack/vue-query";
    import { useLearningObjectHTMLQuery } from "@/queries/learning-objects.ts";
    import UsingQueryResult from "@/components/UsingQueryResult.vue";
-    import {nextTick, onMounted, reactive, watch} from "vue";
+    import {computed, nextTick, onMounted, reactive, watch} from "vue";
    import {getGiftAdapterForType} from "@/views/learning-paths/gift-adapters/gift-adapters.ts";
+    import authService from "@/services/auth/auth-service.ts";
+    import {useCreateSubmissionMutation, useSubmissionsQuery} from "@/queries/submissions.ts";
+    import type {SubmissionDTO} from "@dwengo-1/common/dist/interfaces/submission.d.ts";
+    import type {GroupDTO} from "@dwengo-1/common/interfaces/group";
+    import type {StudentDTO} from "@dwengo-1/common/interfaces/student";
+    import type {LearningObjectIdentifierDTO} from "@dwengo-1/common/interfaces/learning-content";
+    import type {User, UserProfile} from "oidc-client-ts";

-    const props = defineProps<{ hruid: string; language: Language; version: number }>();
+    const isStudent = computed(() => authService.authState.activeRole === "student");
+
+    const props = defineProps<{
+        hruid: string;
+        language: Language;
+        version: number,
+        group?: {forGroup: number, assignmentNo: number, classId: string}
+    }>();

    const learningObjectHtmlQueryResult: UseQueryReturnType<Document, Error> = useLearningObjectHTMLQuery(
        () => props.hruid,
@ -14,7 +28,61 @@
        () => props.version,
    );

-    const currentAnswer = reactive([]);
+    const currentAnswer = reactive(<(string | number | object)[]>[]);
+
+    const {
+        isPending: submissionIsPending,
+        isError: submissionFailed,
+        error: submissionError,
+        isSuccess: submissionSuccess,
+        mutate: submitSolution
+    } = useCreateSubmissionMutation();
+
+    const {
+        isPending: existingSubmissionsIsPending,
+        isError: existingSubmissionsFailed,
+        error: existingSubmissionsError,
+        isSuccess: existingSubmissionsSuccess,
+        data: existingSubmissions
+    } = useSubmissionsQuery(
+        props.hruid,
+        props.language,
+        props.version,
+        props.group?.classId,
+        props.group?.assignmentNo,
+        props.group?.forGroup,
+        true
+    );
+
+
+
+    function submitCurrentAnswer(): void {
+        const { forGroup, assignmentNo, classId } = props.group!;
+        const currentUser: UserProfile = authService.authState.user!.profile;
+        const learningObjectIdentifier: LearningObjectIdentifierDTO = {
+            hruid: props.hruid,
+            language: props.language as Language,
+            version: props.version
+        };
+        const submitter: StudentDTO = {
+            id: currentUser.preferred_username!,
+            username: currentUser.preferred_username!,
+            firstName: currentUser.given_name!,
+            lastName: currentUser.family_name!
+        };
+        const group: GroupDTO = {
+            class: classId,
+            assignment: assignmentNo,
+            groupNumber: forGroup
+        }
+        const submission: SubmissionDTO = {
+            learningObjectIdentifier,
+            submitter,
+            group,
+            content: JSON.stringify(currentAnswer)
+        }
+        submitSolution({ data: submission });
+    }

    function forEachQuestion(
        doAction: (questionIndex: number, questionName: string, questionType: string, questionElement: Element) => void
@ -22,9 +90,9 @@
        const questions = document.querySelectorAll(".gift-question");
        questions.forEach(question => {
            const name = question.id.match(/gift-q(\d+)/)?.[1]
-            const questionType = question.classList.values()
+            const questionType = question.className.split(" ")
                .find(it => it.startsWith("gift-question-type"))
-                .match(/gift-question-type-([^ ]*)/)?.[1];
+                ?.match(/gift-question-type-([^ ]*)/)?.[1];

            if (!name || isNaN(parseInt(name)) || !questionType) return;

@ -46,7 +114,7 @@
        forEachQuestion((index, name, type, element) => {
            getGiftAdapterForType(type)?.setAnswer(element, answers[index]);
        });
-        currentAnswer.fill(answers);
+        currentAnswer.splice(0, currentAnswer.length, ...answers);
    }

    onMounted(() => nextTick(() => attachQuestionListeners()));
@ -68,6 +136,14 @@
            v-html="learningPathHtml.data.body.innerHTML"
        ></div>
        {{ currentAnswer }}
+        <v-btn v-if="isStudent && props.group"
+               prepend-icon="mdi-check"
+               variant="elevated"
+               :loading="submissionIsPending"
+               @click="submitCurrentAnswer()"
+        >
+            Submit
+        </v-btn>
    </using-query-result>
 </template>

--- a/frontend/src/views/learning-paths/LearningPathPage.vue
+++ b/frontend/src/views/learning-paths/LearningPathPage.vue
@ -16,26 +16,31 @@
    const route = useRoute();
    const { t } = useI18n();

-    const props = defineProps<{ hruid: string; language: Language; learningObjectHruid?: string }>();
+    const props = defineProps<{
+        hruid: string;
+        language: Language;
+        learningObjectHruid?: string,
+    }>();

-    interface Personalization {
-        forStudent?: string;
+    interface LearningPathPageQuery {
        forGroup?: string;
+        assignmentNo?: string;
+        classId?: string;
    }

-    const personalization = computed(() => {
-        if (route.query.forStudent || route.query.forGroup) {
+    const query = computed(() => route.query as LearningPathPageQuery);
+
+    const forGroup = computed(() => {
+        if (query.value.forGroup && query.value.assignmentNo && query.value.classId) {
            return {
-                forStudent: route.query.forStudent,
-                forGroup: route.query.forGroup,
-            } as Personalization;
+                forGroup: parseInt(query.value.forGroup),
+                assignmentNo: parseInt(query.value.assignmentNo),
+                classId: query.value.classId
+            };
        }
-        return {
-            forStudent: authService.authState.user?.profile?.preferred_username,
-        } as Personalization;
    });

-    const learningPathQueryResult = useGetLearningPathQuery(props.hruid, props.language, personalization);
+    const learningPathQueryResult = useGetLearningPathQuery(props.hruid, props.language, forGroup);

    const learningObjectListQueryResult = useLearningObjectListForPathQuery(learningPathQueryResult.data);

@ -184,6 +189,7 @@
            :hruid="currentNode.learningobjectHruid"
            :language="currentNode.language"
            :version="currentNode.version"
+            :group="forGroup"
            v-if="currentNode"
        ></learning-object-view>
        <div class="navigation-buttons-container">
--- a/package-lock.json
+++ b/package-lock.json
@ -269,6 +269,7 @@
            "name": "dwengo-1-frontend",
            "version": "0.1.1",
            "dependencies": {
+                "@dwengo-1/common": "^0.1.1",
                "@tanstack/react-query": "^5.69.0",
                "@tanstack/vue-query": "^5.69.0",
                "axios": "^1.8.2",