Sindbad~EG File Manager

import User from "../../model/user";
import Address from "../../model/address";
import Goals from "../../model/goals";
import SocialMedia from "../../model/socialMedia";
import PersonalInfo from "../../model/personalInfo";
import EmploymentInfo from "../../model/employmentInfo";
import BasicContactInfo from "../../model/basicontactInfo";
import System from "../../model/system";
import Signature from "../../model/signatures";
import EmailSetup from "../../model/emailSetup";
import bcrypt from "bcrypt";
import { successResponse, failedResponse } from "../../utils/responseFormat";
import CustomError from "../../errors/index";
import mongoose from "mongoose";
const filteredPrimaryData = async (userId) => {
  const filteredData = await BasicContactInfo.aggregate([
    {
      $match: {
        user_id: mongoose.Types.ObjectId(userId), // Ensure userId is of the correct type
      },
    },
    {
      $project: {
        phone_numbers: {
          $cond: {
            if: { $isArray: "$phone_numbers" },
            then: {
              $filter: {
                input: "$phone_numbers",
                as: "phone",
                cond: { $eq: ["$$phone.is_primary", true] },
              },
            },
            else: [],
          },
        },
        emails: {
          $cond: {
            if: { $isArray: "$emails" },
            then: {
              $filter: {
                input: "$emails",
                as: "email",
                cond: { $eq: ["$$email.is_primary", true] },
              },
            },
            else: [],
          },
        },
      },
    },
    {
      $match: {
        $or: [
          { "phone_numbers.0": { $exists: true } },
          { "emails.0": { $exists: true } },
        ],
      },
    },
  ]);
  return filteredData;
};

const viewAll = async (req, res) => {
  try {
    let result = await User.find();
    return successResponse(res, result, "All Users");
  } catch (error) {
    return failedResponse({ res, error: error.message });
  }
};

const view = async (req, res) => {
  try {
    let user = await User.findById({ _id: req.params.id });
    if (!user) {
      return failedResponse({ res, error: "No data found." });
    }
    return successResponse(res, user);
  } catch (error) {
    return failedResponse({ res, error: error.message });
  }
};

const edit = async (req, res) => {
  try {
    if (req.body.password) {
      req.body.password = await bcrypt.hash(req.body.password, 10);
    }
    let result = await User.findByIdAndUpdate(
      { _id: req.user._id },
      {
        $set: req.body,
      }
    );
    return successResponse(res, result, "User updated successfully.");
  } catch (error) {
    return failedResponse({ res, error: error.message });
  }
};

const deleteData = async (req, res) => {
  try {
    const userId = req.params.id;
    const user = await User.findById(userId);
    if (!user) {
      throw new CustomError.NotFoundError("User not found.");
    }
    if (user.role !== "admin") {
      // const deletedUser = await User.findByIdAndDelete({ _id: userId });
      const deletedUser = await User.findByIdAndDelete({ _id: userId });
      if (!deletedUser) {
        return failedResponse({ res, error: "No data found." });
      }
      return successResponse(res, deletedUser, "User deleted successfully.");
    } else {
      res.send({ message: "Admin can not deleted" });
    }
  } catch (error) {
    return failedResponse({ res, error: error.message });
  }
};

const profile = async (req, res) => {
  try {
    let user_id = req.user._id;
    let dummyData = {
      phone_numbers: [
        {
          phone_no: "",
          type: "",
          is_primary: false,
          _id: "",
        },
      ],
      emails: [
        {
          email_address: "",
          type: "",
          is_primary: false,
          _id: "",
        },
      ],
    };

    let userDoc = await User.findById(user_id, {
      __v: 0,
      password: 0,
    });

    if (!userDoc) {
      return failedResponse({ res, error: "No data found." });
    }
    const user = userDoc.toObject();
    // return res.json(user);
    const { basic_contact_info, ...profile } = user;

    const address = await Address.find({ user_id: user_id });

    const basicContactInfo = await BasicContactInfo.findOne({
      user_id: user_id,
    });

    const filteredData = await filteredPrimaryData(user_id);
    profile.filteredData =
      filteredData.length > 0 ? filteredData[0] : dummyData;
    const goals = await Goals.find({ user_id: user_id });

    const socialMedia = await SocialMedia.find({ user_id: user_id });

    const employeeInfo = await PersonalInfo.findOne({ user_id: user_id });

    const employmentInfo = await EmploymentInfo.findOne({
      user_id: user_id,
    });

    const system = await System.findOne({
      user_id: user_id,
    });
    const signature = await Signature.find({ user_id: user_id });

    const emailSetup = await EmailSetup.find({
      user_id: user_id,
    });

    const newFormat = {
      profile,
      basicContactInfo,
      goals,
      socialMedia,
      address,
      employeeInfo,
      employmentInfo,
      signature,
      system,
      emailSetup,
    };
    return successResponse(res, newFormat);
  } catch (error) {
    return failedResponse({ res, error: error.message });
  }
};

const createAgent = async (req, res) => {
  try {
    let { primary_email, password } = req.body;
    if (!primary_email || !password) {
      return failedResponse({
        res,
        error: "primary_email,password are required.",
      });
    }
    // Check if the username is already taken
    const existingUser = await User.findOne({ primary_email });
    if (existingUser) {
      return failedResponse({
        res,
        error: "EmailAddress already exists.",
      });
    }
    // Hash the password
    req.body.password = await bcrypt.hash(password, 10);
    const newUser = new User(req.body);
    const data = await newUser.save();

    const personalInfo = new PersonalInfo({ user_id: data._id });
    await personalInfo.save();

    const employmentInfo = new EmploymentInfo({ user_id: data._id });
    await employmentInfo.save();

    const system = new System({ user_id: data._id });
    await system.save();

    res.status(201).json({
      data,
      message: "Agent created successfully",
      personalInfo,
      employmentInfo,
      system,
    });
  } catch (error) {
    return failedResponse({ res, error: error.message });
  }
};

export default {
  view,
  profile,
  viewAll,
  edit,
  deleteData,
  createAgent,
};