129 lines
4.5 KiB
TypeScript
129 lines
4.5 KiB
TypeScript
import {
|
|
getClassRepository,
|
|
getLearningObjectRepository,
|
|
getQuestionRepository,
|
|
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, 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[]> {
|
|
const teacherRepository = getTeacherRepository();
|
|
const users = await teacherRepository.findAll();
|
|
return users.map(mapToTeacherDTO);
|
|
}
|
|
|
|
export async function getAllTeacherIds(): Promise<string[]> {
|
|
const users = await getAllTeachers();
|
|
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);
|
|
|
|
if (!user) {
|
|
return null;
|
|
}
|
|
|
|
try {
|
|
await teacherRepository.deleteByUsername(username);
|
|
|
|
return mapToTeacherDTO(user);
|
|
} catch (e) {
|
|
console.log(e);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
export async function fetchClassesByTeacher(username: string): Promise<ClassDTO[]> {
|
|
const teacherRepository = getTeacherRepository();
|
|
const teacher = await teacherRepository.findByUsername(username);
|
|
if (!teacher) {
|
|
return [];
|
|
}
|
|
|
|
const classRepository = getClassRepository();
|
|
const classes = await classRepository.findByTeacher(teacher);
|
|
return classes.map(mapToClassDTO);
|
|
}
|
|
|
|
export async function getClassesByTeacher(username: string): Promise<ClassDTO[]> {
|
|
return await fetchClassesByTeacher(username);
|
|
}
|
|
|
|
export async function getClassIdsByTeacher(username: string): Promise<string[]> {
|
|
const classes = await fetchClassesByTeacher(username);
|
|
return classes.map((cls) => cls.id);
|
|
}
|
|
|
|
export async function fetchStudentsByTeacher(username: string) {
|
|
const classes = await getClassIdsByTeacher(username);
|
|
|
|
return (await Promise.all(classes.map(async (id) => getClassStudents(id)))).flat();
|
|
}
|
|
|
|
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[]> {
|
|
const teacherRepository = getTeacherRepository();
|
|
const teacher = await teacherRepository.findByUsername(username);
|
|
if (!teacher) {
|
|
throw new Error(`Teacher with username '${username}' not found.`);
|
|
}
|
|
|
|
// Find all learning objects that this teacher manages
|
|
const learningObjectRepository = getLearningObjectRepository();
|
|
const learningObjects = await learningObjectRepository.findAllByTeacher(teacher);
|
|
|
|
// Fetch all questions related to these learning objects
|
|
const questionRepository = getQuestionRepository();
|
|
const questions = await questionRepository.findAllByLearningObjects(learningObjects);
|
|
|
|
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);
|
|
}
|