109 lines
3.3 KiB
TypeScript
109 lines
3.3 KiB
TypeScript
import {getAnswerRepository, getQuestionRepository} from "../data/repositories.js";
|
|
import {mapToQuestionDTO, mapToQuestionId, QuestionDTO, QuestionId} from "../interfaces/question.js";
|
|
import {Question} from "../entities/questions/question.entity.js";
|
|
import {Answer} from "../entities/questions/answer.entity.js";
|
|
import {mapToAnswerDTO, mapToAnswerId} from "../interfaces/answer.js";
|
|
import {QuestionRepository} from "../data/questions/question-repository.js";
|
|
import {LearningObjectIdentifier} from "../entities/content/learning-object-identifier.js";
|
|
import {mapToUser} from "../interfaces/user.js";
|
|
import {Student} from "../entities/users/student.entity.js";
|
|
|
|
export async function getAllQuestions(
|
|
id: LearningObjectIdentifier, full: boolean
|
|
): Promise<QuestionDTO[] | QuestionId[]> {
|
|
const questionRepository: QuestionRepository = getQuestionRepository();
|
|
const questions = await questionRepository.findAllQuestionsAboutLearningObject(id);
|
|
|
|
if (!questions) {
|
|
return [];
|
|
}
|
|
|
|
const questionsDTO: QuestionDTO[] = questions.map(mapToQuestionDTO);
|
|
|
|
if (full) {
|
|
return questionsDTO;
|
|
}
|
|
|
|
return questionsDTO.map(mapToQuestionId);
|
|
}
|
|
|
|
async function fetchQuestion(questionId: QuestionId): Promise<Question | null> {
|
|
const questionRepository = getQuestionRepository();
|
|
|
|
return await questionRepository.findOne(
|
|
{
|
|
learningObjectHruid: questionId.learningObjectIdentifier.hruid,
|
|
learningObjectLanguage: questionId.learningObjectIdentifier.language,
|
|
learningObjectVersion: questionId.learningObjectIdentifier.version,
|
|
sequenceNumber: questionId.sequenceNumber
|
|
}
|
|
)
|
|
}
|
|
|
|
export async function getQuestion(questionId: QuestionId): Promise<QuestionDTO | null> {
|
|
const question = await fetchQuestion(questionId);
|
|
|
|
if (!question)
|
|
return null
|
|
|
|
return mapToQuestionDTO(question);
|
|
}
|
|
|
|
export async function getAnswersByQuestion(questionId: QuestionId, full: boolean) {
|
|
const answerRepository = getAnswerRepository();
|
|
const question = await fetchQuestion(questionId);
|
|
|
|
if (!question)
|
|
return [];
|
|
|
|
const answers: Answer[] = await answerRepository.findAllAnswersToQuestion(question);
|
|
|
|
if (!answers)
|
|
return []
|
|
|
|
const answersDTO = answers.map(mapToAnswerDTO);
|
|
|
|
if (full)
|
|
return answersDTO
|
|
|
|
return answersDTO.map(mapToAnswerId);
|
|
}
|
|
|
|
export async function createQuestion(questionDTO: QuestionDTO) {
|
|
const questionRepository = getQuestionRepository();
|
|
|
|
const author = mapToUser<Student>(questionDTO.author, new Student())
|
|
|
|
try {
|
|
await questionRepository.createQuestion({
|
|
loId: questionDTO.learningObjectIdentifier,
|
|
author,
|
|
content: questionDTO.content }
|
|
);
|
|
} catch (e) {
|
|
return null
|
|
}
|
|
|
|
return questionDTO;
|
|
}
|
|
|
|
export async function deleteQuestion(questionId: QuestionId) {
|
|
const questionRepository = getQuestionRepository();
|
|
|
|
const question = await fetchQuestion(questionId);
|
|
|
|
if (!question)
|
|
return null
|
|
|
|
try {
|
|
await questionRepository.removeQuestionByLearningObjectAndSequenceNumber(
|
|
questionId.learningObjectIdentifier, questionId.sequenceNumber
|
|
);
|
|
} catch (e) {
|
|
return null
|
|
}
|
|
|
|
return question
|
|
}
|
|
|
|
|