reinitializing codebase and resuming development

controllers/partner.controller.js

@@ -7,17 +7,74 @@ import {
   updatePartner,
   aggregatePartner,
 } from "../models/Partner/operations";
+import { aggregateAccess } from "../models/Access/operations";
+import {
+  createApproval,
+  updateApproval,
+  aggregateApproval,
+} from "../models/Approval/operations";
 import dayjs from "dayjs";
 import { ObjectId } from "mongodb";
 
 export const createPartnerController = async (req, res) => {
   try {
     const { user } = res.locals;
-    const partner = await createPartner({
+
+    const accessRole = await aggregateAccess([
+      {
+        $match: {
+          user: ObjectId.createFromHexString(user.id),
+        },
+      },
+      {
+        $lookup: {
+          from: "roles",
+          localField: "role",
+          foreignField: "_id",
+          as: "role",
+        },
+      },
+      {
+        $unwind: {
+          path: "$role",
+          preserveNullAndEmptyArrays: true,
+        },
+      },
+    ]);
+
+    console.log("ACCESS ROLE", accessRole[0]?.role?.modules);
+
+    const isAutoApproved = accessRole[0]?.role?.modules?.some(
+      ({ module, permission }) => {
+        return module === "partner" && permission === "authorize";
+      },
+    );
+
+    const partnerPayload = {
       ...req.body,
       createdBy: user.id,
       createdOn: dayjs().toISOString(),
-    });
+      temp: true,
+      isApproved: isAutoApproved,
+    };
+
+    const approvalPayload = {
+      entity: partner.id,
+      type: "partner",
+      createdBy: user.id,
+      createdOn: dayjs().toISOString(),
+    };
+
+    if (isAutoApproved) {
+      approvalPayload.approvedBy = user.id;
+      approvalPayload.approvedOn = dayjs().toISOString();
+      approvalPayload.isAutoApproved = true;
+      approvalPayload.isApproved = true;
+    }
+
+    const partner = await createPartner(partnerPayload);
+
+    const approval = await createApproval(approvalPayload);
     res.status(200).json({ result: partner });
   } catch (error) {
     console.log("createPartnerController Error", error);
@@ -39,37 +96,37 @@ export const getPartnerController = async (req, res, next) => {
       // 2. Fetch all invoices for this partner
       {
         $lookup: {
-          from: "invoices", // Ensure this matches your actual collection name
+          from: "orders", // Ensure this matches your actual collection name
           localField: "_id",
-          foreignField: "customer",
-          as: "partnerInvoices",
+          foreignField: "partner",
+          as: "partnerOrders",
         },
       },
 
       // 3. Calculate Invoice Metrics without unwinding (Satisfies Reqs #3, #4, #5)
       {
         $addFields: {
-          totalInvoicesCount: { $size: "$partnerInvoices" },
-          pendingOrPartialInvoicesCount: {
+          totalOrdersCount: { $size: "$partnerOrders" },
+          pendingOrPartialOrdersCount: {
             $size: {
               $filter: {
-                input: "$partnerInvoices",
-                as: "invoice",
+                input: "$partnerOrders",
+                as: "order",
                 cond: {
-                  $in: ["$$invoice.status", ["PENDING", "PARTIAL"]],
+                  $in: ["$$order.status", ["INPROGRESS", "COMPLETED"]],
                 },
               },
             },
           },
           // Note: Your schema uses "PAID", assuming that correlates to "COMPLETED"
-          totalInvoicesAmount: { $sum: "$partnerInvoices.total" },
+          totalOrdersAmount: { $sum: "$partnerOrders.total" },
         },
       },
 
       // 4. Remove the heavy invoices array from memory before doing more lookups
       {
         $project: {
-          partnerInvoices: 0,
+          partnerOrders: 0,
         },
       },
 
@@ -163,7 +220,7 @@ export const getPartnerController = async (req, res, next) => {
 
 export const getAllPartnersController = async (req, res) => {
   try {
-    const partners = await getAllPartners();
+    const partners = await getPartnersByQuery({ isApproved: true });
     res.status(200).json({ result: partners });
   } catch (error) {
     console.log("getAllPartnersController Error", error);
@@ -192,3 +249,59 @@ export const deletePartnerController = async (req, res, next) => {
     next(error);
   }
 };
+
+export const approvePartnerController = async (req, res, next) => {
+  try {
+    const { user } = res.locals;
+    const { id } = req.params;
+
+    const approval = await updateApproval(id, {
+      isApproved: true,
+      isAutoApproved: false,
+      approvedBy: user.id,
+      approvedOn: dayjs().toISOString(),
+    });
+
+    const partner = await updatePartner(approval.entity, {
+      isApproved: true,
+      temp: true,
+    });
+
+    res.status(200).json({ result: partner });
+  } catch (error) {
+    console.log("approvePartnerController Error", error);
+    next(error);
+  }
+};
+
+export const getUnapprovedPartnersController = async (req, res, next) => {
+  try {
+    const pipeline = [
+      {
+        $match: {
+          isApproved: false,
+        },
+      },
+      {
+        $lookup: {
+          from: "partners",
+          localField: "entity",
+          foreignField: "_id",
+          as: "partner",
+        },
+      },
+      {
+        $unwind: {
+          path: "$partner",
+        },
+      },
+    ];
+
+    const unapprovedPartners = await aggregateApproval(pipeline);
+
+    res.status(200).json({ result: unapprovedPartners });
+  } catch (error) {
+    console.log("getUnapprovedPartnersController Error", error);
+    next(error);
+  }
+};