Sindbad~EG File Manager

import db from "../../model/index";
import AppError from "../../utils/apiError";
import catchAsync from "../../utils/catchAsync";
import { successResponse } from "../../utils/responseFormat";
const index = catchAsync(async (req, res, next) => {
  //contact_id or user_id
  const query = req.query;
  let allData = await db.Policy.find(query)
    .populate("user_id", "_id first_name last_name")
    .populate("contact_id", "_id first_name last_name");
  return successResponse(res, allData);
});

const getSinglePolicy = catchAsync(async (req, res, next) => {
  const _id = req.params.id;

  const policyPromise = db.Policy.findOne({ _id })
    .populate("user_id", "_id first_name last_name email")
    .populate("contact_id", "_id first_name last_name email");

  const additionalInfoPromise = db.AdditionalInfo.find({ policy_id: _id });
  const additionalInterestPromise = db.AdditionalInterest.find({
    policy_id: _id,
  });
  const binderInfoPromise = db.BinderInfo.findOne({ policy_id: _id });
  const commercialAdditionalInfoPromise = db.CommercialAdditionalInfo.findOne({
    policy_id: _id,
  });
  const contractorUnderwritingPromise = db.ContractorUnderwriting.findOne({
    policy_id: _id,
  });
  const extendedPolicyInfoPromise = db.ExtendedPolicyInfo.find({
    policy_id: _id,
  });
  const generalLiabilityUnderwritingPromise =
    db.GeneralLiabilityUnderwriting.find({
      policy_id: _id,
    });
  const locationSchedulePromise = db.LocationSchedule.find({ policy_id: _id });
  const namedInsuredPromise = db.NamedInsured.find({ policy_id: _id });
  const natureOfBusinessPromise = db.NatureOfBusiness.findOne({
    policy_id: _id,
  });
  const paymentPlanPromise = db.PaymentPlan.findOne({ policy_id: _id });
  const policyAttachmentsPromise = db.PolicyAttachment.find({ policy_id: _id });
  const policyFormPromise = db.PolicyForm.find({ policy_id: _id });
  const policyFeePromise = db.Fee.find({ policy_id: _id });
  const policyInfoPromise = db.PolicyInfo.findOne({ policy_id: _id });
  const priorPolicyInfoPromise = db.PriorPolicyInfo.findOne({ policy_id: _id });
  const productPromise = db.Product.find({ policy_id: _id });
  const underwritingQuestionPromise = db.UnderwritingQuestion.find({
    policy_id: _id,
  });

  const [
    policy,
    additionalInfo,
    additionalInterest,
    binderInfo,
    commercialAdditionalInfo,
    contractorUnderwriting,
    extendedPolicyInfo,
    generalLiabilityUnderwriting,
    locationSchedule,
    namedInsured,
    natureOfBusiness,
    paymentPlan,
    policyAttachments,
    policyForm,
    policyFee,
    policyInfo,
    priorPolicyInfo,
    product,
    underwritingQuestion,
  ] = await Promise.all([
    policyPromise,
    additionalInfoPromise,
    additionalInterestPromise,
    binderInfoPromise,
    commercialAdditionalInfoPromise,
    contractorUnderwritingPromise,
    extendedPolicyInfoPromise,
    generalLiabilityUnderwritingPromise,
    locationSchedulePromise,
    namedInsuredPromise,
    natureOfBusinessPromise,
    paymentPlanPromise,
    policyAttachmentsPromise,
    policyFormPromise,
    policyFeePromise,
    policyInfoPromise,
    priorPolicyInfoPromise,
    productPromise,
    underwritingQuestionPromise,
  ]);

  return successResponse(res, {
    policy,
    additionalInfo,
    additionalInterest,
    binderInfo,
    commercialAdditionalInfo,
    contractorUnderwriting,
    extendedPolicyInfo,
    generalLiabilityUnderwriting,
    locationSchedule,
    namedInsured,
    natureOfBusiness,
    paymentPlan,
    policyAttachments,
    policyForm,
    policyFee,
    policyInfo,
    priorPolicyInfo,
    product,
    underwritingQuestion,
  });
});

const add = catchAsync(async (req, res, next) => {
  if (!req.body.contact_id && !req.body.user_id) {
    return next(new AppError("contact_id or user_id is required", 500));
  }

  const policy = new db.Policy(req.body);
  await policy.save();

  const namedInsured = new db.BinderInfo({ policy_id: policy._id });
  const locationSchedule = new db.PolicyInfo({ policy_id: policy._id });
  const paymentPlan = new db.PaymentPlan({ policy_id: policy._id });
  const natureOfBusiness = new db.NatureOfBusiness({ policy_id: policy._id });
  const priorPolicyInfo = new db.PriorPolicyInfo({ policy_id: policy._id });
  const commercialAdditionalInfo = new db.CommercialAdditionalInfo({
    policy_id: policy._id,
  });
  const contractorUnderwriting = new db.ContractorUnderwriting({
    policy_id: policy._id,
  });

  await Promise.all([
    namedInsured.save(),
    locationSchedule.save(),
    paymentPlan.save(),
    natureOfBusiness.save(),
    priorPolicyInfo.save(),
    commercialAdditionalInfo.save(),
    contractorUnderwriting.save(),
  ]);

  return successResponse(
    res,
    {
      policy,
      namedInsured,
      locationSchedule,
      paymentPlan,
      natureOfBusiness,
      priorPolicyInfo,
      commercialAdditionalInfo,
      contractorUnderwriting,
    },
    "Policy saved successfully"
  );
});

const edit = catchAsync(async (req, res, next) => {
  let result = await db.Policy.findByIdAndUpdate(
    { _id: req.params.id },
    { $set: req.body },
    { new: true }
  );
  if (!result) {
    return next(new AppError("No data found.", 404));
  }
  return successResponse(res, result, "Policy updated successfully");
});

const deleteData = catchAsync(async (req, res, next) => {
  let policy = await db.Policy.findById({
    _id: req.params.id,
  });
  if (!policy) {
    return next(new AppError("No data found.", 404));
  }
  await policy.remove();
  return successResponse(res, policy, "Policy deleted successfully");
});

export default { getSinglePolicy, index, add, edit, deleteData };