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

Merge remote-tracking branch 'origin/dev' into feat/endpoints-beschermen-met-authenticatie-#105

Browse source 
# Conflicts:
#	backend/src/controllers/assignments.ts
#	backend/src/controllers/questions.ts
#	backend/src/data/questions/question-repository.ts
#	backend/src/interfaces/question.ts
#	backend/src/routes/assignments.ts
#	backend/src/routes/classes.ts
#	backend/src/routes/groups.ts
#	backend/src/routes/teachers.ts
#	backend/src/services/questions.ts
#	common/src/interfaces/question.ts
This commit is contained in:
Gabriellvl 2025-04-18 21:55:01 +02:00
commit ac399153b6
71 changed files with 2075 additions and 2603 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -1,77 +1,94 @@
import { Request, Response } from 'express';
import { createAssignment, getAllAssignments, getAssignment, getAssignmentsSubmissions } 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.js';
import { BadRequestException } from '../exceptions/bad-request-exception.js';
import { Assignment } from '../entities/assignments/assignment.entity.js';
import { EntityDTO } from '@mikro-orm/core';
// Typescript is annoying with parameter forwarding from class.ts
export interface AssignmentParams {
classid: string;
id: string;
}
export async function getAllAssignmentsHandler(req: Request<AssignmentParams>, res: Response): Promise<void> {
const classid = req.params.classid;
export async function getAllAssignmentsHandler(req: Request, res: Response): Promise<void> {
const classId = req.params.classid;
const full = req.query.full === 'true';
const assignments = await getAllAssignments(classid, full);
const assignments = await getAllAssignments(classId, full);
res.json({
assignments: assignments,
});
res.json({ assignments });
}
export async function createAssignmentHandler(req: Request<AssignmentParams>, res: Response): Promise<void> {
export async function createAssignmentHandler(req: Request, res: Response): Promise<void> {
const classid = req.params.classid;
const description = req.body.description;
const language = req.body.language;
const learningPath = req.body.learningPath;
const title = req.body.title;
requireFields({ description, language, learningPath, title });
const assignmentData = req.body as AssignmentDTO;
if (!assignmentData.description || !assignmentData.language || !assignmentData.learningPath || !assignmentData.title) {
res.status(400).json({
error: 'Missing one or more required fields: title, description, learningPath, language',
});
return;
}
const assignment = await createAssignment(classid, assignmentData);
if (!assignment) {
res.status(500).json({ error: 'Could not create assignment ' });
return;
}
res.status(201).json(assignment);
res.json({ assignment });
}
export async function getAssignmentHandler(req: Request<AssignmentParams>, res: Response): Promise<void> {
export async function getAssignmentHandler(req: Request, res: Response): Promise<void> {
const id = Number(req.params.id);
const classid = req.params.classid;
requireFields({ id, classid });
if (isNaN(id)) {
res.status(400).json({ error: 'Assignment id must be a number' });
return;
throw new BadRequestException('Assignment id should be a number');
}
const assignment = await getAssignment(classid, id);
if (!assignment) {
res.status(404).json({ error: 'Assignment not found' });
return;
}
res.json(assignment);
res.json({ assignment });
}
export async function getAssignmentsSubmissionsHandler(req: Request<AssignmentParams>, res: Response): Promise<void> {
export async function putAssignmentHandler(req: Request, res: Response): Promise<void> {
const id = Number(req.params.id);
const classid = req.params.classid;
requireFields({ id, classid });
if (isNaN(id)) {
throw new BadRequestException('Assignment id should be a number');
}
const assignmentData = req.body as Partial<EntityDTO<Assignment>>;
const assignment = await putAssignment(classid, id, assignmentData);
res.json({ assignment });
}
export async function deleteAssignmentHandler(req: Request, _res: Response): Promise<void> {
const id = Number(req.params.id);
const classid = req.params.classid;
requireFields({ id, classid });
if (isNaN(id)) {
throw new BadRequestException('Assignment id should be a number');
}
await deleteAssignment(classid, id);
}
export async function getAssignmentsSubmissionsHandler(req: Request, res: Response): Promise<void> {
const classid = req.params.classid;
const assignmentNumber = Number(req.params.id);
const full = req.query.full === 'true';
requireFields({ assignmentNumber, classid });
if (isNaN(assignmentNumber)) {
res.status(400).json({ error: 'Assignment id must be a number' });
return;
throw new BadRequestException('Assignment id should be a number');
}
const submissions = await getAssignmentsSubmissions(classid, assignmentNumber, full);
res.json({
submissions: submissions,
});
res.json({ submissions });
}

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

@ -1,44 +1,62 @@
import { Request, Response } from 'express';
import { createClass, getAllClasses, getClass, getClassStudents, getClassStudentsIds, getClassTeacherInvitations } from '../services/classes.js';
import {
addClassStudent,
addClassTeacher,
createClass,
deleteClass,
deleteClassStudent,
deleteClassTeacher,
getAllClasses,
getClass,
getClassStudents,
getClassTeacherInvitations,
getClassTeachers,
putClass,
} from '../services/classes.js';
import { ClassDTO } from '@dwengo-1/common/interfaces/class';
import { requireFields } from './error-helper.js';
import { EntityDTO } from '@mikro-orm/core';
import { Class } from '../entities/classes/class.entity.js';
export async function getAllClassesHandler(req: Request, res: Response): Promise<void> {
const full = req.query.full === 'true';
const classes = await getAllClasses(full);
res.json({
classes: classes,
});
res.json({ classes });
}
export async function createClassHandler(req: Request, res: Response): Promise<void> {
const displayName = req.body.displayName;
requireFields({ displayName });
const classData = req.body as ClassDTO;
if (!classData.displayName) {
res.status(400).json({
error: 'Missing one or more required fields: displayName',
});
return;
}
const cls = await createClass(classData);
if (!cls) {
res.status(500).json({ error: 'Something went wrong while creating class' });
return;
}
res.status(201).json({ class: cls });
res.json({ class: cls });
}
export async function getClassHandler(req: Request, res: Response): Promise<void> {
const classId = req.params.id;
requireFields({ classId });
const cls = await getClass(classId);
if (!cls) {
res.status(404).json({ error: 'Class not found' });
return;
}
res.json({ class: cls });
}
export async function putClassHandler(req: Request, res: Response): Promise<void> {
const classId = req.params.id;
requireFields({ classId });
const newData = req.body as Partial<EntityDTO<Class>>;
const cls = await putClass(classId, newData);
res.json({ class: cls });
}
export async function deleteClassHandler(req: Request, res: Response): Promise<void> {
const classId = req.params.id;
const cls = await deleteClass(classId);
res.json({ class: cls });
}
@ -46,21 +64,69 @@ export async function getClassHandler(req: Request, res: Response): Promise<void
export async function getClassStudentsHandler(req: Request, res: Response): Promise<void> {
const classId = req.params.id;
const full = req.query.full === 'true';
requireFields({ classId });
const students = full ? await getClassStudents(classId) : await getClassStudentsIds(classId);
const students = await getClassStudents(classId, full);
res.json({
students: students,
});
res.json({ students });
}
export async function getClassTeachersHandler(req: Request, res: Response): Promise<void> {
const classId = req.params.id;
const full = req.query.full === 'true';
requireFields({ classId });
const teachers = await getClassTeachers(classId, full);
res.json({ teachers });
}
export async function getTeacherInvitationsHandler(req: Request, res: Response): Promise<void> {
const classId = req.params.id;
const full = req.query.full === 'true';
requireFields({ classId });
const invitations = await getClassTeacherInvitations(classId, full);
res.json({
invitations: invitations,
});
res.json({ invitations });
}
export async function deleteClassStudentHandler(req: Request, res: Response): Promise<void> {
const classId = req.params.id;
const username = req.params.username;
requireFields({ classId, username });
const cls = await deleteClassStudent(classId, username);
res.json({ class: cls });
}
export async function deleteClassTeacherHandler(req: Request, res: Response): Promise<void> {
const classId = req.params.id;
const username = req.params.username;
requireFields({ classId, username });
const cls = await deleteClassTeacher(classId, username);
res.json({ class: cls });
}
export async function addClassStudentHandler(req: Request, res: Response): Promise<void> {
const classId = req.params.id;
const username = req.body.username;
requireFields({ classId, username });
const cls = await addClassStudent(classId, username);
res.json({ class: cls });
}
export async function addClassTeacherHandler(req: Request, res: Response): Promise<void> {
const classId = req.params.id;
const username = req.body.username;
requireFields({ classId, username });
const cls = await addClassTeacher(classId, username);
res.json({ class: cls });
}

102
backend/src/controllers/groups.ts
View file

@ -1,100 +1,104 @@
import { Request, Response } from 'express';
import { createGroup, 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 { EntityDTO } from '@mikro-orm/core';
import { Group } from '../entities/assignments/group.entity.js';
// Typescript is annoywith with parameter forwarding from class.ts
interface GroupParams {
classid: string;
assignmentid: string;
groupid?: string;
}
export async function getGroupHandler(req: Request<GroupParams>, res: Response): Promise<void> {
const classId = req.params.classid;
const full = req.query.full === 'true';
const assignmentId = Number(req.params.assignmentid);
function checkGroupFields(classId: string, assignmentId: number, groupId: number): void {
requireFields({ classId, assignmentId, groupId });
if (isNaN(assignmentId)) {
res.status(400).json({ error: 'Assignment id must be a number' });
return;
throw new BadRequestException('Assignment id must be a number');
}
const groupId = Number(req.params.groupid!); // Can't be undefined
if (isNaN(groupId)) {
res.status(400).json({ error: 'Group id must be a number' });
return;
throw new BadRequestException('Group id must be a number');
}
}
const group = await getGroup(classId, assignmentId, groupId, full);
export async function getGroupHandler(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);
if (!group) {
res.status(404).json({ error: 'Group not found' });
return;
}
const group = await getGroup(classId, assignmentId, groupId);
res.json(group);
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);
const groupId = parseInt(req.params.groupid);
checkGroupFields(classId, assignmentId, groupId);
const group = await deleteGroup(classId, assignmentId, groupId);
res.json({ group });
}
export async function getAllGroupsHandler(req: Request, res: Response): Promise<void> {
const classId = req.params.classid;
const full = req.query.full === 'true';
const assignmentId = Number(req.params.assignmentid);
const full = req.query.full === 'true';
requireFields({ classId, assignmentId });
if (isNaN(assignmentId)) {
res.status(400).json({ error: 'Assignment id must be a number' });
return;
throw new BadRequestException('Assignment id must be a number');
}
const groups = await getAllGroups(classId, assignmentId, full);
res.json({
groups: groups,
});
res.json({ groups });
}
export async function createGroupHandler(req: Request, res: Response): Promise<void> {
const classid = req.params.classid;
const assignmentId = Number(req.params.assignmentid);
requireFields({ classid, assignmentId });
if (isNaN(assignmentId)) {
res.status(400).json({ error: 'Assignment id must be a number' });
return;
throw new BadRequestException('Assignment id must be a number');
}
const groupData = req.body as GroupDTO;
const group = await createGroup(groupData, classid, assignmentId);
if (!group) {
res.status(500).json({ error: 'Something went wrong while creating group' });
return;
}
res.status(201).json(group);
res.status(201).json({ group });
}
export async function getGroupSubmissionsHandler(req: Request, res: Response): Promise<void> {
const classId = req.params.classid;
const assignmentId = Number(req.params.assignmentid);
const groupId = Number(req.params.groupid);
const full = req.query.full === 'true';
const assignmentId = Number(req.params.assignmentid);
requireFields({ classId, assignmentId, groupId });
if (isNaN(assignmentId)) {
res.status(400).json({ error: 'Assignment id must be a number' });
return;
throw new BadRequestException('Assignment id must be a number');
}
const groupId = Number(req.params.groupid); // Can't be undefined
if (isNaN(groupId)) {
res.status(400).json({ error: 'Group id must be a number' });
return;
throw new BadRequestException('Group id must be a number');
}
const submissions = await getGroupSubmissions(classId, assignmentId, groupId, full);
res.json({
submissions: submissions,
});
res.json({ submissions });
}

48
backend/src/controllers/questions.ts
View file

@ -3,16 +3,15 @@ import {
createQuestion,
deleteQuestion,
getAllQuestions,
getAnswersByQuestion,
getQuestion,
getQuestionsAboutLearningObjectInAssignment, updateQuestion,
getQuestionsAboutLearningObjectInAssignment,
updateQuestion,
} from '../services/questions.js';
import {FALLBACK_LANG, FALLBACK_SEQ_NUM, FALLBACK_VERSION_NUM} from '../config.js';
import { FALLBACK_LANG, FALLBACK_SEQ_NUM, FALLBACK_VERSION_NUM } from '../config.js';
import { LearningObjectIdentifier } from '../entities/content/learning-object-identifier.js';
import { QuestionData, QuestionDTO, QuestionId } from '@dwengo-1/common/interfaces/question';
import { Language } from '@dwengo-1/common/util/language';
import {requireFields} from "./error-helper";
import {BadRequestException} from "../exceptions/bad-request-exception";
import { requireFields } from './error-helper.js';
export function getLearningObjectId(hruid: string, version: string, lang: string): LearningObjectIdentifier {
return {
@ -29,20 +28,6 @@ export function getQuestionId(learningObjectIdentifier: LearningObjectIdentifier
};
}
function getQuestionIdFromRequest(req: Request): QuestionId | null {
const seq = req.params.seq;
const hruid = req.params.hruid;
const version = req.params.version;
const language = req.query.lang as string;
const learningObjectIdentifier = getLearningObjectId(hruid, version, language);
if (!learningObjectIdentifier) {
return null;
}
return getQuestionId(learningObjectIdentifier, seq);
}
export async function getAllQuestionsHandler(req: Request, res: Response): Promise<void> {
const hruid = req.params.hruid;
const version = req.params.version;
@ -50,12 +35,6 @@ export async function getAllQuestionsHandler(req: Request, res: Response): Promi
const full = req.query.full === 'true';
requireFields({ hruid });
const assignmentId = parseInt(req.query.assignmentId as string);
if (isNaN(assignmentId)) {
throw new BadRequestException("The assignment ID must be a number.");
}
const learningObjectId = getLearningObjectId(hruid, version, language);
let questions: QuestionDTO[] | QuestionId[];
@ -89,23 +68,6 @@ export async function getQuestionHandler(req: Request, res: Response): Promise<v
res.json({ question });
}
export async function getQuestionAnswersHandler(req: Request, res: Response): Promise<void> {
const questionId = getQuestionIdFromRequest(req);
const full = req.query.full;
if (!questionId) {
return;
}
const answers = await getAnswersByQuestion(questionId, full === "true");
if (!answers) {
res.status(404).json({ error: `Questions not found` });
} else {
res.json({ answers: answers });
}
}
export async function createQuestionHandler(req: Request, res: Response): Promise<void> {
const hruid = req.params.hruid;
const version = req.params.version;
@ -116,7 +78,7 @@ export async function createQuestionHandler(req: Request, res: Response): Promis
const author = req.body.author as string;
const content = req.body.content as string;
const inGroup = req.body.inGroup as string;
const inGroup = req.body.inGroup;
requireFields({ author, content, inGroup });
const questionData = req.body as QuestionData;

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

@ -1,83 +1,83 @@
import { Request, Response } from 'express';
import { createSubmission, deleteSubmission, getSubmission, getSubmissionsForLearningObjectAndAssignment } from '../services/submissions.js';
import {
createSubmission,
deleteSubmission,
getAllSubmissions,
getSubmission,
getSubmissionsForLearningObjectAndAssignment,
} from '../services/submissions.js';
import { SubmissionDTO } from '@dwengo-1/common/interfaces/submission';
import { Language, languageMap } from '@dwengo-1/common/util/language';
import { Submission } from '../entities/assignments/submission.entity';
import { BadRequestException } from '../exceptions/bad-request-exception.js';
import { requireFields } from './error-helper.js';
import { LearningObjectIdentifier } from '../entities/content/learning-object-identifier.js';
interface SubmissionParams {
hruid: string;
id: number;
}
interface SubmissionQuery {
language: string;
version: number;
}
interface SubmissionsQuery extends SubmissionQuery {
classId: string;
assignmentId: number;
studentUsername?: string;
}
export async function getSubmissionsHandler(req: Request<SubmissionParams, Submission[], null, SubmissionsQuery>, res: Response): Promise<void> {
export async function getSubmissionsHandler(req: Request, res: Response): Promise<void> {
const loHruid = req.params.hruid;
const lang = languageMap[req.query.language] || Language.Dutch;
const version = req.query.version || 1;
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, req.query.assignmentId);
const submissions = await getSubmissionsForLearningObjectAndAssignment(
loHruid,
lang,
version,
req.query.classId as string,
parseInt(req.query.assignmentId as string)
);
res.json(submissions);
}
export async function getSubmissionHandler(req: Request<SubmissionParams>, res: Response): Promise<void> {
export async function getSubmissionHandler(req: Request, res: Response): Promise<void> {
const lohruid = req.params.hruid;
const submissionNumber = Number(req.params.id);
if (isNaN(submissionNumber)) {
res.status(400).json({ error: 'Submission number is not a number' });
return;
}
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 });
const submission = await getSubmission(lohruid, lang, version, submissionNumber);
if (!submission) {
res.status(404).json({ error: 'Submission not found' });
return;
if (isNaN(submissionNumber)) {
throw new BadRequestException('Submission number must be a number');
}
res.json(submission);
const loId = new LearningObjectIdentifier(lohruid, lang, version);
const submission = await getSubmission(loId, submissionNumber);
res.json({ submission });
}
export async function getAllSubmissionsHandler(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;
requireFields({ lohruid });
const loId = new LearningObjectIdentifier(lohruid, lang, version);
const submissions = await getAllSubmissions(loId);
res.json({ submissions });
}
// TODO: gerald moet nog dingen toevoegen aan de databank voor dat dit gefinaliseerd kan worden
export async function createSubmissionHandler(req: Request, res: Response): Promise<void> {
const submissionDTO = req.body as SubmissionDTO;
const submission = await createSubmission(submissionDTO);
if (!submission) {
res.status(400).json({ error: 'Failed to create submission' });
return;
}
res.json(submission);
res.json({ submission });
}
export async function deleteSubmissionHandler(req: Request, res: Response): Promise<void> {
const hruid = req.params.hruid;
const submissionNumber = Number(req.params.id);
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({ hruid, submissionNumber });
const submission = await deleteSubmission(hruid, lang, version, submissionNumber);
if (!submission) {
res.status(404).json({ error: 'Submission not found' });
return;
if (isNaN(submissionNumber)) {
throw new BadRequestException('Submission number must be a number');
}
res.json(submission);
const loId = new LearningObjectIdentifier(hruid, lang, version);
const submission = await deleteSubmission(loId, submissionNumber);
res.json({ submission });
}

66
backend/src/controllers/teacher-invitations.ts Normal file
View file

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

5
backend/src/controllers/teachers.ts
View file

@ -81,16 +81,15 @@ export async function getTeacherQuestionHandler(req: Request, res: Response): Pr
}
export async function getStudentJoinRequestHandler(req: Request, res: Response): Promise<void> {
const username = req.query.username as string;
const classId = req.params.classId;
requireFields({ username, classId });
requireFields({ classId });
const joinRequests = await getJoinRequestsByClass(classId);
res.json({ joinRequests });
}
export async function updateStudentJoinRequestHandler(req: Request, res: Response): Promise<void> {
const studentUsername = req.query.studentUsername as string;
const studentUsername = req.params.studentUsername;
const classId = req.params.classId;
const accepted = req.body.accepted !== 'false'; // Default = true
requireFields({ studentUsername, classId });

8
backend/src/data/assignments/submission-repository.ts
View file

@ -18,6 +18,14 @@ export class SubmissionRepository extends DwengoEntityRepository<Submission> {
});
}
public async findByLearningObject(loId: LearningObjectIdentifier): Promise<Submission[]> {
return this.find({
learningObjectHruid: loId.hruid,
learningObjectLanguage: loId.language,
learningObjectVersion: loId.version,
});
}
public async findMostRecentSubmissionForStudent(loId: LearningObjectIdentifier, submitter: Student): Promise<Submission | null> {
return this.findOne(
{

4
backend/src/data/classes/class-join-request-repository.ts
View file

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

10
backend/src/data/classes/teacher-invitation-repository.ts
View file

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

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

@ -3,8 +3,8 @@ import { Question } from '../../entities/questions/question.entity.js';
import { LearningObjectIdentifier } from '../../entities/content/learning-object-identifier.js';
import { Student } from '../../entities/users/student.entity.js';
import { LearningObject } from '../../entities/content/learning-object.entity.js';
import { Group } from '../../entities/assignments/group.entity';
import { Assignment } from '../../entities/assignments/assignment.entity';
import { Group } from '../../entities/assignments/group.entity.js';
import { Assignment } from '../../entities/assignments/assignment.entity.js';
import { Loaded } from '@mikro-orm/core';
export class QuestionRepository extends DwengoEntityRepository<Question> {
@ -60,6 +60,16 @@ export class QuestionRepository extends DwengoEntityRepository<Question> {
});
}
public async findAllByAssignment(assignment: Assignment): Promise<Question[]> {
return this.find({
inGroup: {
$contained: assignment.groups,
},
learningObjectHruid: assignment.learningPathHruid,
learningObjectLanguage: assignment.learningPathLanguage,
});
}
public async findAllByAuthor(author: Student): Promise<Question[]> {
return this.findAll({
where: { author },
@ -67,21 +77,6 @@ export class QuestionRepository extends DwengoEntityRepository<Question> {
});
}
public async findByLearningObjectAndSequenceNumber(loId: LearningObjectIdentifier, sequenceNumber: number): Promise<Loaded<Question> | null> {
return this.findOne({
learningObjectHruid: loId.hruid,
learningObjectLanguage: loId.language,
learningObjectVersion: loId.version,
sequenceNumber,
});
}
public async updateContent(question: Question, newContent: string): Promise<Question> {
question.content = newContent;
await this.save(question);
return question;
}
/**
* Looks up all questions for the given learning object which were asked as part of the given assignment.
* When forStudentUsername is set, only the questions within the given user's group are shown.
@ -113,4 +108,19 @@ export class QuestionRepository extends DwengoEntityRepository<Question> {
},
});
}
public async findByLearningObjectAndSequenceNumber(loId: LearningObjectIdentifier, sequenceNumber: number): Promise<Loaded<Question> | null> {
return this.findOne({
learningObjectHruid: loId.hruid,
learningObjectLanguage: loId.language,
learningObjectVersion: loId.version,
sequenceNumber,
});
}
public async updateContent(question: Question, newContent: string): Promise<Question> {
question.content = newContent;
await this.save(question);
return question;
}
}

6
backend/src/entities/classes/class-join-request.entity.ts
View file

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

6
backend/src/entities/classes/teacher-invitation.entity.ts
View file

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

2
backend/src/entities/questions/question.entity.ts
View file

@ -2,7 +2,7 @@ import { Entity, Enum, ManyToOne, PrimaryKey, Property } from '@mikro-orm/core';
import { Student } from '../users/student.entity.js';
import { QuestionRepository } from '../../data/questions/question-repository.js';
import { Language } from '@dwengo-1/common/util/language';
import { Group } from '../assignments/group.entity';
import { Group } from '../assignments/group.entity.js';
@Entity({ repository: () => QuestionRepository })
export class Question {

5
backend/src/interfaces/assignment.ts
View file

@ -8,19 +8,18 @@ import { AssignmentDTO } from '@dwengo-1/common/interfaces/assignment';
export function mapToAssignmentDTOId(assignment: Assignment): AssignmentDTO {
return {
id: assignment.id!,
class: assignment.within.classId!,
within: assignment.within.classId!,
title: assignment.title,
description: assignment.description,
learningPath: assignment.learningPathHruid,
language: assignment.learningPathLanguage,
// Groups: assignment.groups.map(group => group.groupNumber),
};
}
export function mapToAssignmentDTO(assignment: Assignment): AssignmentDTO {
return {
id: assignment.id!,
class: assignment.within.classId!,
within: assignment.within.classId!,
title: assignment.title,
description: assignment.description,
learningPath: assignment.learningPathHruid,

1
backend/src/interfaces/class.ts
View file

@ -10,7 +10,6 @@ export function mapToClassDTO(cls: Class): ClassDTO {
displayName: cls.displayName,
teachers: cls.teachers.map((teacher) => teacher.username),
students: cls.students.map((student) => student.username),
joinRequests: [], // TODO
};
}

18
backend/src/interfaces/group.ts
View file

@ -1,11 +1,14 @@
import { Group } from '../entities/assignments/group.entity.js';
import { mapToAssignment, mapToAssignmentDTO, mapToAssignmentDTOId } from './assignment.js';
import { mapToStudent, mapToStudentDTO } from './student.js';
import { mapToAssignment } from './assignment.js';
import { mapToStudent } from './student.js';
import { mapToAssignmentDTO } from './assignment.js';
import { mapToStudentDTO } from './student.js';
import { GroupDTO } from '@dwengo-1/common/interfaces/group';
import { getGroupRepository } from '../data/repositories';
import { getGroupRepository } from '../data/repositories.js';
import { AssignmentDTO } from '@dwengo-1/common/interfaces/assignment';
import { Class } from '../entities/classes/class.entity';
import { Class } from '../entities/classes/class.entity.js';
import { StudentDTO } from '@dwengo-1/common/interfaces/student';
import { mapToClassDTO } from './class';
export function mapToGroup(groupDto: GroupDTO, clazz: Class): Group {
const assignmentDto = groupDto.assignment as AssignmentDTO;
@ -19,7 +22,8 @@ export function mapToGroup(groupDto: GroupDTO, clazz: Class): Group {
export function mapToGroupDTO(group: Group): GroupDTO {
return {
assignment: mapToAssignmentDTO(group.assignment), // ERROR: , group.assignment.within),
class: mapToClassDTO(group.assignment.within),
assignment: mapToAssignmentDTO(group.assignment),
groupNumber: group.groupNumber!,
members: group.members.map(mapToStudentDTO),
};
@ -27,7 +31,8 @@ export function mapToGroupDTO(group: Group): GroupDTO {
export function mapToGroupDTOId(group: Group): GroupDTO {
return {
assignment: mapToAssignmentDTOId(group.assignment),
class: group.assignment.within.classId!,
assignment: group.assignment.id!,
groupNumber: group.groupNumber!,
};
}
@ -37,6 +42,7 @@ export function mapToGroupDTOId(group: Group): GroupDTO {
*/
export function mapToShallowGroupDTO(group: Group): GroupDTO {
return {
class: group.assignment.within.classId!,
assignment: group.assignment.id!,
groupNumber: group.groupNumber!,
members: group.members.map((member) => member.username),

4
backend/src/interfaces/question.ts
View file

@ -1,9 +1,9 @@
import { Question } from '../entities/questions/question.entity.js';
import { mapToStudentDTO } from './student.js';
import { QuestionDTO, QuestionId } from '@dwengo-1/common/interfaces/question';
import { mapToGroupDTOId } from './group';
import { LearningObjectIdentifierDTO } from '@dwengo-1/common/interfaces/learning-content';
import {LearningObjectIdentifier} from "../entities/content/learning-object-identifier";
import { LearningObjectIdentifier } from '../entities/content/learning-object-identifier.js';
import { mapToGroupDTOId } from './group.js';
function getLearningObjectIdentifier(question: Question): LearningObjectIdentifierDTO {
return {

4
backend/src/interfaces/student-request.ts
View file

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

27
backend/src/interfaces/submission.ts
View file

@ -1,7 +1,10 @@
import { Submission } from '../entities/assignments/submission.entity.js';
import { mapToGroupDTO } from './group.js';
import { mapToStudent, mapToStudentDTO } from './student.js';
import { mapToStudentDTO } from './student.js';
import { SubmissionDTO, SubmissionDTOId } from '@dwengo-1/common/interfaces/submission';
import { getSubmissionRepository } from '../data/repositories';
import { Student } from '../entities/users/student.entity';
import { Group } from '../entities/assignments/group.entity';
export function mapToSubmissionDTO(submission: Submission): SubmissionDTO {
return {
@ -29,16 +32,14 @@ export function mapToSubmissionDTOId(submission: Submission): SubmissionDTOId {
};
}
export function mapToSubmission(submissionDTO: SubmissionDTO): Submission {
const submission = new Submission();
submission.learningObjectHruid = submissionDTO.learningObjectIdentifier.hruid;
submission.learningObjectLanguage = submissionDTO.learningObjectIdentifier.language;
submission.learningObjectVersion = submissionDTO.learningObjectIdentifier.version!;
// Submission.submissionNumber = submissionDTO.submissionNumber;
submission.submitter = mapToStudent(submissionDTO.submitter);
// Submission.submissionTime = submissionDTO.time;
// Submission.onBehalfOf = submissionDTO.group!;
submission.content = submissionDTO.content;
return submission;
export function mapToSubmission(submissionDTO: SubmissionDTO, submitter: Student, onBehalfOf: Group): Submission {
return getSubmissionRepository().create({
learningObjectHruid: submissionDTO.learningObjectIdentifier.hruid,
learningObjectLanguage: submissionDTO.learningObjectIdentifier.language,
learningObjectVersion: submissionDTO.learningObjectIdentifier.version || 1,
submitter: submitter,
submissionTime: new Date(),
content: submissionDTO.content,
onBehalfOf: onBehalfOf,
});
}

20
backend/src/interfaces/teacher-invitation.ts
View file

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

8
backend/src/routes/assignments.ts
View file

@ -1,9 +1,11 @@
import express from 'express';
import {
createAssignmentHandler,
deleteAssignmentHandler,
getAllAssignmentsHandler,
getAssignmentHandler,
getAssignmentsSubmissionsHandler,
putAssignmentHandler,
} from '../controllers/assignments.js';
import groupRouter from './groups.js';
import {adminOnly, teachersOnly} from "../middleware/auth/checks/auth-checks";
@ -12,14 +14,20 @@ import {onlyAllowIfHasAccessToAssignment} from "../middleware/auth/checks/assign
const router = express.Router({ mergeParams: true });
router.get('/', getAllAssignmentsHandler);
// Root endpoint used to search objects
router.get('/', adminOnly, getAllAssignmentsHandler);
router.post('/', teachersOnly, onlyAllowOwnClassInBody, createAssignmentHandler);
router.get('/:id', getAssignmentHandler);
// Information about an assignment with id 'id'
router.get('/:id', onlyAllowIfHasAccessToAssignment, getAssignmentHandler);
router.put('/:id', putAssignmentHandler);
router.delete('/:id', deleteAssignmentHandler);
router.get('/:id/submissions', onlyAllowIfHasAccessToAssignment, getAssignmentsSubmissionsHandler);
router.get('/:id/questions', onlyAllowIfHasAccessToAssignment, (_req, res) => {

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

@ -1,10 +1,17 @@
import express from 'express';
import {
addClassStudentHandler,
addClassTeacherHandler,
createClassHandler,
deleteClassHandler,
deleteClassStudentHandler,
deleteClassTeacherHandler,
getAllClassesHandler,
getClassHandler,
getClassStudentsHandler,
getClassTeachersHandler,
getTeacherInvitationsHandler,
putClassHandler,
} from '../controllers/classes.js';
import assignmentRouter from './assignments.js';
import {adminOnly, teachersOnly} from "../middleware/auth/checks/auth-checks";
@ -20,10 +27,24 @@ router.post('/', teachersOnly, createClassHandler);
// Information about an class with id 'id'
router.get('/:id', onlyAllowIfInClass, getClassHandler);
router.put('/:id', putClassHandler);
router.delete('/:id', deleteClassHandler);
router.get('/:id/teacher-invitations', teachersOnly, onlyAllowIfInClass, getTeacherInvitationsHandler);
router.get('/:id/students', onlyAllowIfInClass, getClassStudentsHandler);
router.post('/:id/students', addClassStudentHandler);
router.delete('/:id/students/:username', deleteClassStudentHandler);
router.get('/:id/teachers', getClassTeachersHandler);
router.post('/:id/teachers', addClassTeacherHandler);
router.delete('/:id/teachers/:username', deleteClassTeacherHandler);
router.use('/:classid/assignments', assignmentRouter);
export default router;

13
backend/src/routes/groups.ts
View file

@ -1,5 +1,12 @@
import express from 'express';
import { createGroupHandler, getAllGroupsHandler, getGroupHandler, getGroupSubmissionsHandler } from '../controllers/groups.js';
import {
createGroupHandler,
deleteGroupHandler,
getAllGroupsHandler,
getGroupHandler,
getGroupSubmissionsHandler,
putGroupHandler,
} from '../controllers/groups.js';
import {onlyAllowIfHasAccessToGroup} from "../middleware/auth/checks/group-auth-checker";
import {teachersOnly} from "../middleware/auth/checks/auth-checks";
import {onlyAllowIfHasAccessToAssignment} from "../middleware/auth/checks/assignment-auth-checks";
@ -14,6 +21,10 @@ router.post('/', teachersOnly, onlyAllowIfHasAccessToAssignment, createGroupHand
// Information about a group (members, ... [TODO DOC])
router.get('/:groupid', onlyAllowIfHasAccessToGroup, getGroupHandler);
router.put('/:groupid', putGroupHandler);
router.delete('/:groupid', deleteGroupHandler);
router.get('/:groupid/submissions', onlyAllowIfHasAccessToGroup, getGroupSubmissionsHandler);
// The list of questions a group has made

22
backend/src/routes/teacher-invitations.ts Normal file
View file

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

8
backend/src/routes/teachers.ts
View file

@ -10,6 +10,8 @@ import {
getTeacherStudentHandler,
updateStudentJoinRequestHandler,
} from '../controllers/teachers.js';
import invitationRouter from './teacher-invitations.js';
import {adminOnly} from "../middleware/auth/checks/auth-checks";
import {onlyAllowUserHimself} from "../middleware/auth/checks/user-auth-checks";
import {onlyAllowTeacherOfClass} from "../middleware/auth/checks/class-auth-checks";
@ -35,10 +37,6 @@ router.get('/:username/joinRequests/:classId', onlyAllowTeacherOfClass, getStude
router.put('/:username/joinRequests/:classId/:studentUsername', onlyAllowTeacherOfClass, 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;

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

@ -1,18 +1,43 @@
import { getAssignmentRepository, getClassRepository, getGroupRepository, getSubmissionRepository } from '../data/repositories.js';
import { mapToAssignment, mapToAssignmentDTO, mapToAssignmentDTOId } from '../interfaces/assignment.js';
import { mapToSubmissionDTO, mapToSubmissionDTOId } from '../interfaces/submission.js';
import { AssignmentDTO } from '@dwengo-1/common/interfaces/assignment';
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';
import { mapToQuestionDTO } from '../interfaces/question.js';
import { mapToSubmissionDTO, mapToSubmissionDTOId } from '../interfaces/submission.js';
import { fetchClass } from './classes.js';
import { QuestionDTO, QuestionId } from '@dwengo-1/common/interfaces/question';
import { SubmissionDTO, SubmissionDTOId } from '@dwengo-1/common/interfaces/submission';
import { getLogger } from '../logging/initalize.js';
import { EntityDTO } from '@mikro-orm/core';
import { putObject } from './service-helper.js';
export async function getAllAssignments(classid: string, full: boolean): Promise<AssignmentDTO[]> {
export async function fetchAssignment(classid: string, assignmentNumber: number): Promise<Assignment> {
const classRepository = getClassRepository();
const cls = await classRepository.findById(classid);
if (!cls) {
return [];
throw new NotFoundException("Could not find assignment's class");
}
const assignmentRepository = getAssignmentRepository();
const assignment = await assignmentRepository.findByClassAndId(cls, assignmentNumber);
if (!assignment) {
throw new NotFoundException('Could not find assignment');
}
return assignment;
}
export async function getAllAssignments(classid: string, full: boolean): Promise<AssignmentDTO[]> {
const cls = await fetchClass(classid);
const assignmentRepository = getAssignmentRepository();
const assignments = await assignmentRepository.findAllAssignmentsInClass(cls);
@ -23,42 +48,37 @@ export async function getAllAssignments(classid: string, full: boolean): Promise
return assignments.map(mapToAssignmentDTOId);
}
export async function createAssignment(classid: string, assignmentData: AssignmentDTO): Promise<AssignmentDTO | null> {
const classRepository = getClassRepository();
const cls = await classRepository.findById(classid);
if (!cls) {
return null;
}
export async function createAssignment(classid: string, assignmentData: AssignmentDTO): Promise<AssignmentDTO> {
const cls = await fetchClass(classid);
const assignment = mapToAssignment(assignmentData, cls);
const assignmentRepository = getAssignmentRepository();
const newAssignment = assignmentRepository.create(assignment);
await assignmentRepository.save(newAssignment, { preventOverwrite: true });
try {
const newAssignment = assignmentRepository.create(assignment);
await assignmentRepository.save(newAssignment);
return mapToAssignmentDTO(newAssignment);
} catch (e) {
getLogger().error(e);
return null;
}
return mapToAssignmentDTO(newAssignment);
}
export async function getAssignment(classid: string, id: number): Promise<AssignmentDTO | null> {
const classRepository = getClassRepository();
const cls = await classRepository.findById(classid);
export async function getAssignment(classid: string, id: number): Promise<AssignmentDTO> {
const assignment = await fetchAssignment(classid, id);
return mapToAssignmentDTO(assignment);
}
if (!cls) {
return null;
}
export async function putAssignment(classid: string, id: number, assignmentData: Partial<EntityDTO<Assignment>>): Promise<AssignmentDTO> {
const assignment = await fetchAssignment(classid, id);
await putObject<Assignment>(assignment, assignmentData, getAssignmentRepository());
return mapToAssignmentDTO(assignment);
}
export async function deleteAssignment(classid: string, id: number): Promise<AssignmentDTO> {
const assignment = await fetchAssignment(classid, id);
const cls = await fetchClass(classid);
const assignmentRepository = getAssignmentRepository();
const assignment = await assignmentRepository.findByClassAndId(cls, id);
if (!assignment) {
return null;
}
await assignmentRepository.deleteByClassAndId(cls, id);
return mapToAssignmentDTO(assignment);
}
@ -68,19 +88,7 @@ export async function getAssignmentsSubmissions(
assignmentNumber: number,
full: boolean
): Promise<SubmissionDTO[] | SubmissionDTOId[]> {
const classRepository = getClassRepository();
const cls = await classRepository.findById(classid);
if (!cls) {
return [];
}
const assignmentRepository = getAssignmentRepository();
const assignment = await assignmentRepository.findByClassAndId(cls, assignmentNumber);
if (!assignment) {
return [];
}
const assignment = await fetchAssignment(classid, assignmentNumber);
const groupRepository = getGroupRepository();
const groups = await groupRepository.findAllGroupsForAssignment(assignment);
@ -94,3 +102,16 @@ export async function getAssignmentsSubmissions(
return submissions.map(mapToSubmissionDTOId);
}
export async function getAssignmentsQuestions(classid: string, assignmentNumber: number, full: boolean): Promise<QuestionDTO[] | QuestionId[]> {
const assignment = await fetchAssignment(classid, assignmentNumber);
const questionRepository = getQuestionRepository();
const questions = await questionRepository.findAllByAssignment(assignment);
if (full) {
return questions.map(mapToQuestionDTO);
}
return questions.map(mapToQuestionDTO);
}

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

@ -1,22 +1,25 @@
import { getClassRepository, getStudentRepository, getTeacherInvitationRepository, getTeacherRepository } from '../data/repositories.js';
import { getClassRepository, getTeacherInvitationRepository } from '../data/repositories.js';
import { mapToClassDTO } from '../interfaces/class.js';
import { mapToStudentDTO } from '../interfaces/student.js';
import { mapToTeacherInvitationDTO, mapToTeacherInvitationDTOIds } from '../interfaces/teacher-invitation.js';
import { getLogger } from '../logging/initalize.js';
import { NotFoundException } from '../exceptions/not-found-exception.js';
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.js';
import { fetchStudent } from './students.js';
import { TeacherDTO } from '@dwengo-1/common/interfaces/teacher';
import { mapToTeacherDTO } from '../interfaces/teacher.js';
import { EntityDTO } from '@mikro-orm/core';
import { putObject } from './service-helper.js';
const logger = getLogger();
export async function fetchClass(classId: string): Promise<Class> {
export async function fetchClass(classid: string): Promise<Class> {
const classRepository = getClassRepository();
const cls = await classRepository.findById(classId);
const cls = await classRepository.findById(classid);
if (!cls) {
throw new NotFoundException('Class with id not found');
throw new NotFoundException('Class not found');
}
return cls;
@ -24,11 +27,7 @@ export async function fetchClass(classId: string): Promise<Class> {
export async function getAllClasses(full: boolean): Promise<ClassDTO[] | string[]> {
const classRepository = getClassRepository();
const classes = await classRepository.find({}, { populate: ['students', 'teachers'] });
if (!classes) {
return [];
}
const classes = await classRepository.findAll({ populate: ['students', 'teachers'] });
if (full) {
return classes.map(mapToClassDTO);
@ -36,74 +35,71 @@ export async function getAllClasses(full: boolean): Promise<ClassDTO[] | string[
return classes.map((cls) => cls.classId!);
}
export async function createClass(classData: ClassDTO): Promise<ClassDTO | null> {
const teacherRepository = getTeacherRepository();
const teacherUsernames = classData.teachers || [];
const teachers = (await Promise.all(teacherUsernames.map(async (id) => teacherRepository.findByUsername(id)))).filter(
(teacher) => teacher !== null
);
const studentRepository = getStudentRepository();
const studentUsernames = classData.students || [];
const students = (await Promise.all(studentUsernames.map(async (id) => studentRepository.findByUsername(id)))).filter(
(student) => student !== null
);
const classRepository = getClassRepository();
try {
const newClass = classRepository.create({
displayName: classData.displayName,
teachers: teachers,
students: students,
});
await classRepository.save(newClass);
return mapToClassDTO(newClass);
} catch (e) {
logger.error(e);
return null;
}
export async function getClass(classId: string): Promise<ClassDTO> {
const cls = await fetchClass(classId);
return mapToClassDTO(cls);
}
export async function getClass(classId: string): Promise<ClassDTO | null> {
const classRepository = getClassRepository();
const cls = await classRepository.findById(classId);
export async function createClass(classData: ClassDTO): Promise<ClassDTO> {
const teacherUsernames = classData.teachers || [];
const teachers = await Promise.all(teacherUsernames.map(async (id) => fetchTeacher(id)));
if (!cls) {
return null;
}
const studentUsernames = classData.students || [];
const students = await Promise.all(studentUsernames.map(async (id) => fetchStudent(id)));
const classRepository = getClassRepository();
const newClass = classRepository.create({
displayName: classData.displayName,
teachers: teachers,
students: students,
});
await classRepository.save(newClass, { preventOverwrite: true });
return mapToClassDTO(newClass);
}
export async function putClass(classId: string, classData: Partial<EntityDTO<Class>>): Promise<ClassDTO> {
const cls = await fetchClass(classId);
await putObject<Class>(cls, classData, getClassRepository());
return mapToClassDTO(cls);
}
async function fetchClassStudents(classId: string): Promise<StudentDTO[]> {
export async function deleteClass(classId: string): Promise<ClassDTO> {
const cls = await fetchClass(classId);
const classRepository = getClassRepository();
const cls = await classRepository.findById(classId);
await classRepository.deleteById(classId);
if (!cls) {
return [];
return mapToClassDTO(cls);
}
export async function getClassStudents(classId: string, full: boolean): Promise<StudentDTO[] | string[]> {
const cls = await fetchClass(classId);
if (full) {
return cls.students.map(mapToStudentDTO);
}
return cls.students.map((student) => student.username);
}
export async function getClassStudentsDTO(classId: string): Promise<StudentDTO[]> {
const cls = await fetchClass(classId);
return cls.students.map(mapToStudentDTO);
}
export async function getClassStudents(classId: string): Promise<StudentDTO[]> {
return await fetchClassStudents(classId);
}
export async function getClassTeachers(classId: string, full: boolean): Promise<TeacherDTO[] | string[]> {
const cls = await fetchClass(classId);
export async function getClassStudentsIds(classId: string): Promise<string[]> {
const students: StudentDTO[] = await fetchClassStudents(classId);
return students.map((student) => student.username);
if (full) {
return cls.teachers.map(mapToTeacherDTO);
}
return cls.teachers.map((student) => student.username);
}
export async function getClassTeacherInvitations(classId: string, full: boolean): Promise<TeacherInvitationDTO[]> {
const classRepository = getClassRepository();
const cls = await classRepository.findById(classId);
if (!cls) {
return [];
}
const cls = await fetchClass(classId);
const teacherInvitationRepository = getTeacherInvitationRepository();
const invitations = await teacherInvitationRepository.findAllInvitationsForClass(cls);
@ -114,3 +110,41 @@ export async function getClassTeacherInvitations(classId: string, full: boolean)
return invitations.map(mapToTeacherInvitationDTOIds);
}
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>(cls, newStudents, getClassRepository());
return mapToClassDTO(cls);
}
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>(cls, newTeachers, getClassRepository());
return mapToClassDTO(cls);
}
export async function addClassStudent(classId: string, username: string): Promise<ClassDTO> {
const cls = await fetchClass(classId);
const newStudent = await fetchStudent(username);
const newStudents = { students: [...cls.students, newStudent] };
await putObject<Class>(cls, newStudents, getClassRepository());
return mapToClassDTO(cls);
}
export async function addClassTeacher(classId: string, username: string): Promise<ClassDTO> {
const cls = await fetchClass(classId);
const newTeacher = await fetchTeacher(username);
const newTeachers = { teachers: [...cls.teachers, newTeacher] };
await putObject<Class>(cls, newTeachers, getClassRepository());
return mapToClassDTO(cls);
}

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

@ -1,105 +1,90 @@
import {
getAssignmentRepository,
getClassRepository,
getGroupRepository,
getStudentRepository,
getSubmissionRepository,
} from '../data/repositories.js';
import { EntityDTO } from '@mikro-orm/core';
import { getGroupRepository, getStudentRepository, getSubmissionRepository } from '../data/repositories.js';
import { Group } from '../entities/assignments/group.entity.js';
import { mapToGroupDTO, mapToShallowGroupDTO } from '../interfaces/group.js';
import { mapToSubmissionDTO, mapToSubmissionDTOId } from '../interfaces/submission.js';
import { GroupDTO } from '@dwengo-1/common/interfaces/group';
import { SubmissionDTO, SubmissionDTOId } from '@dwengo-1/common/interfaces/submission';
import { getLogger } from '../logging/initalize.js';
import { fetchAssignment } from './assignments.js';
import { NotFoundException } from '../exceptions/not-found-exception.js';
import { putObject } from './service-helper.js';
export async function getGroup(classId: string, assignmentNumber: number, groupNumber: number, full: boolean): Promise<GroupDTO | null> {
const classRepository = getClassRepository();
const cls = await classRepository.findById(classId);
if (!cls) {
return null;
}
const assignmentRepository = getAssignmentRepository();
const assignment = await assignmentRepository.findByClassAndId(cls, assignmentNumber);
if (!assignment) {
return null;
}
export async function fetchGroup(classId: string, assignmentNumber: number, groupNumber: number): Promise<Group> {
const assignment = await fetchAssignment(classId, assignmentNumber);
const groupRepository = getGroupRepository();
const group = await groupRepository.findByAssignmentAndGroupNumber(assignment, groupNumber);
if (!group) {
return null;
throw new NotFoundException('Could not find group');
}
if (full) {
return mapToGroupDTO(group);
}
return mapToShallowGroupDTO(group);
return group;
}
export async function createGroup(groupData: GroupDTO, classid: string, assignmentNumber: number): Promise<Group | null> {
export async function getGroup(classId: string, assignmentNumber: number, groupNumber: number): Promise<GroupDTO> {
const group = await fetchGroup(classId, assignmentNumber, groupNumber);
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);
const groupRepository = getGroupRepository();
await groupRepository.deleteByAssignmentAndGroupNumber(assignment, groupNumber);
return mapToGroupDTO(group);
}
export async function getExistingGroupFromGroupDTO(groupData: GroupDTO): Promise<Group> {
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);
}
export async function createGroup(groupData: GroupDTO, classid: string, assignmentNumber: number): Promise<GroupDTO> {
const studentRepository = getStudentRepository();
const memberUsernames = (groupData.members as string[]) || []; // TODO check if groupdata.members is a list
const memberUsernames = (groupData.members as string[]) || [];
const members = (await Promise.all([...memberUsernames].map(async (id) => studentRepository.findByUsername(id)))).filter(
(student) => student !== null
);
getLogger().debug(members);
const classRepository = getClassRepository();
const cls = await classRepository.findById(classid);
if (!cls) {
return null;
}
const assignmentRepository = getAssignmentRepository();
const assignment = await assignmentRepository.findByClassAndId(cls, assignmentNumber);
if (!assignment) {
return null;
}
const assignment = await fetchAssignment(classid, assignmentNumber);
const groupRepository = getGroupRepository();
try {
const newGroup = groupRepository.create({
assignment: assignment,
members: members,
});
await groupRepository.save(newGroup);
const newGroup = groupRepository.create({
assignment: assignment,
members: members,
});
await groupRepository.save(newGroup);
return newGroup;
} catch (e) {
getLogger().error(e);
return null;
}
return mapToGroupDTO(newGroup);
}
export async function getAllGroups(classId: string, assignmentNumber: number, full: boolean): Promise<GroupDTO[]> {
const classRepository = getClassRepository();
const cls = await classRepository.findById(classId);
if (!cls) {
return [];
}
const assignmentRepository = getAssignmentRepository();
const assignment = await assignmentRepository.findByClassAndId(cls, assignmentNumber);
if (!assignment) {
return [];
}
const assignment = await fetchAssignment(classId, assignmentNumber);
const groupRepository = getGroupRepository();
const groups = await groupRepository.findAllGroupsForAssignment(assignment);
if (full) {
getLogger().debug({ full: full, groups: groups });
return groups.map(mapToGroupDTO);
}
@ -112,26 +97,7 @@ export async function getGroupSubmissions(
groupNumber: number,
full: boolean
): Promise<SubmissionDTO[] | SubmissionDTOId[]> {
const classRepository = getClassRepository();
const cls = await classRepository.findById(classId);
if (!cls) {
return [];
}
const assignmentRepository = getAssignmentRepository();
const assignment = await assignmentRepository.findByClassAndId(cls, assignmentNumber);
if (!assignment) {
return [];
}
const groupRepository = getGroupRepository();
const group = await groupRepository.findByAssignmentAndGroupNumber(assignment, groupNumber);
if (!group) {
return [];
}
const group = await fetchGroup(classId, assignmentNumber, groupNumber);
const submissionRepository = getSubmissionRepository();
const submissions = await submissionRepository.findAllSubmissionsForGroup(group);

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

@ -1,23 +1,17 @@
import {
getAnswerRepository, getAssignmentRepository,
getClassRepository,
getGroupRepository,
getQuestionRepository
} from '../data/repositories.js';
import {mapToLearningObjectID, mapToQuestionDTO, mapToQuestionDTOId} from '../interfaces/question.js';
import { getAnswerRepository, getAssignmentRepository, getClassRepository, getGroupRepository, getQuestionRepository } from '../data/repositories.js';
import { mapToLearningObjectID, mapToQuestionDTO, mapToQuestionDTOId } from '../interfaces/question.js';
import { Question } from '../entities/questions/question.entity.js';
import { Answer } from '../entities/questions/answer.entity.js';
import { mapToAnswerDTO, mapToAnswerDTOId } from '../interfaces/answer.js';
import { QuestionRepository } from '../data/questions/question-repository.js';
import { LearningObjectIdentifier } from '../entities/content/learning-object-identifier.js';
import { mapToStudent } from '../interfaces/student.js';
import {QuestionData, QuestionDTO, QuestionId} from '@dwengo-1/common/interfaces/question';
import { QuestionData, QuestionDTO, QuestionId } from '@dwengo-1/common/interfaces/question';
import { AnswerDTO, AnswerId } from '@dwengo-1/common/interfaces/answer';
import {fetchStudent} from "./students";
import {mapToAssignment} from "../interfaces/assignment";
import { NotFoundException } from '../exceptions/not-found-exception.js';
import {AssignmentDTO} from "@dwengo-1/common/interfaces/assignment";
import {FALLBACK_VERSION_NUM} from "../config";
import { mapToAssignment } from '../interfaces/assignment.js';
import { AssignmentDTO } from '@dwengo-1/common/interfaces/assignment';
import { fetchStudent } from './students.js';
import { NotFoundException } from '../exceptions/not-found-exception';
import { FALLBACK_VERSION_NUM } from '../config.js';
export async function getQuestionsAboutLearningObjectInAssignment(
loId: LearningObjectIdentifier,
@ -92,14 +86,14 @@ export async function createQuestion(loId: LearningObjectIdentifier, questionDat
const author = await fetchStudent(questionData.author!);
const content = questionData.content;
const clazz = await getClassRepository().findById((questionData.inGroup.assignment as AssignmentDTO).class);
const clazz = await getClassRepository().findById((questionData.inGroup.assignment as AssignmentDTO).within);
const assignment = mapToAssignment(questionData.inGroup.assignment as AssignmentDTO, clazz!);
const inGroup = (await getGroupRepository().findByAssignmentAndGroupNumber(assignment, questionData.inGroup.groupNumber))!;
const inGroup = await getGroupRepository().findByAssignmentAndGroupNumber(assignment, questionData.inGroup.groupNumber);
const question = await questionRepository.createQuestion({
loId,
inGroup,
author,
inGroup: inGroup!,
content,
});

20
backend/src/services/service-helper.ts Normal file
View file

@ -0,0 +1,20 @@
import { EntityDTO, FromEntityType } from '@mikro-orm/core';
import { DwengoEntityRepository } from '../data/dwengo-entity-repository';
/**
* Utility function to perform an PUT on an object.
*
* @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>(
object: T,
data: Partial<EntityDTO<FromEntityType<T>>>,
repo: DwengoEntityRepository<T>
): Promise<void> {
repo.assign(object, data);
await repo.getEntityManager().flush();
}

5
backend/src/services/students.ts
View file

@ -23,6 +23,7 @@ import { GroupDTO } from '@dwengo-1/common/interfaces/group';
import { SubmissionDTO, SubmissionDTOId } from '@dwengo-1/common/interfaces/submission';
import { QuestionDTO, QuestionId } from '@dwengo-1/common/interfaces/question';
import { ClassJoinRequestDTO } from '@dwengo-1/common/interfaces/class-join-request';
import { ConflictException } from '../exceptions/conflict-exception.js';
import { Submission } from '../entities/assignments/submission.entity';
export async function getAllStudents(full: boolean): Promise<StudentDTO[] | string[]> {
@ -137,6 +138,10 @@ export async function createClassJoinRequest(username: string, classId: string):
const student = await fetchStudent(username); // Throws error if student not found
const cls = await fetchClass(classId);
if (cls.students.contains(student)) {
throw new ConflictException('Student already in this class');
}
const request = mapToStudentRequest(student, cls);
await requestRepo.save(request, { preventOverwrite: true });
return mapToStudentRequestDTO(request);

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

@ -1,61 +1,56 @@
import { getAssignmentRepository, 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';
import { SubmissionDTO } from '@dwengo-1/common/interfaces/submission';
import { fetchStudent } from './students.js';
import { getExistingGroupFromGroupDTO } from './groups.js';
import { Submission } from '../entities/assignments/submission.entity.js';
import { Language } from '@dwengo-1/common/util/language';
export async function getSubmission(
learningObjectHruid: string,
language: Language,
version: number,
submissionNumber: number
): Promise<SubmissionDTO | null> {
const loId = new LearningObjectIdentifier(learningObjectHruid, language, version);
export async function fetchSubmission(loId: LearningObjectIdentifier, submissionNumber: number): Promise<Submission> {
const submissionRepository = getSubmissionRepository();
const submission = await submissionRepository.findSubmissionByLearningObjectAndSubmissionNumber(loId, submissionNumber);
if (!submission) {
return null;
throw new NotFoundException('Could not find submission');
}
return mapToSubmissionDTO(submission);
}
export async function createSubmission(submissionDTO: SubmissionDTO): Promise<SubmissionDTO | null> {
const submissionRepository = getSubmissionRepository();
const submission = mapToSubmission(submissionDTO);
try {
const newSubmission = submissionRepository.create(submission);
await submissionRepository.save(newSubmission);
} catch (_) {
return null;
}
return mapToSubmissionDTO(submission);
}
export async function deleteSubmission(
learningObjectHruid: string,
language: Language,
version: number,
submissionNumber: number
): Promise<SubmissionDTO | null> {
const submissionRepository = getSubmissionRepository();
const submission = getSubmission(learningObjectHruid, language, version, submissionNumber);
if (!submission) {
return null;
}
const loId = new LearningObjectIdentifier(learningObjectHruid, language, version);
await submissionRepository.deleteSubmissionByLearningObjectAndSubmissionNumber(loId, submissionNumber);
return submission;
}
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[]> {
const submissionRepository = getSubmissionRepository();
const submissions = await submissionRepository.findByLearningObject(loId);
return submissions.map(mapToSubmissionDTO);
}
export async function createSubmission(submissionDTO: SubmissionDTO): Promise<SubmissionDTO> {
const submitter = await fetchStudent(submissionDTO.submitter.username);
const group = await getExistingGroupFromGroupDTO(submissionDTO.group);
const submissionRepository = getSubmissionRepository();
const submission = mapToSubmission(submissionDTO, submitter, group);
await submissionRepository.save(submission);
return mapToSubmissionDTO(submission);
}
export async function deleteSubmission(loId: LearningObjectIdentifier, submissionNumber: number): Promise<SubmissionDTO> {
const submission = await fetchSubmission(loId, submissionNumber);
const submissionRepository = getSubmissionRepository();
await submissionRepository.deleteSubmissionByLearningObjectAndSubmissionNumber(loId, submissionNumber);
return mapToSubmissionDTO(submission);
}
/**
* Returns all the submissions made by on behalf of any group the given student is in.
*/

87
backend/src/services/teacher-invitations.ts Normal file
View file

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

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

@ -22,13 +22,14 @@ 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 } from './classes.js';
import { addClassStudent, fetchClass, 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';
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[]> {
const teacherRepository: TeacherRepository = getTeacherRepository();
@ -99,10 +100,12 @@ export async function getStudentsByTeacher(username: string, full: boolean): Pro
const classIds: string[] = classes.map((cls) => cls.id);
const students: StudentDTO[] = (await Promise.all(classIds.map(async (id) => getClassStudents(id)))).flat();
const students: StudentDTO[] = (await Promise.all(classIds.map(async (username) => await getClassStudentsDTO(username)))).flat();
if (full) {
return students;
}
return students.map((student) => student.username);
}
@ -143,13 +146,12 @@ export async function getJoinRequestsByClass(classId: string): Promise<ClassJoin
export async function updateClassJoinRequestStatus(studentUsername: string, classId: string, accepted = true): Promise<ClassJoinRequestDTO> {
const requestRepo: ClassJoinRequestRepository = getClassJoinRequestRepository();
const classRepo: ClassRepository = getClassRepository();
const student: Student = await fetchStudent(studentUsername);
const cls: Class | null = await classRepo.findById(classId);
const cls = await fetchClass(classId);
if (!cls) {
throw new NotFoundException('Class not found');
if (cls.students.contains(student)) {
throw new ConflictException('Student already in this class');
}
const request: ClassJoinRequest | null = await requestRepo.findByStudentAndClass(student, cls);
@ -158,8 +160,14 @@ export async function updateClassJoinRequestStatus(studentUsername: string, clas
throw new NotFoundException('Join request not found');
}
request.status = accepted ? ClassJoinRequestStatus.Accepted : ClassJoinRequestStatus.Declined;
request.status = ClassStatus.Declined;
if (accepted) {
request.status = ClassStatus.Accepted;
await addClassStudent(classId, studentUsername);
}
await requestRepo.save(request);
return mapToStudentRequestDTO(request);
}