feat: PUT op group geimplementeerd

backend/src/controllers/groups.ts

@@ -1,9 +1,11 @@
 import { Request, Response } from 'express';
-import { createGroup, deleteGroup, getAllGroups, getGroup, getGroupSubmissions } from '../services/groups.js';
+import { createGroup, deleteGroup, getAllGroups, getGroup, getGroupSubmissions, putGroup } from '../services/groups.js';
 import { GroupDTO } from '@dwengo-1/common/interfaces/group';
 import { requireFields } from './error-helper.js';
 import { BadRequestException } from '../exceptions/bad-request-exception.js';
 import { getLogger } from '../logging/initalize.js';
+import { EntityDTO } from '@mikro-orm/core';
+import { Group } from '../entities/assignments/group.entity.js';
 
 function checkGroupFields(classId: any, assignmentId: any, groupId: any) {
     requireFields({ classId, assignmentId, groupId });
@@ -28,6 +30,17 @@ export async function getGroupHandler(req: Request, res: Response): Promise<void
     res.json({ group });
 }
 
+export async function putGroupHandler(req: Request, res: Response): Promise<void> {
+    const classId = req.params.classid;
+    const assignmentId = parseInt(req.params.assignmentid);
+    const groupId = parseInt(req.params.groupid);
+    checkGroupFields(classId, assignmentId, groupId);
+
+    const group = await putGroup(classId, assignmentId, groupId, req.body as Partial<EntityDTO<Group>>);
+
+    res.json({ group });
+}
+
 export async function deleteGroupHandler(req: Request, res: Response): Promise<void> {
     const classId = req.params.classid;
     const assignmentId = parseInt(req.params.assignmentid);

backend/src/routes/groups.ts

@@ -1,5 +1,5 @@
 import express from 'express';
-import { createGroupHandler, deleteGroupHandler, getAllGroupsHandler, getGroupHandler, getGroupSubmissionsHandler } from '../controllers/groups.js';
+import { createGroupHandler, deleteGroupHandler, getAllGroupsHandler, getGroupHandler, getGroupSubmissionsHandler, putGroupHandler } from '../controllers/groups.js';
 
 const router = express.Router({ mergeParams: true });
 
@@ -10,6 +10,8 @@ router.post('/', createGroupHandler);
 
 router.get('/:groupid', getGroupHandler);
 
+router.put('/:groupid', putGroupHandler);
+
 router.delete('/:groupid', deleteGroupHandler);
 
 router.get('/:groupid/submissions', getGroupSubmissionsHandler);

backend/src/services/assignments.ts

@@ -64,7 +64,7 @@ export async function getAssignment(classid: string, id: number): Promise<Assign
 export async function putAssignment(classid: string, id: number, assignmentData: Partial<EntityDTO<Assignment>>): Promise<AssignmentDTO> {
     const assignment = await fetchAssignment(classid, id);
     
-    await putObject<Assignment, AssignmentDTO>(assignment, assignmentData, getAssignmentRepository());
+    await putObject<Assignment>(assignment, assignmentData, getAssignmentRepository());
 
     return mapToAssignmentDTO(assignment);
 }

backend/src/services/classes.ts

@@ -62,7 +62,7 @@ export async function createClass(classData: ClassDTO): Promise<ClassDTO> {
 export async function putClass(classId: string, classData: Partial<EntityDTO<Class>>): Promise<ClassDTO> {
     const cls = await fetchClass(classId);
 
-    await putObject<Class, ClassDTO>(cls, classData, getClassRepository());
+    await putObject<Class>(cls, classData, getClassRepository());
 
     return mapToClassDTO(cls);
 }
@@ -116,7 +116,7 @@ export async function deleteClassStudent(classId: string, username: string): Pro
     const cls = await fetchClass(classId);
     
     const newStudents = { students: cls.students.filter((student) => student.username !== username) };
-    await putObject<Class, ClassDTO>(cls, newStudents, getClassRepository());
+    await putObject<Class>(cls, newStudents, getClassRepository());
 
     return mapToClassDTO(cls);
 }
@@ -125,7 +125,7 @@ export async function deleteClassTeacher(classId: string, username: string): Pro
     const cls = await fetchClass(classId);
     
     const newTeachers = { teachers: cls.teachers.filter((teacher) => teacher.username !== username) };
-    await putObject<Class, ClassDTO>(cls, newTeachers, getClassRepository());
+    await putObject<Class>(cls, newTeachers, getClassRepository());
 
     return mapToClassDTO(cls);
 }
@@ -135,7 +135,7 @@ export async function addClassStudent(classId: string, username: string): Promis
     const newStudent = await fetchStudent(username);
 
     const newStudents = { students: [...cls.students, newStudent] }
-    await putObject<Class, ClassDTO>(cls, newStudents, getClassRepository());
+    await putObject<Class>(cls, newStudents, getClassRepository());
     
     return mapToClassDTO(cls);
 }
@@ -145,7 +145,7 @@ export async function addClassTeacher(classId: string, username: string): Promis
     const newTeacher = await fetchTeacher(username);
 
     const newTeachers = { teachers: [...cls.teachers, newTeacher] };
-    await putObject<Class, ClassDTO>(cls, newTeachers, getClassRepository());    
+    await putObject<Class>(cls, newTeachers, getClassRepository());    
 
     return mapToClassDTO(cls);
 }

backend/src/services/groups.ts

@@ -1,4 +1,4 @@
-import { assign } from '@mikro-orm/core';
+import { assign, EntityDTO } from '@mikro-orm/core';
 import {
     getAssignmentRepository,
     getClassRepository,
@@ -16,6 +16,7 @@ import { getLogger } from '../logging/initalize.js';
 import { fetchAssignment } from './assignments.js';
 import { NotFoundException } from '../exceptions/not-found-exception.js';
 import { fetchClass } from './classes.js';
+import { putObject } from './service-helper.js';
 
 export async function fetchGroup(classId: string, assignmentNumber: number, groupNumber: number): Promise<Group> {
     const assignment = await fetchAssignment(classId, assignmentNumber);
@@ -35,6 +36,19 @@ export async function getGroup(classId: string, assignmentNumber: number, groupN
     return mapToGroupDTO(group);
 }
 
+export async function putGroup(
+    classId: string, 
+    assignmentNumber: number, 
+    groupNumber: number, 
+    groupData: Partial<EntityDTO<Group>>
+): Promise<GroupDTO> {
+    const group = await fetchGroup(classId, assignmentNumber, groupNumber);
+
+    await putObject<Group>(group, groupData, getGroupRepository());
+
+    return mapToGroupDTO(group);
+}
+
 export async function deleteGroup(classId: string, assignmentNumber: number, groupNumber: number): Promise<GroupDTO> {
     const group = await fetchGroup(classId, assignmentNumber, groupNumber);
     const assignment = await fetchAssignment(classId, assignmentNumber);

backend/src/services/service-helper.ts

@@ -10,7 +10,7 @@ import { DwengoEntityRepository } from "../data/dwengo-entity-repository";
  * 
  * @returns Nothing.
  */
-export async function putObject<T extends Object, DTO>(
+export async function putObject<T extends Object>(
     object: T, 
     data: Partial<EntityDTO<FromEntityType<T>>>, 
     repo: DwengoEntityRepository<T>