feat: questions via student

backend/src/controllers/students.ts

@@ -1,53 +1,43 @@
 import { Request, Response } from 'express';
 import {
     createStudent,
-    deleteStudent,
+    deleteStudent, getAllStudentIds,
     getAllStudents,
     getStudent,
     getStudentAssignments,
     getStudentClasses,
-    getStudentGroups,
+    getStudentGroups, getStudentQuestions,
     getStudentSubmissions,
 } from '../services/students.js';
-import { ClassDTO } from '../interfaces/class.js';
+import {MISSING_FIELDS_ERROR, MISSING_USERNAME_ERROR, NAME_NOT_FOUND_ERROR} from './users.js';
-import { getAllAssignments } from '../services/assignments.js';
-import { getUserHandler } from './users.js';
-import { Student } from '../entities/users/student.entity.js';
 import { StudentDTO } from '../interfaces/student.js';
-import { getStudentRepository } from '../data/repositories.js';
-import { UserDTO } from '../interfaces/user.js';
 
-// TODO: accept arguments (full, ...)
+
-// TODO: endpoints
 export async function getAllStudentsHandler(req: Request, res: Response): Promise<void> {
     const full = req.query.full === 'true';
 
-    const studentRepository = getStudentRepository();
+    const students: StudentDTO[] | string[] = full ? await getAllStudents() : await getAllStudentIds();
-
-    const students: StudentDTO[] | string[] = full ? await getAllStudents() : await getAllStudents();
 
     if (!students) {
-        res.status(404).json({ error: `Student not found.` });
+        res.status(404).json({ error: `Students not found.` });
         return;
     }
 
-    res.status(201).json(students);
+    res.json({students});
 }
 
 export async function getStudentHandler(req: Request, res: Response): Promise<void> {
     const username = req.params.username;
 
     if (!username) {
-        res.status(400).json({ error: 'Missing required field: username' });
+        res.status(400).json(MISSING_USERNAME_ERROR);
         return;
     }
 
     const user = await getStudent(username);
 
     if (!user) {
-        res.status(404).json({
+        res.status(404).json(NAME_NOT_FOUND_ERROR(username));
-            error: `User with username '${username}' not found.`,
-        });
         return;
     }
 
@@ -58,9 +48,7 @@ export async function createStudentHandler(req: Request, res: Response) {
     const userData = req.body as StudentDTO;
 
     if (!userData.username || !userData.firstName || !userData.lastName) {
-        res.status(400).json({
+        res.status(400).json(MISSING_FIELDS_ERROR);
-            error: 'Missing required fields: username, firstName, lastName',
-        });
         return;
     }
 
@@ -72,15 +60,13 @@ export async function deleteStudentHandler(req: Request, res: Response) {
     const username = req.params.username;
 
     if (!username) {
-        res.status(400).json({ error: 'Missing required field: username' });
+        res.status(400).json(MISSING_USERNAME_ERROR);
         return;
     }
 
     const deletedUser = await deleteStudent(username);
     if (!deletedUser) {
-        res.status(404).json({
+        res.status(404).json(NAME_NOT_FOUND_ERROR(username));
-            error: `User with username '${username}' not found.`,
-        });
         return;
     }
 
@@ -88,25 +74,19 @@ export async function deleteStudentHandler(req: Request, res: Response) {
 }
 
 export async function getStudentClassesHandler(req: Request, res: Response): Promise<void> {
-    try {
     const full = req.query.full === 'true';
-        const username = req.params.id;
+    const username = req.params.username;
+
+    if (!username) {
+        res.status(400).json(MISSING_USERNAME_ERROR);
+        return;
+    }
 
     const classes = await getStudentClasses(username, full);
 
     res.json({
-            classes: classes,
+        classes,
-            endpoints: {
-                self: `${req.baseUrl}/${req.params.id}`,
-                classes: `${req.baseUrl}/${req.params.id}/invitations`,
-                questions: `${req.baseUrl}/${req.params.id}/assignments`,
-                students: `${req.baseUrl}/${req.params.id}/students`,
-            },
     });
-    } catch (error) {
-        console.error('Error fetching learning objects:', error);
-        res.status(500).json({ error: 'Internal server error' });
-    }
 }
 
 // TODO
@@ -115,32 +95,62 @@ export async function getStudentClassesHandler(req: Request, res: Response): Pro
 // Have this assignment.
 export async function getStudentAssignmentsHandler(req: Request, res: Response): Promise<void> {
     const full = req.query.full === 'true';
-    const username = req.params.id;
+    const username = req.params.username;
+
+    if (!username) {
+        res.status(400).json(MISSING_USERNAME_ERROR);
+        return;
+    }
 
     const assignments = getStudentAssignments(username, full);
 
     res.json({
-        assignments: assignments,
+        assignments,
     });
 }
 
 export async function getStudentGroupsHandler(req: Request, res: Response): Promise<void> {
     const full = req.query.full === 'true';
-    const username = req.params.id;
+    const username = req.params.username;
+
+    if (!username) {
+        res.status(400).json(MISSING_USERNAME_ERROR);
+        return;
+    }
 
     const groups = await getStudentGroups(username, full);
 
     res.json({
-        groups: groups,
+        groups,
     });
 }
 
 export async function getStudentSubmissionsHandler(req: Request, res: Response): Promise<void> {
-    const username = req.params.id;
+    const username = req.params.username;
+
+    if (!username) {
+        res.status(400).json(MISSING_USERNAME_ERROR);
+        return;
+    }
 
     const submissions = await getStudentSubmissions(username);
 
     res.json({
-        submissions: submissions,
+        submissions,
     });
 }
+
+export async function getStudentQuestionsHandler(req: Request, res: Response): Promise<void> {
+    const username = req.params.username;
+
+    if (!username) {
+        res.status(400).json(MISSING_USERNAME_ERROR);
+        return;
+    }
+
+    const questions = await getStudentQuestions(username, full);
+
+    res.json({
+        questions,
+    })
+}

backend/src/controllers/teachers.ts

@@ -4,49 +4,40 @@ import {
     deleteTeacher,
     getAllTeachers,
     getClassesByTeacher,
-    getClassIdsByTeacher,
-    getQuestionIdsByTeacher,
-    getQuestionsByTeacher,
-    getStudentIdsByTeacher,
     getStudentsByTeacher,
     getTeacher,
 } from '../services/teachers.js';
 import { ClassDTO } from '../interfaces/class.js';
 import { StudentDTO } from '../interfaces/student.js';
 import { QuestionDTO, QuestionId } from '../interfaces/question.js';
-import { Teacher } from '../entities/users/teacher.entity.js';
 import { TeacherDTO } from '../interfaces/teacher.js';
-import { getTeacherRepository } from '../data/repositories.js';
+import {MISSING_FIELDS_ERROR, MISSING_USERNAME_ERROR, NAME_NOT_FOUND_ERROR} from "./users";
 
 export async function getAllTeachersHandler(req: Request, res: Response): Promise<void> {
     const full = req.query.full === 'true';
 
-    const teacherRepository = getTeacherRepository();
+    const teachers: TeacherDTO[] | string[] = await getAllTeachers(full);
-
-    const teachers: TeacherDTO[] | string[] = full ? await getAllTeachers() : await getAllTeachers();
 
     if (!teachers) {
-        res.status(404).json({ error: `Teacher not found.` });
+        res.status(404).json({ error: `Teachers not found.` });
         return;
     }
 
-    res.status(201).json(teachers);
+    res.json({teachers});
 }
 
 export async function getTeacherHandler(req: Request, res: Response): Promise<void> {
     const username = req.params.username;
 
     if (!username) {
-        res.status(400).json({ error: 'Missing required field: username' });
+        res.status(400).json(MISSING_USERNAME_ERROR);
         return;
     }
 
     const user = await getTeacher(username);
 
     if (!user) {
-        res.status(404).json({
+        res.status(404).json(NAME_NOT_FOUND_ERROR(username));
-            error: `User with username '${username}' not found.`,
-        });
         return;
     }
 
@@ -57,9 +48,7 @@ export async function createTeacherHandler(req: Request, res: Response) {
     const userData = req.body as TeacherDTO;
 
     if (!userData.username || !userData.firstName || !userData.lastName) {
-        res.status(400).json({
+        res.status(400).json(MISSING_FIELDS_ERROR);
-            error: 'Missing required fields: username, firstName, lastName',
-        });
         return;
     }
 
@@ -71,15 +60,13 @@ export async function deleteTeacherHandler(req: Request, res: Response) {
     const username = req.params.username;
 
     if (!username) {
-        res.status(400).json({ error: 'Missing required field: username' });
+        res.status(400).json(MISSING_USERNAME_ERROR);
         return;
     }
 
     const deletedUser = await deleteTeacher(username);
     if (!deletedUser) {
-        res.status(404).json({
+        res.status(404).json(NAME_NOT_FOUND_ERROR(username));
-            error: `User with username '${username}' not found.`,
-        });
         return;
     }
 
@@ -87,58 +74,43 @@ export async function deleteTeacherHandler(req: Request, res: Response) {
 }
 
 export async function getTeacherClassHandler(req: Request, res: Response): Promise<void> {
-    try {
     const username = req.params.username as string;
     const full = req.query.full === 'true';
 
     if (!username) {
-            res.status(400).json({ error: 'Missing required field: username' });
+        res.status(400).json(MISSING_USERNAME_ERROR);
         return;
     }
 
-        const classes: ClassDTO[] | string[] = full ? await getClassesByTeacher(username) : await getClassIdsByTeacher(username);
+    const classes: ClassDTO[] | string[] = await getClassesByTeacher(username, full);
 
     res.status(201).json(classes);
-    } catch (error) {
-        console.error('Error fetching classes by teacher:', error);
-        res.status(500).json({ error: 'Internal server error' });
-    }
 }
 
 export async function getTeacherStudentHandler(req: Request, res: Response): Promise<void> {
-    try {
     const username = req.params.username as string;
     const full = req.query.full === 'true';
 
     if (!username) {
-            res.status(400).json({ error: 'Missing required field: username' });
+        res.status(400).json(MISSING_USERNAME_ERROR);
         return;
     }
 
-        const students: StudentDTO[] | string[] = full ? await getStudentsByTeacher(username) : await getStudentIdsByTeacher(username);
+    const students: StudentDTO[] | string[] = await getStudentsByTeacher(username, full);
 
-        res.status(201).json(students);
+    res.json({students});
-    } catch (error) {
-        console.error('Error fetching students by teacher:', error);
-        res.status(500).json({ error: 'Internal server error' });
-    }
 }
 
 export async function getTeacherQuestionHandler(req: Request, res: Response): Promise<void> {
-    try {
     const username = req.params.username as string;
     const full = req.query.full === 'true';
 
     if (!username) {
-            res.status(400).json({ error: 'Missing required field: username' });
+        res.status(400).json(MISSING_USERNAME_ERROR);
         return;
     }
 
-        const questions: QuestionDTO[] | QuestionId[] = full ? await getQuestionsByTeacher(username) : await getQuestionIdsByTeacher(username);
+    const questions: QuestionDTO[] | QuestionId[] = await getQuestionsByTeacher(username, full);
 
-        res.status(201).json(questions);
+    res.json({questions});
-    } catch (error) {
-        console.error('Error fetching questions by teacher:', error);
-        res.status(500).json({ error: 'Internal server error' });
-    }
 }

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

@@ -54,4 +54,12 @@ export class QuestionRepository extends DwengoEntityRepository<Question> {
             orderBy: { timestamp: 'ASC' },
         });
     }
+
+    public findAllByAuthor(author: Student): Promise<Question[]> {
+        return this.findAll({
+            where: { author },
+            orderBy: { timestamp: 'DESC' }, // new to old
+        });
+    }
+
 }

backend/src/routes/students.ts

@@ -6,7 +6,7 @@ import {
     getStudentAssignmentsHandler,
     getStudentClassesHandler,
     getStudentGroupsHandler,
-    getStudentHandler,
+    getStudentHandler, getStudentQuestionsHandler,
     getStudentSubmissionsHandler,
 } from '../controllers/students.js';
 import { getStudentGroups } from '../services/students.js';
@@ -17,30 +17,24 @@ router.get('/', getAllStudentsHandler);
 
 router.post('/', createStudentHandler);
 
-router.delete('/', deleteStudentHandler);
-
 router.delete('/:username', deleteStudentHandler);
 
 // Information about a student's profile
 router.get('/:username', getStudentHandler);
 
 // The list of classes a student is in
-router.get('/:id/classes', getStudentClassesHandler);
+router.get('/:username/classes', getStudentClassesHandler);
 
 // The list of submissions a student has made
-router.get('/:id/submissions', getStudentSubmissionsHandler);
+router.get('/:username/submissions', getStudentSubmissionsHandler);
 
 // The list of assignments a student has
-router.get('/:id/assignments', getStudentAssignmentsHandler);
+router.get('/:username/assignments', getStudentAssignmentsHandler);
 
 // The list of groups a student is in
-router.get('/:id/groups', getStudentGroupsHandler);
+router.get('/:username/groups', getStudentGroupsHandler);
 
 // A list of questions a user has created
-router.get('/:id/questions', (req, res) => {
+router.get('/:username/questions', getStudentQuestionsHandler);
-    res.json({
-        questions: ['0'],
-    });
-});
 
 export default router;

backend/src/routes/teachers.ts

@@ -15,8 +15,6 @@ router.get('/', getAllTeachersHandler);
 
 router.post('/', createTeacherHandler);
 
-router.delete('/', deleteTeacherHandler);
-
 router.get('/:username', getTeacherHandler);
 
 router.delete('/:username', deleteTeacherHandler);

backend/src/services/students.ts

@@ -1,13 +1,17 @@
-import { getClassRepository, getGroupRepository, getStudentRepository, getSubmissionRepository } from '../data/repositories.js';
+import {
-import { Class } from '../entities/classes/class.entity.js';
+    getClassRepository,
-import { Student } from '../entities/users/student.entity.js';
+    getGroupRepository,
+    getQuestionRepository,
+    getStudentRepository,
+    getSubmissionRepository
+} from '../data/repositories.js';
 import { AssignmentDTO } from '../interfaces/assignment.js';
 import { ClassDTO, mapToClassDTO } from '../interfaces/class.js';
 import { GroupDTO, mapToGroupDTO, mapToGroupDTOId } from '../interfaces/group.js';
 import { mapToStudent, mapToStudentDTO, StudentDTO } from '../interfaces/student.js';
 import { mapToSubmissionDTO, SubmissionDTO } from '../interfaces/submission.js';
 import { getAllAssignments } from './assignments.js';
-import { UserService } from './users.js';
+import {mapToQuestionDTO, mapToQuestionId, QuestionDTO, QuestionId} from "../interfaces/question";
 
 export async function getAllStudents(): Promise<StudentDTO[]> {
     const studentRepository = getStudentRepository();
@@ -88,9 +92,7 @@ export async function getStudentAssignments(username: string, full: boolean): Pr
     const classRepository = getClassRepository();
     const classes = await classRepository.findByStudent(student);
 
-    const assignments = (await Promise.all(classes.map(async (cls) => await getAllAssignments(cls.classId!, full)))).flat();
+    return (await Promise.all(classes.map(async (cls) => await getAllAssignments(cls.classId!, full)))).flat();
-
-    return assignments;
 }
 
 export async function getStudentGroups(username: string, full: boolean): Promise<GroupDTO[]> {
@@ -124,3 +126,20 @@ export async function getStudentSubmissions(username: string): Promise<Submissio
 
     return submissions.map(mapToSubmissionDTO);
 }
+
+export async function getStudentQuestions(username: string, full: boolean): Promise<QuestionDTO[] | QuestionId[]> {
+    const studentRepository = getStudentRepository();
+    const student = await studentRepository.findByUsername(username);
+
+    if (!student) {
+        return [];
+    }
+
+    const questionRepository = getQuestionRepository();
+    const questions = await questionRepository.findAllByAuthor(student);
+
+    if (full)
+        return questions.map(mapToQuestionDTO)
+
+    return questions.map(mapToQuestionId);
+}

backend/src/services/teachers.ts

@@ -5,23 +5,17 @@ import {
     getStudentRepository,
     getTeacherRepository,
 } from '../data/repositories.js';
-import { Teacher } from '../entities/users/teacher.entity.js';
 import { ClassDTO, mapToClassDTO } from '../interfaces/class.js';
 import { getClassStudents } from './class.js';
-import { StudentDTO } from '../interfaces/student.js';
+import { mapToQuestionDTO, mapToQuestionId, QuestionDTO } from '../interfaces/question.js';
-import { mapToQuestionDTO, mapToQuestionId, QuestionDTO, QuestionId } from '../interfaces/question.js';
-import { UserService } from './users.js';
-import { mapToUser } from '../interfaces/user.js';
 import { mapToTeacher, mapToTeacherDTO, TeacherDTO } from '../interfaces/teacher.js';
 
-export async function getAllTeachers(): Promise<TeacherDTO[]> {
+export async function getAllTeachers(full: boolean): Promise<TeacherDTO[]> {
     const teacherRepository = getTeacherRepository();
     const users = await teacherRepository.findAll();
-    return users.map(mapToTeacherDTO);
-}
 
-export async function getAllTeacherIds(): Promise<string[]> {
+    if (full)
-    const users = await getAllTeachers();
+        return users.map(mapToTeacherDTO);
     return users.map((user) => user.username);
 }
 
@@ -64,7 +58,7 @@ export async function deleteTeacher(username: string): Promise<TeacherDTO | null
     }
 }
 
-export async function fetchClassesByTeacher(username: string): Promise<ClassDTO[]> {
+async function fetchClassesByTeacher(username: string): Promise<ClassDTO[]> {
     const teacherRepository = getTeacherRepository();
     const teacher = await teacherRepository.findByUsername(username);
     if (!teacher) {
@@ -76,31 +70,24 @@ export async function fetchClassesByTeacher(username: string): Promise<ClassDTO[
     return classes.map(mapToClassDTO);
 }
 
-export async function getClassesByTeacher(username: string): Promise<ClassDTO[]> {
+export async function getClassesByTeacher(username: string, full: boolean): Promise<ClassDTO[] | string[]> {
-    return await fetchClassesByTeacher(username);
-}
-
-export async function getClassIdsByTeacher(username: string): Promise<string[]> {
     const classes = await fetchClassesByTeacher(username);
+
+    if (full)
+        return classes;
     return classes.map((cls) => cls.id);
 }
 
-export async function fetchStudentsByTeacher(username: string) {
+export async function getStudentsByTeacher(username: string, full: boolean) {
-    const classes = await getClassIdsByTeacher(username);
+    const classes = await getClassesByTeacher(username, false);
 
-    return (await Promise.all(classes.map(async (id) => getClassStudents(id)))).flat();
+    const students =  (await Promise.all(classes.map(async (id) => getClassStudents(id)))).flat();
-}
+    if (full)
-
+        return students
-export async function getStudentsByTeacher(username: string): Promise<StudentDTO[]> {
-    return await fetchStudentsByTeacher(username);
-}
-
-export async function getStudentIdsByTeacher(username: string): Promise<string[]> {
-    const students = await fetchStudentsByTeacher(username);
     return students.map((student) => student.username);
 }
 
-export async function fetchTeacherQuestions(username: string): Promise<QuestionDTO[]> {
+export async function getTeacherQuestions(username: string, full: boolean): Promise<QuestionDTO[]> {
     const teacherRepository = getTeacherRepository();
     const teacher = await teacherRepository.findByUsername(username);
     if (!teacher) {
@@ -115,15 +102,9 @@ export async function fetchTeacherQuestions(username: string): Promise<QuestionD
     const questionRepository = getQuestionRepository();
     const questions = await questionRepository.findAllByLearningObjects(learningObjects);
 
+    if (full)
         return questions.map(mapToQuestionDTO);
-}
-
-export async function getQuestionsByTeacher(username: string): Promise<QuestionDTO[]> {
-    return await fetchTeacherQuestions(username);
-}
-
-export async function getQuestionIdsByTeacher(username: string): Promise<QuestionId[]> {
-    const questions = await fetchTeacherQuestions(username);
 
     return questions.map(mapToQuestionId);
 }
+