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

feat: assignment/questions endpoint toegevoegd

Browse source
This commit is contained in:
Adriaan Jacquet 2025-03-30 19:24:52 +02:00
parent 136dcb4c71
commit 62711f323d
7 changed files with 82 additions and 80 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -1,5 +1,5 @@
import { Request, Response } from 'express';
import { createClass, getAllClasses, getClass, getClassStudents, getClassStudentsIds, getClassTeacherInvitations } from '../services/classes.js';
import { createClass, getAllClasses, getClass, getClassStudents, getClassTeacherInvitations } from '../services/classes.js';
import { ClassDTO } from '../interfaces/class.js';
export async function getAllClassesHandler(req: Request, res: Response): Promise<void> {
@ -47,7 +47,7 @@ export async function getClassStudentsHandler(req: Request, res: Response): Prom
const classId = req.params.id;
const full = req.query.full === 'true';
const students = full ? await getClassStudents(classId) : await getClassStudentsIds(classId);
const students = getClassStudents(classId, full);
res.json({
students: students,

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

@ -12,6 +12,7 @@ interface GroupParams {
export async function getGroupHandler(req: Request<GroupParams>, res: Response): Promise<void> {
const classId = req.params.classid;
const full = req.query.full === 'true';
const assignmentId = +req.params.assignmentid;
if (isNaN(assignmentId)) {

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

@ -3,6 +3,7 @@ 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 { Assignment } from '../../entities/assignments/assignment.entity.js';
export class QuestionRepository extends DwengoEntityRepository<Question> {
public createQuestion(question: { loId: LearningObjectIdentifier; author: Student; content: string }): Promise<Question> {
@ -54,4 +55,12 @@ export class QuestionRepository extends DwengoEntityRepository<Question> {
orderBy: { timestamp: 'ASC' },
});
}
public findAllByAssignment(assignment: Assignment): Promise<Question[]> {
return this.find({
author: assignment.groups.flatMap(group => group.members),
learningObjectHruid: assignment.learningPathHruid,
learningObjectLanguage: assignment.learningPathLanguage,
});
}
}

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

@ -11,13 +11,6 @@ router.post('/', createGroupHandler);
// Information about a group (members, ... [TODO DOC])
router.get('/:groupid', getGroupHandler);
router.get('/:groupid', getGroupSubmissionsHandler);
// The list of questions a group has made
router.get('/:id/questions', (req, res) => {
res.json({
questions: ['0'],
});
});
router.get('/:groupid/submissions', getGroupSubmissionsHandler);
export default router;

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

@ -1,7 +1,23 @@
import { getAssignmentRepository, getClassRepository, getGroupRepository, getSubmissionRepository } from '../data/repositories.js';
import { getAssignmentRepository, getClassRepository, getGroupRepository, getQuestionRepository, getSubmissionRepository } from '../data/repositories.js';
import { Assignment } from '../entities/assignments/assignment.entity.js';
import { AssignmentDTO, mapToAssignment, mapToAssignmentDTO, mapToAssignmentDTOId } from '../interfaces/assignment.js';
import { mapToQuestionDTO, mapToQuestionId, QuestionDTO, QuestionId } from '../interfaces/question.js';
import { mapToSubmissionDTO, mapToSubmissionDTOId, SubmissionDTO, SubmissionDTOId } from '../interfaces/submission.js';
export async function fetchAssignment(classid: string, assignmentNumber: number): Promise<Assignment | null> {
const classRepository = getClassRepository();
const cls = await classRepository.findById(classid);
if (!cls) {
return null;
}
const assignmentRepository = getAssignmentRepository();
const assignment = await assignmentRepository.findByClassAndId(cls, assignmentNumber);
return assignment;
}
export async function getAllAssignments(classid: string, full: boolean): Promise<AssignmentDTO[]> {
const classRepository = getClassRepository();
const cls = await classRepository.findById(classid);
@ -43,15 +59,7 @@ export async function createAssignment(classid: string, assignmentData: Assignme
}
export async function getAssignment(classid: string, id: number): Promise<AssignmentDTO | null> {
const classRepository = getClassRepository();
const cls = await classRepository.findById(classid);
if (!cls) {
return null;
}
const assignmentRepository = getAssignmentRepository();
const assignment = await assignmentRepository.findByClassAndId(cls, id);
const assignment = await fetchAssignment(classid, id);
if (!assignment) {
return null;
@ -65,15 +73,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);
const assignment = await fetchAssignment(classid, assignmentNumber);
if (!assignment) {
return [];
@ -91,3 +91,24 @@ 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);
if (!assignment) {
return [];
}
const questionRepository = getQuestionRepository();
const questions = await questionRepository.findAllByAssignment(assignment);
if (full) {
return questions.map(mapToQuestionDTO);
}
return questions.map(mapToQuestionDTO).map(mapToQuestionId); // mapToQuestionId should be updated
}

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

@ -1,4 +1,5 @@
import { getClassRepository, getStudentRepository, getTeacherInvitationRepository, getTeacherRepository } from '../data/repositories.js';
import { Class } from '../entities/classes/class.entity.js';
import { ClassDTO, mapToClassDTO } from '../interfaces/class.js';
import { mapToStudentDTO, StudentDTO } from '../interfaces/student.js';
import { mapToTeacherInvitationDTO, mapToTeacherInvitationDTOIds, TeacherInvitationDTO } from '../interfaces/teacher-invitation.js';
@ -6,6 +7,13 @@ import { getLogger } from '../logging/initalize.js';
const logger = getLogger();
async function fetchClass(classid: string): Promise<Class | null> {
const classRepository = getClassRepository();
const cls = await classRepository.findById(classid);
return cls;
}
export async function getAllClasses(full: boolean): Promise<ClassDTO[] | string[]> {
const classRepository = getClassRepository();
const classes = await classRepository.find({}, { populate: ['students', 'teachers'] });
@ -47,8 +55,7 @@ export async function createClass(classData: ClassDTO): Promise<ClassDTO | null>
}
export async function getClass(classId: string): Promise<ClassDTO | null> {
const classRepository = getClassRepository();
const cls = await classRepository.findById(classId);
const cls = await fetchClass(classId);
if (!cls) {
return null;
@ -57,24 +64,18 @@ export async function getClass(classId: string): Promise<ClassDTO | null> {
return mapToClassDTO(cls);
}
async function fetchClassStudents(classId: string): Promise<StudentDTO[]> {
const classRepository = getClassRepository();
const cls = await classRepository.findById(classId);
export async function getClassStudents(classId: string, full: boolean): Promise<StudentDTO[] | string[]> {
const cls = await fetchClass(classId);
if (!cls) {
return [];
}
return cls.students.map(mapToStudentDTO);
}
if (full) {
return cls.students.map(mapToStudentDTO);
}
export async function getClassStudents(classId: string): Promise<StudentDTO[]> {
return await fetchClassStudents(classId);
}
export async function getClassStudentsIds(classId: string): Promise<string[]> {
const students: StudentDTO[] = await fetchClassStudents(classId);
return students.map((student) => student.username);
return cls.students.map((student) => student.username);
}
export async function getClassTeacherInvitations(classId: string, full: boolean): Promise<TeacherInvitationDTO[]> {

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

@ -1,24 +1,20 @@
import { assign } from '@mikro-orm/core';
import {
getAssignmentRepository,
getClassRepository,
getGroupRepository,
getQuestionRepository,
getStudentRepository,
getSubmissionRepository,
} from '../data/repositories.js';
import { Group } from '../entities/assignments/group.entity.js';
import { GroupDTO, mapToGroupDTO, mapToGroupDTOId } from '../interfaces/group.js';
import { mapToSubmissionDTO, mapToSubmissionDTOId, SubmissionDTO, SubmissionDTOId } from '../interfaces/submission.js';
import { fetchAssignment } from './assignments.js';
import { mapToQuestionDTO, mapToQuestionId, QuestionDTO, QuestionId } from '../interfaces/question.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);
async function fetchGroup(classId: string, assignmentNumber: number, groupNumber: number): Promise<Group | null> {
const assignment = await fetchAssignment(classId, assignmentNumber);
if (!assignment) {
return null;
@ -27,6 +23,12 @@ export async function getGroup(classId: string, assignmentNumber: number, groupN
const groupRepository = getGroupRepository();
const group = await groupRepository.findByAssignmentAndGroupNumber(assignment, groupNumber);
return group;
}
export async function getGroup(classId: string, assignmentNumber: number, groupNumber: number, full: boolean): Promise<GroupDTO | null> {
const group = await fetchGroup(classId, assignmentNumber, groupNumber);
if (!group) {
return null;
}
@ -76,15 +78,7 @@ export async function createGroup(groupData: GroupDTO, classid: string, assignme
}
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);
const assignment = await fetchAssignment(classId, assignmentNumber);
if (!assignment) {
return [];
@ -94,8 +88,6 @@ export async function getAllGroups(classId: string, assignmentNumber: number, fu
const groups = await groupRepository.findAllGroupsForAssignment(assignment);
if (full) {
console.log('full');
console.log(groups);
return groups.map(mapToGroupDTO);
}
@ -108,22 +100,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);
const group = await fetchGroup(classId, assignmentNumber, groupNumber);
if (!group) {
return [];