backend_adaptive_learning/controllers/learningControllers/stdExercise.js

import response from "../../response.js";
import models from "../../models/index.js";

export const getStdExercises = async (req, res) => {
  try {
    const stdExercise = await models.StdExercise.findAll();
    response(200, stdExercise, "Success", res);
  } catch (error) {
    console.log(error);
    response(500, null, "Error retrieving student exercise data!", res);
  }
};

export const getStdExerciseById = async (req, res) => {
  try {
    const { id } = req.params;
    const stdExercise = await models.StdExercise.findByPk(id);

    if (!stdExercise) {
      return response(404, null, "Student exercise data not found", res);
    }

    response(200, stdExercise, "Success", res);
  } catch (error) {
    console.log(error);
    res.status(500).json({ message: "Internal Server Error" });
  }
};

export const stdAnswerExercise = async (req, res, next) => {
  try {
    const { answers } = req.body;

    if (!Array.isArray(answers) || answers.length === 0) {
      return response(400, null, "Answers array is required", res);
    }

    for (const answer of answers) {
      const { ID_STUDENT_LEARNING, ID_ADMIN_EXERCISE, ANSWER_STUDENT } = answer;

      if (!ID_STUDENT_LEARNING) {
        return response(400, null, "Id student learning is required", res);
      }

      const existingStdLearning = await models.StdLearning.findByPk(
        ID_STUDENT_LEARNING
      );
      if (!existingStdLearning) {
        return response(404, null, "Id student learning not found", res);
      }

      if (!ID_ADMIN_EXERCISE) {
        return response(400, null, "Id exercise is required", res);
      }

      const exercise = await models.Exercise.findOne({
        where: {
          ID_ADMIN_EXERCISE: ID_ADMIN_EXERCISE,
          ID_LEVEL: existingStdLearning.ID_LEVEL,
        },
      });
      if (!exercise) {
        return response(404, null, "Exercise not found in this level", res);
      }

      if (!ANSWER_STUDENT) {
        return response(400, null, "Answer is required", res);
      }

      const existingStdExercise = await models.StdExercise.findOne({
        where: {
          ID_STUDENT_LEARNING: ID_STUDENT_LEARNING,
          ID_ADMIN_EXERCISE: ID_ADMIN_EXERCISE,
        },
      });

      if (existingStdExercise) {
        existingStdExercise.ANSWER_STUDENT = ANSWER_STUDENT;
        await existingStdExercise.save();
      } else {
        await models.StdExercise.create({
          ID_STUDENT_LEARNING,
          ID_ADMIN_EXERCISE,
          ANSWER_STUDENT,
        });
      }
    }

    req.params.id = answers[0].ID_STUDENT_LEARNING;
    next();
  } catch (error) {
    console.log(error);
    return response(
      500,
      null,
      "Error creating or updating student exercise data!",
      res
    );
  }
};

export const getStudentAnswersByStdLearningId = async (req, res) => {
  try {
    const { id } = req.params;

    const stdLearning = await models.StdLearning.findByPk(id, {
      include: [
        {
          model: models.Level,
          as: "level",
          attributes: ["ID_LEVEL", "NAME_LEVEL"],
          include: [
            {
              model: models.Topic,
              as: "levelTopic",
              attributes: ["ID_TOPIC", "NAME_TOPIC"],
              include: [
                {
                  model: models.Section,
                  as: "topicSection",
                  attributes: ["ID_SECTION", "NAME_SECTION"],
                },
              ],
            },
          ],
        },
      ],
      attributes: ["ID_STUDENT_LEARNING", "ID_LEVEL", "SCORE", "IS_PASS"],
    });

    if (!stdLearning) {
      return response(404, null, "Student learning data not found", res);
    }

    const stdLearningData = stdLearning.toJSON();
    const { ID_LEVEL } = stdLearningData;

    const exercises = await models.Exercise.findAll({
      where: { ID_LEVEL, IS_DELETED: 0 },
      include: [
        {
          model: models.MultipleChoices,
          as: "multipleChoices",
          attributes: [
            "OPTION_A",
            "OPTION_B",
            "OPTION_C",
            "OPTION_D",
            "OPTION_E",
          ],
        },
        {
          model: models.MatchingPairs,
          as: "matchingPairs",
          attributes: ["LEFT_PAIR", "RIGHT_PAIR"],
        },
      ],
      attributes: [
        "ID_ADMIN_EXERCISE",
        "TITLE",
        "QUESTION",
        "QUESTION_TYPE",
        "SCORE_WEIGHT",
        "IMAGE",
        "AUDIO",
        "VIDEO",
      ],
      order: [
        [
          models.Sequelize.literal(
            "CAST(SUBSTRING_INDEX(TITLE, ' ', -1) AS UNSIGNED)"
          ),
          "ASC",
        ],
      ],
    });

    const stdExercises = await models.StdExercise.findAll({
      where: { ID_STUDENT_LEARNING: stdLearning.ID_STUDENT_LEARNING },
      include: [
        {
          model: models.Exercise,
          as: "stdExerciseExercises",
          attributes: ["ID_ADMIN_EXERCISE"],
        },
      ],
      attributes: [
        "ID_STUDENT_EXERCISE",
        "ID_ADMIN_EXERCISE",
        "ANSWER_STUDENT",
        "IS_CORRECT",
        "RESULT_SCORE_STUDENT",
      ],
    });

    const mappedExercises = exercises.map((exercise) => {
      const stdExercise = stdExercises.find(
        (stdEx) => stdEx.ID_ADMIN_EXERCISE === exercise.ID_ADMIN_EXERCISE
      );

      return {
        ID_STUDENT_EXERCISE: stdExercise?.ID_STUDENT_EXERCISE || null,
        ID_ADMIN_EXERCISE: exercise.ID_ADMIN_EXERCISE,
        TITLE: exercise.TITLE,
        QUESTION: exercise.QUESTION,
        QUESTION_TYPE: exercise.QUESTION_TYPE,
        SCORE_WEIGHT: exercise.SCORE_WEIGHT,
        IMAGE: exercise.IMAGE,
        VIDEO: exercise.VIDEO,
        AUDIO: exercise.AUDIO,
        ANSWER_STUDENT: stdExercise?.ANSWER_STUDENT || null,
        IS_CORRECT: stdExercise?.IS_CORRECT || null,
        RESULT_SCORE_STUDENT: stdExercise?.RESULT_SCORE_STUDENT || null,
        ...(exercise.QUESTION_TYPE === "MCQ" && {
          multipleChoices: exercise.multipleChoices,
        }),
        ...(exercise.QUESTION_TYPE === "MPQ" && {
          matchingPairs: exercise.matchingPairs,
        }),
      };
    });

    const { NAME_SECTION } = stdLearningData.level.levelTopic.topicSection;
    const { NAME_TOPIC } = stdLearningData.level.levelTopic;
    const { NAME_LEVEL } = stdLearningData.level;

    return response(
      200,
      {
        ID_STUDENT_LEARNING: stdLearningData.ID_STUDENT_LEARNING,
        ID_LEVEL: stdLearningData.ID_LEVEL,
        NAME_SECTION,
        NAME_TOPIC,
        NAME_LEVEL,
        SCORE: stdLearningData.SCORE,
        IS_PASS: stdLearningData.IS_PASS,
        stdExercises: mappedExercises,
      },
      "Student learning exercises retrieved successfully",
      res
    );
  } catch (error) {
    console.error(error);
    return response(
      500,
      null,
      "Error retrieving student learning exercises",
      res
    );
  }
};