tdpeuter/2025SELab2-project-Dwengo
tdpeuter/2025SELab2-project-Dwengo
1
Fork 0
Code Issues Releases 4 Packages 2 Wiki Activity

style: fix linting issues met Prettier

Browse source
This commit is contained in:
Lint Action 2025-04-06 20:32:13 +00:00
parent b963101f62
commit 34facfe7c8
12 changed files with 70 additions and 72 deletions
Download patch file Download diff file Expand all files Collapse all files

23
backend/src/controllers/assignments.ts
View file

@ -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 {BadRequestException} from "../exceptions/bad-request-exception";
import { requireFields } from './error-helper';
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);

4
backend/src/controllers/classes.ts
View file

@ -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';

8
backend/src/controllers/submissions.ts
View file

@ -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);

4
backend/src/data/questions/question-repository.ts
View file

@ -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 },

3
backend/src/routes/classes.ts
View file

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

28
backend/src/services/assignments.ts
View file

@ -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(
groups.map(async (group) => submissionRepository.findAllSubmissionsForGroup(group))
)).flat();
const submissions = (await Promise.all(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(
classid: string,
assignmentNumber: number,
full: boolean
): Promise<QuestionDTO[] | QuestionId[]> {
export async function getAssignmentsQuestions(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);
}
}

28
backend/src/services/classes.ts
View file

@ -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 {fetchStudent, getStudent} from "./students";
import {TeacherDTO} from "@dwengo-1/common/interfaces/teacher";
import {mapToTeacherDTO} from "../interfaces/teacher";
import { fetchTeacher } from './teachers';
import { fetchStudent, getStudent } from './students';
import { TeacherDTO } from '@dwengo-1/common/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);
}

8
backend/src/services/groups.ts
View file

@ -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 assignmentNumber = typeof(groupData.assignment) === 'number' ? groupData.assignment : groupData.assignment.id;
const classId = typeof groupData.class === 'string' ? groupData.class : groupData.class.id;
const assignmentNumber = typeof groupData.assignment === 'number' ? groupData.assignment : groupData.assignment.id;
const groupNumber = groupData.groupNumber;
return await fetchGroup(classId, assignmentNumber, groupNumber);

12
backend/src/services/service-helper.ts
View file

@ -1,5 +1,5 @@
import { EntityDTO, FromEntityType } from "@mikro-orm/core";
import { DwengoEntityRepository } from "../data/dwengo-entity-repository";
import { EntityDTO, FromEntityType } from '@mikro-orm/core';
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,
data: Partial<EntityDTO<FromEntityType<T>>>,
object: T,
data: Partial<EntityDTO<FromEntityType<T>>>,
repo: DwengoEntityRepository<T>
): Promise<void> {
repo.assign(object, data);
await repo.getEntityManager().flush();
}
}

16
backend/src/services/submissions.ts
View file

@ -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(
loId: LearningObjectIdentifier,
submissionNumber: number,
): Promise<Submission> {
export async function fetchSubmission(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(
loId: LearningObjectIdentifier,
submissionNumber: number
): Promise<SubmissionDTO> {
export async function getSubmission(loId: LearningObjectIdentifier, submissionNumber: number): Promise<SubmissionDTO> {
const submission = await fetchSubmission(loId, submissionNumber);
return mapToSubmissionDTO(submission);
}
export async function getAllSubmissions(
loId: LearningObjectIdentifier,
): Promise<SubmissionDTO[]> {
export async function getAllSubmissions(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);

6
backend/src/services/teachers.ts
View file

@ -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);
}

2
frontend/src/controllers/classes.ts
View file

@ -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[];