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

feat: teacher kan student request aanpassen en oprvagen

Browse source
This commit is contained in:
Gabriellvl 2025-03-29 23:12:38 +01:00
parent 815858d02f
commit c8cff2e820
6 changed files with 136 additions and 139 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -1,13 +1,19 @@
import {
getClassJoinRequestRepository,
getClassRepository,
getLearningObjectRepository,
getQuestionRepository,
getQuestionRepository, getStudentRepository,
getTeacherRepository,
} from '../data/repositories.js';
import { ClassDTO, mapToClassDTO } from '../interfaces/class.js';
import { getClassStudents } from './class.js';
import {mapToQuestionDTO, mapToQuestionId, QuestionDTO, QuestionId} from '../interfaces/question.js';
import { mapToTeacher, mapToTeacherDTO, TeacherDTO } from '../interfaces/teacher.js';
import {ConflictException, NotFoundException} from "../exceptions";
import {Teacher} from "../entities/users/teacher.entity";
import {fetchStudent} from "./students";
import {ClassJoinRequestStatus} from "../entities/classes/class-join-request.entity";
import {mapToStudentRequestDTO} from "../interfaces/student-request";
export async function getAllTeachers(full: boolean): Promise<TeacherDTO[] | string[]> {
const teacherRepository = getTeacherRepository();
@ -19,51 +25,45 @@ export async function getAllTeachers(full: boolean): Promise<TeacherDTO[] | stri
return users.map((user) => user.username);
}
export async function getTeacher(username: string): Promise<TeacherDTO | null> {
const teacherRepository = getTeacherRepository();
const user = await teacherRepository.findByUsername(username);
return user ? mapToTeacherDTO(user) : null;
}
export async function createTeacher(userData: TeacherDTO): Promise<TeacherDTO | null> {
const teacherRepository = getTeacherRepository();
try {
const newTeacher = teacherRepository.create(mapToTeacher(userData));
await teacherRepository.save(newTeacher);
return mapToTeacherDTO(newTeacher);
} catch (e) {
console.log(e);
return null;
}
}
export async function deleteTeacher(username: string): Promise<TeacherDTO | null> {
const teacherRepository = getTeacherRepository();
const user = await teacherRepository.findByUsername(username);
export async function fetchTeacher(username: string): Promise<Teacher> {
const studentRepository = getStudentRepository();
const user = await studentRepository.findByUsername(username);
if (!user) {
return null;
throw new NotFoundException("Teacher with username not found");
}
try {
await teacherRepository.deleteByUsername(username);
return user;
}
return mapToTeacherDTO(user);
} catch (e) {
console.log(e);
return null;
export async function getTeacher(username: string): Promise<TeacherDTO | null> {
const user = await fetchTeacher(username);
return mapToTeacherDTO(user);
}
export async function createTeacher(userData: TeacherDTO): Promise<void> {
const teacherRepository = getTeacherRepository();
const user = await teacherRepository.findByUsername(userData.username);
if (user){
throw new ConflictException("Teacher with that username already exists");
}
const newTeacher = teacherRepository.create(mapToTeacher(userData));
await teacherRepository.save(newTeacher);
}
export async function deleteTeacher(username: string): Promise<void> {
const teacherRepository = getTeacherRepository();
await fetchTeacher(username); // throws error if it does not exist
await teacherRepository.deleteByUsername(username);
}
async function fetchClassesByTeacher(username: string): Promise<ClassDTO[]> {
const teacherRepository = getTeacherRepository();
const teacher = await teacherRepository.findByUsername(username);
if (!teacher) {
return [];
}
const teacher = await fetchTeacher(username);
const classRepository = getClassRepository();
const classes = await classRepository.findByTeacher(teacher);
@ -81,6 +81,11 @@ export async function getClassesByTeacher(username: string, full: boolean): Prom
export async function getStudentsByTeacher(username: string, full: boolean) {
const classes = await fetchClassesByTeacher(username);
if (!classes || classes.length === 0){
return [];
}
const classIds = classes.map((cls) => cls.id);
const students = (await Promise.all(classIds.map(async (id) => getClassStudents(id)))).flat();
@ -91,16 +96,16 @@ export async function getStudentsByTeacher(username: string, full: boolean) {
}
export async function getTeacherQuestions(username: string, full: boolean): Promise<QuestionDTO[] | QuestionId[]> {
const teacherRepository = getTeacherRepository();
const teacher = await teacherRepository.findByUsername(username);
if (!teacher) {
throw new Error(`Teacher with username '${username}' not found.`);
}
const teacher = await fetchTeacher(username);
// Find all learning objects that this teacher manages
const learningObjectRepository = getLearningObjectRepository();
const learningObjects = await learningObjectRepository.findAllByTeacher(teacher);
if (!learningObjects || learningObjects.length === 0){
return [];
}
// Fetch all questions related to these learning objects
const questionRepository = getQuestionRepository();
const questions = await questionRepository.findAllByLearningObjects(learningObjects);
@ -112,3 +117,38 @@ export async function getTeacherQuestions(username: string, full: boolean): Prom
return questionsDTO.map(mapToQuestionId);
}
export async function getJoinRequestsByClass( classId: string ){
const classRepository = getClassRepository();
const cls = await classRepository.findById(classId);
if (!cls) {
throw new NotFoundException("Class with id not found");
}
const requestRepo = getClassJoinRequestRepository();
const requests = await requestRepo.findAllOpenRequestsTo(cls);
return requests.map(mapToStudentRequestDTO);
}
export async function updateClassJoinRequestStatus( studentUsername: string, classId: string, accepted: boolean = true) {
const requestRepo = getClassJoinRequestRepository();
const classRepo = getClassRepository();
const student = await fetchStudent(studentUsername);
const cls = await classRepo.findById(classId);
if (!cls) {
throw new NotFoundException('Class not found');
}
const request = await requestRepo.findByStudentAndClass(student, cls);
if (!request) {
throw new NotFoundException('Join request not found');
}
request.status = accepted ? ClassJoinRequestStatus.Accepted : ClassJoinRequestStatus.Declined;
await requestRepo.save(request);
}