backend_adaptive_learning/controllers/contentControllers/topic.js

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

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

export const getTopicById = async (req, res) => {
  try {
    const { id } = req.params;
    const topic = await models.Topic.findByPk(id);

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

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

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

    const sectionExists = await models.Section.findByPk(sectionId);
    if (!sectionExists) {
      return response(404, null, "Section not found", res);
    }

    const topics = await models.Topic.findAll({
      where: { ID_SECTION: sectionId },
    });

    if (!topics || topics.length === 0) {
      return response(404, null, "No topics found for this section", res);
    }

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

export const createTopic = async (req, res) => {
  const { ID_SECTION, NAME_TOPIC, DESCRIPTION_TOPIC } = req.body;

  if (!ID_SECTION) {
    return response(400, null, "Section ID is required", res);
  }

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

  if (!DESCRIPTION_TOPIC) {
    return response(400, null, "Topic description is required", res);
  }

  try {
    const section = await models.Section.findByPk(ID_SECTION);
    if (!section) {
      return response(404, null, "Section not found", res);
    }

    const newTopic = await models.Topic.create({
      ID_SECTION,
      NAME_TOPIC,
      DESCRIPTION_TOPIC,
    });

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

export const updateTopicById = async (req, res) => {
  const { id } = req.params;
  const { ID_SECTION, NAME_TOPIC, DESCRIPTION_TOPIC } = req.body;

  try {
    const topic = await models.Topic.findByPk(id);

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

    if (ID_SECTION) {
      const section = await models.Section.findByPk(ID_SECTION);
      if (!section) {
        return response(404, null, "Section not found", res);
      }
      topic.ID_SECTION = ID_SECTION;
    }

    if (NAME_TOPIC) {
      topic.NAME_TOPIC = NAME_TOPIC;
    }

    if (DESCRIPTION_TOPIC) {
      topic.DESCRIPTION_TOPIC = DESCRIPTION_TOPIC;
    }

    await topic.save();

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

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

  try {
    const topic = await models.Topic.findByPk(id);

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

    await topic.destroy();

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

export const getCompletedTopicsBySection = async (req, res) => {
  try {
    const user = req.user;
    const userId = user.ID;

    const completedLevels = await models.StdLearning.findAll({
      where: {
        ID: userId,
        IS_PASS: 1,
      },
      include: [
        {
          model: models.Level,
          as: "level",
          include: [
            {
              model: models.Topic,
              as: "levelTopic",
              attributes: ["ID_TOPIC", "NAME_TOPIC", "DESCRIPTION_TOPIC"],
              include: [
                {
                  model: models.Section,
                  as: "topicSection",
                  attributes: [
                    "ID_SECTION",
                    "NAME_SECTION",
                    "DESCRIPTION_SECTION",
                  ],
                },
              ],
            },
          ],
        },
      ],
    });

    if (!completedLevels.length) {
      return response(404, null, "No completed topics found", res);
    }

    const completedSections = {};

    for (const levelRecord of completedLevels) {
      const level = levelRecord.level;
      const topic = level.levelTopic;
      const section = topic.topicSection;

      const level6 = await models.Level.findOne({
        where: {
          NAME_LEVEL: "Level 6",
          ID_TOPIC: topic.ID_TOPIC,
        },
      });

      if (level6 && level.ID_LEVEL === level6.ID_LEVEL) {
        const totalTopicsInSection = await models.Topic.count({
          where: { ID_SECTION: section.ID_SECTION },
        });

        if (!completedSections[section.ID_SECTION]) {
          completedSections[section.ID_SECTION] = {
            ID_SECTION: section.ID_SECTION,
            NAME_SECTION: section.NAME_SECTION,
            DESCRIPTION_SECTION: section.DESCRIPTION_SECTION,
            TOTAL_TOPICS: totalTopicsInSection,
            COMPLETED_TOPICS: 0,
          };
        }

        completedSections[section.ID_SECTION].COMPLETED_TOPICS++;
      }
    }

    const result = Object.values(completedSections);

    response(
      200,
      result,
      "Completed topics by section fetched successfully",
      res
    );
  } catch (error) {
    console.error(error);
    response(500, null, "Internal Server Error", res);
  }
};