style: fix linting issues met Prettier

backend/src/controllers/assignments.ts

@@ -1,8 +1,15 @@
 import { Request, Response } from 'express';
-import { createAssignment, deleteAssignment, getAllAssignments, getAssignment, getAssignmentsSubmissions, putAssignment } from '../services/assignments.js';
+import {
+    createAssignment,
+    deleteAssignment,
+    getAllAssignments,
+    getAssignment,
+    getAssignmentsSubmissions,
+    putAssignment,
+} from '../services/assignments.js';
 import { AssignmentDTO } from '@dwengo-1/common/interfaces/assignment';
-import {requireFields} from "./error-helper";
+import { requireFields } from './error-helper';
-import {BadRequestException} from "../exceptions/bad-request-exception";
+import { BadRequestException } from '../exceptions/bad-request-exception';
 import { getLogger } from '../logging/initalize.js';
 import { Assignment } from '../entities/assignments/assignment.entity.js';
 import { EntityDTO } from '@mikro-orm/core';
@@ -37,7 +44,7 @@ export async function getAssignmentHandler(req: Request, res: Response): Promise
     requireFields({ id, classid });
 
     if (isNaN(id)) {
-        throw new BadRequestException("Assignment id should be a number")
+        throw new BadRequestException('Assignment id should be a number');
     }
 
     const assignment = await getAssignment(classid, id);
@@ -51,7 +58,7 @@ export async function putAssignmentHandler(req: Request, res: Response): Promise
     requireFields({ id, classid });
 
     if (isNaN(id)) {
-        throw new BadRequestException("Assignment id should be a number")
+        throw new BadRequestException('Assignment id should be a number');
     }
 
     const assignmentData = req.body as Partial<EntityDTO<Assignment>>;
@@ -66,10 +73,10 @@ export async function deleteAssignmentHandler(req: Request, res: Response): Prom
     requireFields({ id, classid });
 
     if (isNaN(id)) {
-        throw new BadRequestException("Assignment id should be a number");
+        throw new BadRequestException('Assignment id should be a number');
     }
 
-    const assignment = await deleteAssignment(classid, id); 
+    const assignment = await deleteAssignment(classid, id);
 }
 
 export async function getAssignmentsSubmissionsHandler(req: Request, res: Response): Promise<void> {
@@ -79,7 +86,7 @@ export async function getAssignmentsSubmissionsHandler(req: Request, res: Respon
     requireFields({ assignmentNumber, classid });
 
     if (isNaN(assignmentNumber)) {
-        throw new BadRequestException("Assignment id should be a number")
+        throw new BadRequestException('Assignment id should be a number');
     }
 
     const submissions = await getAssignmentsSubmissions(classid, assignmentNumber, full);

backend/src/controllers/classes.ts

@@ -11,10 +11,10 @@ import {
     getClassStudents,
     getClassTeacherInvitations,
     getClassTeachers,
-    putClass
+    putClass,
 } from '../services/classes.js';
 import { ClassDTO } from '@dwengo-1/common/interfaces/class';
-import {requireFields} from "./error-helper";
+import { requireFields } from './error-helper';
 import { EntityDTO } from '@mikro-orm/core';
 import { Class } from '../entities/classes/class.entity.js';
 

backend/src/controllers/submissions.ts

@@ -7,19 +7,17 @@ import { Language, languageMap } from '@dwengo-1/common/util/language';
 import { SubmissionDTO } from '@dwengo-1/common/interfaces/submission';
 import { requireFields } from './error-helper.js';
 
-
-
 export async function getSubmissionHandler(req: Request, res: Response): Promise<void> {
     const lohruid = req.params.hruid;
     const lang = languageMap[req.query.language as string] || Language.Dutch;
     const version = (req.query.version || 1) as number;
     const submissionNumber = Number(req.params.id);
     requireFields({ lohruid, submissionNumber });
-    
+
     if (isNaN(submissionNumber)) {
         throw new BadRequestException('Submission number must be a number');
     }
-    
+
     const loId = new LearningObjectIdentifier(lohruid, lang, version);
     const submission = await getSubmission(loId, submissionNumber);
 
@@ -54,7 +52,7 @@ export async function deleteSubmissionHandler(req: Request, res: Response): Prom
     requireFields({ hruid, submissionNumber });
 
     if (isNaN(submissionNumber)) {
-        throw new BadRequestException('Submission number must be a number'); 
+        throw new BadRequestException('Submission number must be a number');
     }
 
     const loId = new LearningObjectIdentifier(hruid, lang, version);

backend/src/data/questions/question-repository.ts

@@ -58,12 +58,12 @@ export class QuestionRepository extends DwengoEntityRepository<Question> {
 
     public async findAllByAssignment(assignment: Assignment): Promise<Question[]> {
         return this.find({
-            author: assignment.groups.flatMap(group => group.members),
+            author: assignment.groups.flatMap((group) => group.members),
             learningObjectHruid: assignment.learningPathHruid,
             learningObjectLanguage: assignment.learningPathLanguage,
         });
     }
-    
+
     public async findAllByAuthor(author: Student): Promise<Question[]> {
         return this.findAll({
             where: { author },

backend/src/routes/classes.ts

@@ -8,7 +8,8 @@ import {
     deleteClassTeacherHandler,
     getAllClassesHandler,
     getClassHandler,
-    getClassStudentsHandler, getClassTeachersHandler,
+    getClassStudentsHandler,
+    getClassTeachersHandler,
     getTeacherInvitationsHandler,
     putClassHandler,
 } from '../controllers/classes.js';

backend/src/services/assignments.ts

@@ -1,5 +1,11 @@
 import { AssignmentDTO } from '@dwengo-1/common/interfaces/assignment';
-import { getAssignmentRepository, getClassRepository, getGroupRepository, getQuestionRepository, getSubmissionRepository } from '../data/repositories.js';
+import {
+    getAssignmentRepository,
+    getClassRepository,
+    getGroupRepository,
+    getQuestionRepository,
+    getSubmissionRepository,
+} from '../data/repositories.js';
 import { Assignment } from '../entities/assignments/assignment.entity.js';
 import { NotFoundException } from '../exceptions/not-found-exception.js';
 import { mapToAssignment, mapToAssignmentDTO, mapToAssignmentDTOId } from '../interfaces/assignment.js';
@@ -18,7 +24,7 @@ export async function fetchAssignment(classid: string, assignmentNumber: number)
     const cls = await classRepository.findById(classid);
 
     if (!cls) {
-        throw new NotFoundException('Could not find assignment\'s class');
+        throw new NotFoundException("Could not find assignment's class");
     }
 
     const assignmentRepository = getAssignmentRepository();
@@ -48,10 +54,10 @@ export async function createAssignment(classid: string, assignmentData: Assignme
     const cls = await fetchClass(classid);
 
     const assignment = mapToAssignment(assignmentData, cls);
-    
+
     const assignmentRepository = getAssignmentRepository();
     const newAssignment = assignmentRepository.create(assignment);
-    await assignmentRepository.save(newAssignment, {preventOverwrite: true});
+    await assignmentRepository.save(newAssignment, { preventOverwrite: true });
 
     return mapToAssignmentDTO(newAssignment);
 }
@@ -63,7 +69,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());
 
     return mapToAssignmentDTO(assignment);
@@ -90,9 +96,7 @@ export async function getAssignmentsSubmissions(
     const groups = await groupRepository.findAllGroupsForAssignment(assignment);
 
     const submissionRepository = getSubmissionRepository();
-    const submissions = (await Promise.all(
+    const submissions = (await Promise.all(groups.map(async (group) => submissionRepository.findAllSubmissionsForGroup(group)))).flat();
-        groups.map(async (group) => submissionRepository.findAllSubmissionsForGroup(group))
-    )).flat();
 
     if (full) {
         return submissions.map(mapToSubmissionDTO);
@@ -101,11 +105,7 @@ export async function getAssignmentsSubmissions(
     return submissions.map(mapToSubmissionDTOId);
 }
 
-export async function getAssignmentsQuestions(
+export async function getAssignmentsQuestions(classid: string, assignmentNumber: number, full: boolean): Promise<QuestionDTO[] | QuestionId[]> {
-    classid: string,
-    assignmentNumber: number,
-    full: boolean
-): Promise<QuestionDTO[] | QuestionId[]> {
     const assignment = await fetchAssignment(classid, assignmentNumber);
 
     const questionRepository = getQuestionRepository();
@@ -116,4 +116,4 @@ export async function getAssignmentsQuestions(
     }
 
     return questions.map(mapToQuestionDTO);
-}
+}

backend/src/services/classes.ts

@@ -8,10 +8,10 @@ import { Class } from '../entities/classes/class.entity.js';
 import { ClassDTO } from '@dwengo-1/common/interfaces/class';
 import { TeacherInvitationDTO } from '@dwengo-1/common/interfaces/teacher-invitation';
 import { StudentDTO } from '@dwengo-1/common/interfaces/student';
-import {fetchTeacher} from "./teachers";
+import { fetchTeacher } from './teachers';
-import {fetchStudent, getStudent} from "./students";
+import { fetchStudent, getStudent } from './students';
-import {TeacherDTO} from "@dwengo-1/common/interfaces/teacher";
+import { TeacherDTO } from '@dwengo-1/common/interfaces/teacher';
-import {mapToTeacherDTO} from "../interfaces/teacher";
+import { mapToTeacherDTO } from '../interfaces/teacher';
 import { EntityDTO } from '@mikro-orm/core';
 import { putObject } from './service-helper.js';
 
@@ -20,7 +20,7 @@ export async function fetchClass(classid: string): Promise<Class> {
     const cls = await classRepository.findById(classid);
 
     if (!cls) {
-        throw new NotFoundException("Class not found");
+        throw new NotFoundException('Class not found');
     }
 
     return cls;
@@ -43,10 +43,10 @@ export async function getClass(classId: string): Promise<ClassDTO> {
 
 export async function createClass(classData: ClassDTO): Promise<ClassDTO> {
     const teacherUsernames = classData.teachers || [];
-    const teachers = (await Promise.all(teacherUsernames.map(async (id) => fetchTeacher(id) )));
+    const teachers = await Promise.all(teacherUsernames.map(async (id) => fetchTeacher(id)));
 
     const studentUsernames = classData.students || [];
-    const students = (await Promise.all(studentUsernames.map(async (id) => fetchStudent(id) )));
+    const students = await Promise.all(studentUsernames.map(async (id) => fetchStudent(id)));
 
     const classRepository = getClassRepository();
     const newClass = classRepository.create({
@@ -54,7 +54,7 @@ export async function createClass(classData: ClassDTO): Promise<ClassDTO> {
         teachers: teachers,
         students: students,
     });
-    await classRepository.save(newClass, {preventOverwrite: true});
+    await classRepository.save(newClass, { preventOverwrite: true });
 
     return mapToClassDTO(newClass);
 }
@@ -93,7 +93,7 @@ export async function getClassStudentsDTO(classId: string): Promise<StudentDTO[]
 export async function getClassTeachers(classId: string, full: boolean): Promise<TeacherDTO[] | string[]> {
     const cls = await fetchClass(classId);
 
-    if (full){
+    if (full) {
         return cls.teachers.map(mapToTeacherDTO);
     }
     return cls.teachers.map((student) => student.username);
@@ -114,7 +114,7 @@ export async function getClassTeacherInvitations(classId: string, full: boolean)
 
 export async function deleteClassStudent(classId: string, username: string): Promise<ClassDTO> {
     const cls = await fetchClass(classId);
-    
+
     const newStudents = { students: cls.students.filter((student) => student.username !== username) };
     await putObject<Class, ClassDTO>(cls, newStudents, getClassRepository());
 
@@ -123,7 +123,7 @@ export async function deleteClassStudent(classId: string, username: string): Pro
 
 export async function deleteClassTeacher(classId: string, username: string): Promise<ClassDTO> {
     const cls = await fetchClass(classId);
-    
+
     const newTeachers = { teachers: cls.teachers.filter((teacher) => teacher.username !== username) };
     await putObject<Class, ClassDTO>(cls, newTeachers, getClassRepository());
 
@@ -134,9 +134,9 @@ export async function addClassStudent(classId: string, username: string): Promis
     const cls = await fetchClass(classId);
     const newStudent = await fetchStudent(username);
 
-    const newStudents = { students: [...cls.students, newStudent] }
+    const newStudents = { students: [...cls.students, newStudent] };
     await putObject<Class, ClassDTO>(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, ClassDTO>(cls, newTeachers, getClassRepository());
 
     return mapToClassDTO(cls);
 }

backend/src/services/groups.ts

@@ -27,7 +27,7 @@ export async function fetchGroup(classId: string, assignmentNumber: number, grou
         throw new NotFoundException('Could not find group');
     }
 
-    return group; 
+    return group;
 }
 
 export async function getGroup(classId: string, assignmentNumber: number, groupNumber: number): Promise<GroupDTO> {
@@ -38,7 +38,7 @@ export async function getGroup(classId: string, assignmentNumber: number, groupN
 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);
-    
+
     const groupRepository = getGroupRepository();
     await groupRepository.deleteByAssignmentAndGroupNumber(assignment, groupNumber);
 
@@ -46,8 +46,8 @@ export async function deleteGroup(classId: string, assignmentNumber: number, gro
 }
 
 export async function getExistingGroupFromGroupDTO(groupData: GroupDTO) {
-    const classId = typeof(groupData.class) === 'string' ? groupData.class : groupData.class.id;
+    const classId = typeof groupData.class === 'string' ? groupData.class : groupData.class.id;
-    const assignmentNumber = typeof(groupData.assignment) === 'number' ? groupData.assignment : groupData.assignment.id;
+    const assignmentNumber = typeof groupData.assignment === 'number' ? groupData.assignment : groupData.assignment.id;
     const groupNumber = groupData.groupNumber;
 
     return await fetchGroup(classId, assignmentNumber, groupNumber);

backend/src/services/service-helper.ts

@@ -1,5 +1,5 @@
-import { EntityDTO, FromEntityType } from "@mikro-orm/core";
+import { EntityDTO, FromEntityType } from '@mikro-orm/core';
-import { DwengoEntityRepository } from "../data/dwengo-entity-repository";
+import { DwengoEntityRepository } from '../data/dwengo-entity-repository';
 
 /**
  * Utility function to perform an PUT on an object.
@@ -7,14 +7,14 @@ import { DwengoEntityRepository } from "../data/dwengo-entity-repository";
  * @param object The object that needs to be changed
  * @param data The datafields and their values that will be updated
  * @param repo The repository on which this action needs to be performed
- * 
+ *
  * @returns Nothing.
  */
 export async function putObject<T extends object, DTO>(
-    object: T, 
+    object: T,
-    data: Partial<EntityDTO<FromEntityType<T>>>, 
+    data: Partial<EntityDTO<FromEntityType<T>>>,
     repo: DwengoEntityRepository<T>
 ): Promise<void> {
     repo.assign(object, data);
     await repo.getEntityManager().flush();
-}
+}

backend/src/services/submissions.ts

@@ -8,10 +8,7 @@ import { fetchStudent } from './students.js';
 import { fetchGroup, getExistingGroupFromGroupDTO } from './groups.js';
 import { Submission } from '../entities/assignments/submission.entity.js';
 
-export async function fetchSubmission(
+export async function fetchSubmission(loId: LearningObjectIdentifier, submissionNumber: number): Promise<Submission> {
-    loId: LearningObjectIdentifier,
-    submissionNumber: number,
-): Promise<Submission> {
     const submissionRepository = getSubmissionRepository();
     const submission = await submissionRepository.findSubmissionByLearningObjectAndSubmissionNumber(loId, submissionNumber);
 
@@ -22,17 +19,12 @@ export async function fetchSubmission(
     return submission;
 }
 
-export async function getSubmission(
+export async function getSubmission(loId: LearningObjectIdentifier, submissionNumber: number): Promise<SubmissionDTO> {
-    loId: LearningObjectIdentifier,
-    submissionNumber: number
-): Promise<SubmissionDTO> {
     const submission = await fetchSubmission(loId, submissionNumber);
     return mapToSubmissionDTO(submission);
 }
 
-export async function getAllSubmissions(
+export async function getAllSubmissions(loId: LearningObjectIdentifier): Promise<SubmissionDTO[]> {
-    loId: LearningObjectIdentifier,
-): Promise<SubmissionDTO[]> {
     const submissionRepository = getSubmissionRepository();
     const submissions = await submissionRepository.findByLearningObject(loId);
 
@@ -52,7 +44,7 @@ export async function createSubmission(submissionDTO: SubmissionDTO): Promise<Su
 
 export async function deleteSubmission(loId: LearningObjectIdentifier, submissionNumber: number): Promise<SubmissionDTO> {
     const submission = await fetchSubmission(loId, submissionNumber);
-    
+
     const submissionRepository = getSubmissionRepository();
     await submissionRepository.deleteSubmissionByLearningObjectAndSubmissionNumber(loId, submissionNumber);
 

backend/src/services/teachers.ts

@@ -22,7 +22,7 @@ import { Question } from '../entities/questions/question.entity.js';
 import { ClassJoinRequestRepository } from '../data/classes/class-join-request-repository.js';
 import { Student } from '../entities/users/student.entity.js';
 import { NotFoundException } from '../exceptions/not-found-exception.js';
-import {getClassStudents, getClassStudentsDTO} from './classes.js';
+import { getClassStudents, getClassStudentsDTO } from './classes.js';
 import { TeacherDTO } from '@dwengo-1/common/interfaces/teacher';
 import { ClassDTO } from '@dwengo-1/common/interfaces/class';
 import { StudentDTO } from '@dwengo-1/common/interfaces/student';
@@ -102,9 +102,9 @@ export async function getStudentsByTeacher(username: string, full: boolean): Pro
     const students: StudentDTO[] = (await Promise.all(classIds.map(async (username) => await getClassStudentsDTO(username)))).flat();
 
     if (full) {
-        return students
+        return students;
     }
-    
+
     return students.map((student) => student.username);
 }
 

frontend/src/controllers/classes.ts

@@ -3,7 +3,7 @@ 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 { TeachersResponse } from "@/controllers/teachers.ts";
 
 export interface ClassesResponse {
     classes: ClassDTO[] | string[];