Sindbad~EG File Manager

import mongoose from "mongoose";
import Contact from "../../model/contact";
import BasicContactInfo from "../../model/basicontactInfo";
import Address from "../../model/address";
import PersonalInfo from "../../model/personalInfo";
import AccountInfo from "../../model/accountInfo";
import AdditionalContact from "../../model/additionalContact";
import AccountInformation from "../../model/accountInfo";
import LinkedAccount from "../../model/linkedAccount";
import XDates from "../../model/XDates";
import Employer from "../../model/employer";
import SocialMedia from "../../model/socialMedia";
import { successResponse, failedResponse } from "../../utils/responseFormat";
const filteredPrimaryData = async (contactId) => {
  const filteredData = await BasicContactInfo.aggregate([
    {
      $match: {
        contact_id: mongoose.Types.ObjectId(contactId), // 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 index = async (req, res) => {
  try {
    // { created_by: req.user._id }
    let allData = await Contact.find()
      .populate("created_by", ["_id", "first_name"])
      .exec();

    const result = allData.filter((item) => item.created_by !== null);

    let totalRecords = result.length;
    return successResponse(res, result);
  } catch (error) {
    return failedResponse({ res, error: error.message });
  }
};

const add = async (req, res) => {
  try {
    req.body.created_by = req.user._id;
    const contactData = req.body;
    const contact = new Contact(contactData);
    await contact.save();

    const personalInfo = new PersonalInfo({ contact_id: contact._id });
    await personalInfo.save();

    const socialMedia = new SocialMedia({ contact_id: contact._id });
    await socialMedia.save();

    const accountInfo = new AccountInfo({ contact_id: contact._id });
    await accountInfo.save();

    const basicInfo = new BasicContactInfo({ contact_id: contact._id });
    await basicInfo.save();
    return res.status(200).json({
      message: "Contact created successfully",
      contact,
      personalInfo,
      socialMedia,
      accountInfo,
      basicInfo,
    });
    // return successResponse(res, contact, "Contact saved successfully.");
  } catch (error) {
    return failedResponse({ res, error: error.message });
  }
};

const edit = async (req, res) => {
  try {
    let result = await Contact.findByIdAndUpdate(
      { _id: req.params.id },
      { $set: req.body },
      { new: true }
    );
    if (!result) {
      return failedResponse({ res, error: "No data found." });
    }
    return successResponse(res, result, "Contact updated successfully");
  } catch (error) {
    return failedResponse({ res, error: error.message });
  }
};

const view = async (req, res) => {
  try {
    let Contacts = await Contact.aggregate([
      {
        $match: {
          _id: mongoose.Types.ObjectId(req.params.id),
        },
      },
    ]);

    let contact = await Contact.findByIdAndUpdate({ _id: req.params.id });
    if (!contact) {
      return failedResponse({ res, error: "No data found." });
    }
    return successResponse(res, Contacts);
  } catch (error) {
    return failedResponse({ res, error: error.message });
  }
};
const profile = async (req, res) => {
  try {
    const _id = req.body.contact_id;
    let dummyData = {
      phone_numbers: [
        {
          phone_no: "",
          type: "",
          is_primary: false,
          _id: "",
        },
      ],
      emails: [
        {
          email_address: "",
          type: "",
          is_primary: false,
          _id: "",
        },
      ],
    };
    let userDoc = await Contact.findById(_id, {
      password: 0,
    });

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

    const basicContactInfo = await BasicContactInfo.findOne({
      contact_id: _id,
    });
    const filteredData = await filteredPrimaryData(_id);
    profile.filteredData =
      filteredData.length > 0 ? filteredData[0] : dummyData;
    const additionalContact = await AdditionalContact.find({ contact_id: _id });
    const address = await Address.find({ contact_id: _id });
    const personalInfo = await PersonalInfo.findOne({ contact_id: _id });
    const accountInformation = await AccountInformation.findOne({
      contact_id: _id,
    });
    const linkedAccount = await LinkedAccount.find({
      contact_id: _id,
    });
    const xDates = await XDates.find({
      contact_id: _id,
    });
    const employer = await Employer.find({
      contact_id: _id,
    });
    const socialMedia = await SocialMedia.findOne({ contact_id: _id });

    const newFormat = {
      profile,
      basicContactInfo,
      address,
      additionalContact,
      accountInformation,
      personalInfo,
      linkedAccount,
      xDates,
      employer,
      socialMedia,
    };
    return successResponse(res, newFormat);
  } catch (error) {
    return failedResponse({ res, error: error.message });
  }
};

const deleteData = async (req, res) => {
  try {
    const contactId = req.params.id;
    // Delete the contact itself
    const deletedcontact = await Contact.findByIdAndDelete({ _id: contactId });

    if (!deletedcontact) {
      return failedResponse({ res, error: "No data found." });
    }
    return successResponse(
      res,
      deletedcontact,
      "Contact and related data deleted successfully."
    );
  } catch (error) {
    return failedResponse({ res, error: error.message });
  }
};

export default { index, profile, add, edit, view, deleteData };