backend_adaptive_learning/controllers/monitoringControllers/class.js

import response from "../../response.js";
import models from "../../models/index.js";
import { updateMonitoringClass } from "./monitoring.js";

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

export const getClassById = async (req, res) => {
  try {
    const { id } = req.params;
    const classes = await models.Class.findByPk(id);

    if (!classes) {
      return response(404, null, "Class not found", res);
    }

    response(200, classes, "Success", res);
  } catch (error) {
    console.log(error);
    response(500, null, "Internal Server Error", res);
  }
};

export const createClass = async (req, res) => {
  const { NAME_CLASS, TOTAL_STUDENT } = req.body;

  if (!NAME_CLASS) {
    return response(400, null, "Class name is required", res);
  }

  if (!TOTAL_STUDENT) {
    return response(400, null, "Total student is required", res);
  }

  try {
    const newClass = await models.Class.create({
      NAME_CLASS,
      TOTAL_STUDENT,
    });

    response(201, newClass, "Class created successfully", res);
  } catch (error) {
    console.log(error);
    response(500, null, "Internal Server Error", res);
  }
};

export const updateClassById = async (req, res) => {
  const { id } = req.params;
  const { NAME_CLASS, TOTAL_STUDENT } = req.body;

  try {
    const classes = await models.Class.findByPk(id);

    if (!classes) {
      return response(404, null, "Class not found", res);
    }

    if (NAME_CLASS) classes.NAME_CLASS = NAME_CLASS;
    if (TOTAL_STUDENT) classes.TOTAL_STUDENT = TOTAL_STUDENT;

    await classes.save();

    response(200, classes, "Class updated successfully", res);
  } catch (error) {
    console.log(error);
    response(500, null, "Internal Server Error", res);
  }
};

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

  try {
    const classes = await models.Class.findByPk(id);

    if (!classes) {
      return response(404, null, "Class not found", res);
    }

    await classes.destroy();

    response(200, null, "Class deleted successfully", res);
  } catch (error) {
    console.log(error);
    response(500, null, "Internal Server Error", res);
  }
};

export const updateStudentClassByName = async (req, res) => {
  const { NAME_CLASS, STUDENTS } = req.body;

  if (!NAME_CLASS || !Array.isArray(STUDENTS) || STUDENTS.length === 0) {
    return response(
      400,
      null,
      "Class name and students data are required",
      res
    );
  }

  try {
    const classRecord = await models.Class.findOne({
      where: { NAME_CLASS },
    });

    if (!classRecord) {
      return response(404, null, "Class not found", res);
    }

    const updateResults = [];
    let hasError = false;

    for (const { NAME_USERS, NISN } of STUDENTS) {
      if (!NAME_USERS || !NISN) {
        updateResults.push({
          NAME_USERS,
          NISN,
          error: "User name and NISN are required for each student",
        });
        hasError = true;
        continue;
      }

      try {
        const student = await models.Student.findOne({
          include: [
            {
              model: models.User,
              as: "studentUser",
              where: { NAME_USERS },
            },
          ],
          where: { NISN },
        });

        if (!student) {
          updateResults.push({
            NAME_USERS,
            NISN,
            error: "Student with the given name and NISN not found",
          });
          hasError = true;
          continue;
        }

        if (student.ID_CLASS === classRecord.ID_CLASS) {
          updateResults.push({
            NAME_USERS,
            NISN,
            error: "Student is already in the selected class",
          });
          hasError = true;
          continue;
        }

        student.ID_CLASS = classRecord.ID_CLASS;
        await student.save();

        const stdLearningRecords = await models.StdLearning.findAll({
          where: { ID: student.ID },
          include: [
            {
              model: models.Level,
              as: "level",
              where: { NAME_LEVEL: "Level 6" },
            },
          ],
        });

        const studentUpdateResults = [];

        for (const stdLearning of stdLearningRecords) {
          try {
            const result = await updateMonitoringClass({
              ID_STUDENT_LEARNING: stdLearning.ID_STUDENT_LEARNING,
              ID_CLASS: classRecord.ID_CLASS,
            });
            studentUpdateResults.push(result);
          } catch (error) {
            console.error("Error updating monitoring class:", error.message);
            studentUpdateResults.push({ error: error.message });
          }
        }

        updateResults.push({
          NAME_USERS,
          NISN,
          message:
            "Student's class and related monitoring updated successfully",
          studentUpdateResults,
        });
      } catch (error) {
        console.error("Error processing student:", error.message);
        updateResults.push({
          NAME_USERS,
          NISN,
          error: "Error processing student",
          details: error.message,
        });
        hasError = true;
      }
    }

    if (hasError) {
      return response(
        400,
        { updateResults },
        "Some students could not be updated due to errors",
        res
      );
    } else {
      return response(
        200,
        { updateResults },
        "Students classes updated successfully",
        res
      );
    }
  } catch (error) {
    console.error(error);
    response(500, null, "Internal Server Error", res);
  }
};