fix: nog steeds werkende aan 183 fix, probleem komt mogelijks door het feit dat group niet automatisch een groupNummer krijgt

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

@@ -1,4 +1,4 @@
-import { Entity, Enum, ManyToOne, OneToMany, PrimaryKey, Property } from '@mikro-orm/core';
+import { Collection, Entity, Enum, ManyToOne, OneToMany, PrimaryKey, Property } from '@mikro-orm/core';
 import { Class } from '../classes/class.entity.js';
 import { Group } from './group.entity.js';
 import { Language } from '@dwengo-1/common/util/language';
@@ -35,5 +35,5 @@ export class Assignment {
         entity: () => Group,
         mappedBy: 'assignment',
     })
-    groups!: Group[];
+    groups!: Collection<Group>;
 }

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

@@ -19,5 +19,5 @@ export class Group {
     @ManyToMany({
         entity: () => Student,
     })
-    members!: Collection<Student>;
+    members!: Student[];
 }

backend/src/interfaces/assignment.ts

@@ -16,7 +16,7 @@ export function mapToAssignmentDTOId(assignment: Assignment): AssignmentDTO {
         description: assignment.description,
         learningPath: assignment.learningPathHruid,
         language: assignment.learningPathLanguage,
-        groups: assignment.groups.map(mapToGroupDTOId),
+        groups: assignment.groups.map(group => mapToGroupDTOId(group, assignment.within)),
     };
 }
 
@@ -28,7 +28,7 @@ export function mapToAssignmentDTO(assignment: Assignment): AssignmentDTO {
         description: assignment.description,
         learningPath: assignment.learningPathHruid,
         language: assignment.learningPathLanguage,
-        groups: assignment.groups.map(mapToGroupDTO),
+        groups: assignment.groups.map(group => mapToGroupDTO(group, assignment.within)),
     };
 }
 

backend/src/interfaces/group.ts

@@ -1,21 +1,22 @@
 import { Group } from '../entities/assignments/group.entity.js';
+import { Class } from '../entities/classes/class.entity.js';
 import { mapToAssignmentDTO } from './assignment.js';
 import { mapToClassDTO } from './class.js';
 import { mapToStudentDTO } from './student.js';
 import { GroupDTO } from '@dwengo-1/common/interfaces/group';
 
-export function mapToGroupDTO(group: Group): GroupDTO {
+export function mapToGroupDTO(group: Group, cls: Class): GroupDTO {
     return {
-        class: mapToClassDTO(group.assignment.within),
+        class: mapToClassDTO(cls),
         assignment: mapToAssignmentDTO(group.assignment),
         groupNumber: group.groupNumber!,
         members: group.members.map(mapToStudentDTO),
     };
 }
 
-export function mapToGroupDTOId(group: Group): GroupDTO {
+export function mapToGroupDTOId(group: Group, cls: Class): GroupDTO {
     return {
-        class: group.assignment.within.classId!,
+        class: cls.classId!,
         assignment: group.assignment.id!,
         groupNumber: group.groupNumber!,
         members: group.members.map((member) => member.username),

backend/src/services/groups.ts

@@ -1,4 +1,4 @@
-import { EntityDTO } from '@mikro-orm/core';
+import { Collection, EntityDTO } from '@mikro-orm/core';
 import { getGroupRepository, getStudentRepository, getSubmissionRepository } from '../data/repositories.js';
 import { Group } from '../entities/assignments/group.entity.js';
 import { mapToGroupDTO, mapToGroupDTOId } from '../interfaces/group.js';
@@ -8,6 +8,9 @@ import { SubmissionDTO, SubmissionDTOId } from '@dwengo-1/common/interfaces/subm
 import { fetchAssignment } from './assignments.js';
 import { NotFoundException } from '../exceptions/not-found-exception.js';
 import { putObject } from './service-helper.js';
+import { Student } from '../entities/users/student.entity.js';
+import { GroupRepository } from '../data/assignments/group-repository.js';
+import { assert } from 'console';
 
 export async function fetchGroup(classId: string, assignmentNumber: number, groupNumber: number): Promise<Group> {
     const assignment = await fetchAssignment(classId, assignmentNumber);
@@ -24,7 +27,7 @@ export async function fetchGroup(classId: string, assignmentNumber: number, grou
 
 export async function getGroup(classId: string, assignmentNumber: number, groupNumber: number): Promise<GroupDTO> {
     const group = await fetchGroup(classId, assignmentNumber, groupNumber);
-    return mapToGroupDTO(group);
+    return mapToGroupDTO(group, group.assignment.within);
 }
 
 export async function putGroup(
@@ -37,7 +40,7 @@ export async function putGroup(
 
     await putObject<Group>(group, groupData, getGroupRepository());
 
-    return mapToGroupDTO(group);
+    return mapToGroupDTO(group, group.assignment.within);
 }
 
 export async function deleteGroup(classId: string, assignmentNumber: number, groupNumber: number): Promise<GroupDTO> {
@@ -47,7 +50,7 @@ export async function deleteGroup(classId: string, assignmentNumber: number, gro
     const groupRepository = getGroupRepository();
     await groupRepository.deleteByAssignmentAndGroupNumber(assignment, groupNumber);
 
-    return mapToGroupDTO(group);
+    return mapToGroupDTO(group, assignment.within);
 }
 
 export async function getExistingGroupFromGroupDTO(groupData: GroupDTO): Promise<Group> {
@@ -62,27 +65,31 @@ export async function createGroup(groupData: GroupDTO, classid: string, assignme
     const studentRepository = getStudentRepository();
 
     const memberUsernames = (groupData.members as string[]) || [];
-    const members = (await Promise.all([...memberUsernames].map(async (id) => studentRepository.findByUsername(id)))).filter(
+    const members = (
-        (student) => student !== null
+        await Promise.all(
-    );
+            memberUsernames.map(async (id) => studentRepository.findByUsername(id))
-
+        )
-    console.log(members);
+    ).filter((student): student is Student => student !== null);
 
     const assignment = await fetchAssignment(classid, assignmentNumber);
     
-    console.log(assignment);
-
     const groupRepository = getGroupRepository();
     const newGroup = groupRepository.create({
         assignment: assignment,
         members: members,
     });
-    console.log(newGroup.assignment);
+
+    assert(newGroup.groupNumber !== undefined, "NO GROUPNUMBER WAS ASSIGNED");
+
+    console.log(newGroup);
+
+    try {
         await groupRepository.save(newGroup);
+    } catch(e) {
+        console.log(e);
+    }
 
-    console.log(newGroup.assignment);
+    return mapToGroupDTO(newGroup, newGroup.assignment.within);
-
-    return mapToGroupDTO(newGroup);
 }
 
 export async function getAllGroups(classId: string, assignmentNumber: number, full: boolean): Promise<GroupDTO[]> {
@@ -92,10 +99,10 @@ export async function getAllGroups(classId: string, assignmentNumber: number, fu
     const groups = await groupRepository.findAllGroupsForAssignment(assignment);
 
     if (full) {
-        return groups.map(mapToGroupDTO);
+        return groups.map(group => mapToGroupDTO(group, assignment.within));
     }
 
-    return groups.map(mapToGroupDTOId);
+    return groups.map(group => mapToGroupDTOId(group, assignment.within));
 }
 
 export async function getGroupSubmissions(

backend/src/services/submissions.ts

@@ -32,7 +32,9 @@ export async function getAllSubmissions(loId: LearningObjectIdentifier): Promise
 
 export async function createSubmission(submissionDTO: SubmissionDTO): Promise<SubmissionDTO> {
     const submitter = await fetchStudent(submissionDTO.submitter.username);
-    const group = submissionDTO.group ? await getExistingGroupFromGroupDTO(submissionDTO.group) : undefined;
+    // TODO: fix
+    // const group = submissionDTO.group ? await getExistingGroupFromGroupDTO(submissionDTO.group) : undefined;
+    const group = undefined;
 
     const submissionRepository = getSubmissionRepository();
     const submission = mapToSubmission(submissionDTO, submitter, group);