api/resources/KYC/KycController.js

import mongoose from "mongoose";
import cloudinary from "../../Utils/cloudinary.js";
import { KYC } from "./KycModel.js";
import User from "../user/userModel.js";
import { rejectKYC } from "../../Utils/rejectKyc.js";
import SalesCoOrdinator from "../SalesCoOrdinators/SalesCoOrdinatorModel.js";
import TerritoryManager from "../TerritoryManagers/TerritoryManagerModel.js";
import { Notification } from "../Notification/notificationModal.js";

export const createKyc = async (req, res) => {
  const {
    name,
    trade_name,
    address,
    state,
    city,
    district,
    pincode,
    mobile_number,
    principal_distributer,
    pan_number,
    aadhar_number,
    gst_number,

    notes,
  } = req.body;

  const {
    selfie_entrance_img,
    pan_img,
    aadhar_img,
    gst_img,
    pesticide_license_img,
  } = req.files;

  let fertilizer_license_img;
  if (req.files && req.files.fertilizer_license_img) {
    fertilizer_license_img = req.files.fertilizer_license_img;
  }

  if (!req?.user) return res.status(400).json({ message: "Please login!" });
  const userType = req.userType;
  try {
    if (!mongoose.Types.ObjectId.isValid(req.user._id)) {
      return res.status(400).json({ message: "Please login again" });
    }

    // Upload images to Cloudinary and store only public_id and url
    const uploadImage = async (image, folder) => {
      if (!image) return null;
      const result = await cloudinary.v2.uploader.upload(image.tempFilePath, {
        folder,
      });
      return {
        public_id: result.public_id,
        url: result.secure_url,
      };
    };

    const panImg = await uploadImage(pan_img, "KYC/pan");
    const aadharImg = await uploadImage(aadhar_img, "KYC/aadhar");
    const gstImg = await uploadImage(gst_img, "KYC/gst");
    const pesticideLicenseImg = await uploadImage(
      pesticide_license_img,
      "KYC/pesticide_license"
    );
    const fertilizerLicenseImg = await uploadImage(
      fertilizer_license_img,
      "KYC/fertilizer_license"
    );
    const selfieEntranceImg = await uploadImage(
      selfie_entrance_img,
      "KYC/selfie_entrance"
    );

    // Create KYC document
    const kyc = await KYC.create({
      name,
      trade_name,
      address,
      state,
      city,
      district,
      pincode,
      mobile_number,
      principal_distributer,
      pan_number,
      pan_img: panImg,
      aadhar_number,
      aadhar_img: aadharImg,
      gst_number,
      gst_img: gstImg,
      pesticide_license_img: pesticideLicenseImg,
      fertilizer_license_img: fertilizerLicenseImg || {},
      selfie_entrance_img: selfieEntranceImg,
      addedBy: req.user._id,
      userType: userType,
      notes,
    });

    if (kyc) {
      return res
        .status(201)
        .json({ success: true, kyc, message: "KYC created" });
    }
  } catch (error) {
    res.status(500).json({
      success: false,
      message: error.message ? error.message : "Something went wrong",
    });
  }
};
export const createretaildistributor = async (req, res) => {
  const {
    name,
    trade_name,
    address,
    state,
    city,
    district,
    pincode,
    mobile_number,
    pan_number,
    aadhar_number,
    gst_number,
  } = req.body;

  try {
    if (!mongoose.Types.ObjectId.isValid(req.user._id)) {
      return res.status(400).json({ message: "Please login again" });
    }

    if (!req.files) {
      return res.status(400).json({ message: "No files were uploaded." });
    }

    const {
      selfieEntranceImg,
      panImg,
      aadharImg,
      gstImg,
      pesticideLicenseImg,
    } = req.files;
    // console.log(req.files);
    const fertilizerLicenseImg = req.files.fertilizerLicenseImg || null;

    if (
      !panImg ||
      !aadharImg ||
      !gstImg ||
      !selfieEntranceImg ||
      !pesticideLicenseImg
    ) {
      return res
        .status(400)
        .json({ message: "Please upload all required images." });
    }

    // Upload images to Cloudinary
    const uploadImage = async (image, folder) => {
      if (!image) return null;
      const result = await cloudinary.v2.uploader.upload(image.tempFilePath, {
        folder,
      });
      return {
        public_id: result.public_id,
        url: result.secure_url,
      };
    };

    const pan_img = await uploadImage(panImg, "KYC/pan");
    const aadhar_img = await uploadImage(aadharImg, "KYC/aadhar");
    const gst_img = await uploadImage(gstImg, "KYC/gst");
    const pesticide_license_img = await uploadImage(
      pesticideLicenseImg,
      "KYC/pesticide_license"
    );
    const fertilizer_license_img = await uploadImage(
      fertilizerLicenseImg,
      "KYC/fertilizer_license"
    );
    const selfie_entrance_img = await uploadImage(
      selfieEntranceImg,
      "KYC/selfie_entrance"
    );

    // Create KYC document
    const kycData = {
      name,
      trade_name,
      address,
      state,
      city,
      district,
      pincode,
      mobile_number,
      pan_number,
      pan_img,
      aadhar_number,
      aadhar_img,
      gst_number,
      gst_img,
      pesticide_license_img,
      fertilizer_license_img: fertilizer_license_img || null, // Optional field
      selfie_entrance_img,
      status: "approved",
    };

    const kyc = await KYC.create(kycData);

    if (kyc) {
      return res
        .status(201)
        .json({ success: true, kyc, message: "KYC created" });
    }
  } catch (error) {
    res.status(500).json({
      success: false,
      message: error.message ? error.message : "Something went wrong!",
    });
  }
};

// Get All KYC
export const getAllKyc = async (req, res) => {
  try {
    // Fetch all KYC documents from the database
    // console.log("req came here ");
    // console.log(req.user._id);
    const kycs = await KYC.find({ principal_distributer: req.user._id })
      .populate("principal_distributer", "name")
      .populate("addedBy");
    // console.log(kycs);
    // Send the fetched data as a response
    res.status(200).json(kycs);
  } catch (error) {
    // Handle any errors that occur during the fetch operation
    console.log(error);
    res.status(500).json({ message: "Server Error", error });
  }
};
// Get all KYC Rejected
export const getAllKycRejected = async (req, res) => {
  try {
    // Fetch all KYC documents from the database
    // console.log("req came here ");

    const kycs = await KYC.find({ status: "reject", addedBy: req.user._id })
      .sort({ createdAt: -1 })
      .populate("principal_distributer", "name")
      .populate("addedBy");
    // console.log(kycs);
    // Send the fetched data as a response
    res.status(200).json(kycs);
  } catch (error) {
    // Handle any errors that occur during the fetch operation
    console.log(error);
    res.status(500).json({ message: "Server Error", error });
  }
};
// Get All KYC Approved
export const getAllKycApproved = async (req, res) => {
  try {
    // Fetch all KYC documents from the database
    // console.log("req came here ");
    const kycs = await KYC.find({ status: "approved" })
      .sort({ createdAt: -1 })
      .populate("principal_distributer", "name")
      .populate("addedBy");
    // console.log(kycs);
    // Send the fetched data as a response
    res.status(200).json(kycs);
  } catch (error) {
    // Handle any errors that occur during the fetch operation
    console.log(error);
    res.status(500).json({ message: "Server Error", error });
  }
};
// Get Single KYC
export const getKycById = async (req, res) => {
  try {
    // Get the KYC ID from the request parameters
    const { id } = req.params;

    // Fetch the KYC document from the database by ID
    const kyc = await KYC.findById(id)
      .populate("principal_distributer", "name")
      .populate("addedBy");

    // Check if the KYC document exists
    if (!kyc) {
      return res.status(404).json({ message: "KYC document not found" });
    }

    // Send the fetched KYC document as a response
    res.status(200).json(kyc);
  } catch (error) {
    // Handle any errors that occur during the fetch operation
    res.status(500).json({ message: "Server Error", error });
  }
};

export const updateKycStatus = async (req, res) => {
  const { status, rejectionReason, user } = req.body;
  console.log(status);
  const { id } = req.params;
  // console.log(user, rejectionReason, status);
  try {
    // Find the KYC document by ID
    const kyc = await KYC.findById(id);

    if (!kyc) {
      return res.status(404).json({ message: "KYC record not found" });
    }
    if (kyc.principal_distributer.toString() !== req.user._id.toString()) {
      return res.status(403).json({ message: "Access denied" });
    }
    const trade_name = kyc.trade_name;
    if (status === "approved") {
      kyc.status = status;
      console.log("inside Approved ");
      await rejectKYC(
        kyc.addedBy,
        "KYC Approved",
        `Your KYC for ${trade_name} has been approved.`
      );
      await Notification.create({
        title: "KYC Approved",
        msg: `Your KYC for ${trade_name} has been approved.`,
        kyc_ref: kyc._id,
        added_for: kyc.addedBy,
        // userType: req.userType,
      });
    }
    if (status === "reject") {
      console.log("inside reject ");
      await rejectKYC(
        kyc.addedBy,
        "KYC application Rejected",
        `KYC for ${trade_name} has been rejected. Reason: ${rejectionReason}`
      );
      await Notification.create({
        title: "KYC Rejected",
        msg: `KYC for ${trade_name} has been rejected. Reason: ${rejectionReason}`,
        kyc_ref: kyc._id,
        added_for: kyc.addedBy,
        // userType: req.userType,
      });
    }
    // Update the status
    // if (status) {
    //   kyc.status = status;
    // }

    // Add rejection reason to notes if status is reject
    if (kyc.status === "reject" || status === "reject") {
      // kyc.rejection_reason = rejectionReason;
      if (status) {
        kyc.status = status;
      }

      kyc.notes.push({
        message: rejectionReason,
        user: user,
        replyDate: new Date(),
      });
    }

    // Save the updated KYC document
    await kyc.save();

    res.status(200).json({ message: "KYC status updated successfully", kyc });
  } catch (error) {
    console.log(error);
    res.status(500).json({ message: "Error updating KYC status", error });
  }
};

export const getAllPrincipalDistributers = async (req, res) => {
  try {
    // Define the filter for the query
    let filter = { role: "principal-Distributor" };
    // Check the user type and adjust the filter accordingly
    if (req.userType === "SalesCoOrdinator") {
      // If userType is "SalesCoOrdinator", filter by req.user.mappedBy
      filter.mappedby = req.user.mappedby;
    } else {
      // Otherwise, filter by req.user._id
      filter.mappedby = req.user._id;
    }
    console.log(filter);
    // Fetch the principal distributors based on the filter
    const principalDistributers = await User.find(filter);
console.log(principalDistributers);
    // Send the fetched data as a response
    if (principalDistributers.length > 0) {
      res.status(200).json(principalDistributers);
    } else {
      res.status(404).json({ message: "No Principal Distributors found" });
    }
  } catch (error) {
    // Handle any errors that occur during the fetch operation
    res.status(500).json({ message: "Server Error", error });
  }
};

// Fcm token storing
export const saveFCMTokenForSC = async (req, res) => {
  const { fcmToken } = req.body;
  const userId = req.user._id;

  try {
    // Fetch the current FCM token for the user
    const user = await SalesCoOrdinator.findById(userId);

    if (!user) {
      return res.status(404).send("User not found");
    }

    // Check if the new FCM token is different from the current one
    if (user.fcm_token && user.fcm_token === fcmToken) {
      return res.status(200).send("FCM Token is already up to date");
    }

    // Update the FCM token
    user.fcm_token = fcmToken;
    await user.save();

    res.status(200).send("FCM Token saved successfully");
  } catch (error) {
    console.error("Error saving FCM Token:", error);
    res.status(500).send("Internal Server Error");
  }
};

export const saveFCMTokenForTM = async (req, res) => {
  const { fcmToken } = req.body;
  const userId = req.user._id;

  try {
    // Fetch the current FCM token for the user
    const user = await TerritoryManager.findById(userId);

    if (!user) {
      return res.status(404).send("User not found");
    }

    // Check if the new FCM token is different from the current one
    if (user.fcm_token && user.fcm_token === fcmToken) {
      return res.status(200).send("FCM Token is already up to date");
    }

    // Update the FCM token
    user.fcm_token = fcmToken;
    await user.save();

    res.status(200).send("FCM Token saved successfully");
  } catch (error) {
    console.error("Error saving FCM Token:", error);
    res.status(500).send("Internal Server Error");
  }
};
export const getAllKycApprovedbytmid = async (req, res) => {
  try {
    const { id } = req.params; // Extracting `addedBy` ID from req.params
    const { tradename, page = 1, show = 10 } = req.query;

    const query = { status: "approved", mappedTM: id };

    if (tradename) {
      query.trade_name = new RegExp(tradename, "i");
    }

    const skip = (page - 1) * show;

    const retaildistributor = await KYC.find(query)
      .sort({ createdAt: -1 })
      .populate("principal_distributer")
      .populate("mappedTM")
      .populate("mappedSC")
      .populate("addedBy")
      .skip(skip)
      .limit(parseInt(show));
    const total_data = await KYC.countDocuments(query);
    // Send the fetched data as a response
    res.status(200).json({
      success: true,
      total_data: total_data,
      total_pages: Math.ceil(total_data / page),
      retaildistributor,
    });
  } catch (error) {
    // Handle any errors that occur during the fetch operation
    console.error(error);
    res.status(500).json({ message: "Server Error", error });
  }
};

export const updateKYCMapped = async (req, res) => {
  try {
    const { id } = req.params; // KYC document ID from params
    const { principal_distributor, mappedTM, mappedSC } = req.body; // Fields to update from the request body

    // Find the KYC document by ID
    const kyc = await KYC.findById(id);

    // If KYC not found, return 404
    if (!kyc) {
      return res.status(404).json({ message: "KYC record not found" });
    }

    // Update the fields only if they are provided in the request body
    if (principal_distributor) {
      kyc.principal_distributer = principal_distributor;
    }
    if (mappedTM) {
      kyc.mappedTM = mappedTM;
    }
    if (mappedSC) {
      kyc.mappedSC = mappedSC;
    }

    // Save the updated KYC document
    await kyc.save();

    // Send the updated KYC data as a response
    res.status(200).json({
      message: "KYC record updated successfully",
      data: kyc,
    });
  } catch (error) {
    // Handle any errors during the update
    res.status(500).json({
      message: "Error updating KYC record",
      error: error.message,
    });
  }
};