my-typescript-library-rahul52us 3.0.8 → 4.1.0

package/src/repository/document.repository.ts

@@ -145,21 +145,7 @@ export async function withdrawalApprovalDocument(data: any) {
 
 export const findOneByDocumentIdAndDelete = async (data: any) => {
   try {
-    const doc = await Document.findOneAndDelete({ documentId: data.documentId });
-
-    if (!doc) {
-      return {
-        status: "error",
-        data: "Document does not exist",
-      };
-    }
-
-
-    doc.deleted_At = new Date();
-    await doc.save();
-
-    console.log(doc)
-
+    await Document.findOneAndDelete({ documentId: data.documentId });
     return {
       status: "success",
       data: "Document has been deleted successfully (soft delete)",
@@ -2379,3 +2365,775 @@ export const deleteAllDocuments = async () => {
     };
   }
 };
+
+
+export async function getDownloadExcelDocument(
+  noOfLevels: number,
+  workflow: string,
+  searchValue: string,
+  status: string,
+  company: string,
+  userId: any,
+  differentiateFirstLevel: any,
+  level: string,
+  sort: string | null = "1",
+  limit: string | null = "10",
+  page: string | null = "1",
+  exchangeType: any | null,
+  billType: string | null,
+  manual: string | null,
+  startDate: any,
+  endDate: any,
+  searchField: any,
+  dateFilterKey: string,
+  sortByKey: string,
+  additionalFiles: string[]
+) {
+  try {
+    let matchQuery: any = {};
+    matchQuery.status = { $ne: "rejected" };
+
+    if (searchField && searchValue?.trim()) {
+      matchQuery[`originalValues.${searchField}`] = {
+        $regex: searchValue,
+        $options: "i",
+      };
+    }
+
+    if (startDate) {
+      matchQuery[dateFilterKey] = { $gte: new Date(startDate) };
+    }
+
+    if (endDate) {
+      matchQuery[dateFilterKey] = {
+        ...matchQuery[dateFilterKey],
+        $lte: new Date(endDate),
+      };
+    }
+
+    var matchConditions: any = {
+      ...matchQuery,
+      // company: new mongoose.Types.ObjectId(company),
+      workflow: new mongoose.Types.ObjectId(workflow),
+      deleted_At: { $exists: false },
+    };
+
+    if (exchangeType && Array.isArray(exchangeType)) {
+      exchangeType.forEach((typeObj) => {
+        Object.entries(typeObj).forEach(([field, value]) => {
+          if (!matchConditions[`originalValues.${field}`]) {
+            matchConditions[`originalValues.${field}`] = [];
+          }
+          matchConditions[`originalValues.${field}`].push(value);
+        });
+      });
+    }
+
+    Object.entries(matchConditions).forEach(([field, value]) => {
+      if (Array.isArray(value)) {
+        matchConditions[field] = { $in: value };
+      }
+    });
+
+    let pipeline: any = [];
+
+    let expr: any = {};
+
+    let levels = generateLevels(noOfLevels);
+    switch (level) {
+      case levels[0]:
+        switch (status) {
+          case "pending":
+            expr = {
+              $expr: {
+                $and: [
+                  {
+                    $and: [
+                      {
+                        $not: [
+                          {
+                            $and: [
+                              {
+                                $in: [
+                                  { $arrayElemAt: ["$approval.status", -1] },
+                                  ["approved", "rejected"],
+                                ],
+                              },
+                              {
+                                $in: [
+                                  { $arrayElemAt: ["$approval.level", -1] },
+                                  [levels[0]],
+                                ],
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                      {
+                        $not: [
+                          {
+                            $and: [
+                              {
+                                $in: [
+                                  { $arrayElemAt: ["$approval.status", -1] },
+                                  ["approved"],
+                                ],
+                              },
+                              {
+                                $in: [
+                                  { $arrayElemAt: ["$approval.level", -1] },
+                                  [levels[levels.length - 1]],
+                                ],
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            };
+            break;
+          case "approved":
+            expr = {
+              $expr: {
+                $or: [
+                  {
+                    $and: [
+                      {
+                        $in: [
+                          { $arrayElemAt: ["$approval.status", -1] },
+                          [status],
+                        ],
+                      },
+                      {
+                        $in: [
+                          { $arrayElemAt: ["$approval.level", -1] },
+                          [levels[levels.length - 1], levels[0]],
+                        ],
+                      },
+                      {
+                        $not: [{ $eq: ["$approval", []] }],
+                      },
+                    ],
+                  },
+                ],
+              },
+            };
+            break;
+          case "rejected":
+            expr = {
+              $expr: {
+                $or: [
+                  {
+                    $and: [
+                      {
+                        $in: [
+                          { $arrayElemAt: ["$approval.status", -1] },
+                          [status],
+                        ],
+                      },
+                      {
+                        $in: [
+                          { $arrayElemAt: ["$approval.level", -1] },
+                          [levels[0]],
+                        ],
+                      },
+                      {
+                        $not: [{ $eq: ["$approval", []] }],
+                      },
+                    ],
+                  },
+                ],
+              },
+            };
+            break;
+        }
+
+        pipeline = [
+          {
+            $match: {
+              ...matchConditions,
+              ...expr,
+            },
+          },
+        ];
+        break;
+      default:
+        let { approvedRoles, rejectedRoles, approvedBy, rejectedBy } =
+          getDynamicRoles(noOfLevels, level);
+        switch (status) {
+          case "pending":
+            expr = {
+              $expr: {
+                $or: [
+                  {
+                    $and: [
+                      {
+                        $and: [
+                          {
+                            $not: [
+                              {
+                                $and: [
+                                  {
+                                    $in: [
+                                      {
+                                        $arrayElemAt: ["$approval.status", -1],
+                                      },
+                                      ["approved"],
+                                    ],
+                                  },
+                                  {
+                                    $in: [
+                                      {
+                                        $arrayElemAt: ["$approval.level", -1],
+                                      },
+                                      approvedRoles,
+                                    ],
+                                  },
+                                ],
+                              },
+                            ],
+                          },
+                          {
+                            $not: [
+                              {
+                                $and: [
+                                  {
+                                    $in: [
+                                      {
+                                        $arrayElemAt: ["$approval.status", -1],
+                                      },
+                                      ["rejected"],
+                                    ],
+                                  },
+                                  {
+                                    $in: [
+                                      {
+                                        $arrayElemAt: ["$approval.level", -1],
+                                      },
+                                      rejectedRoles,
+                                    ],
+                                  },
+                                ],
+                              },
+                            ],
+                          },
+                          level !== levels[1] && {
+                            $and: [
+                              {
+                                $in: [
+                                  {
+                                    $arrayElemAt: ["$approval.status", -1],
+                                  },
+                                  ["approved"],
+                                ],
+                              },
+                              {
+                                $in: [
+                                  {
+                                    $arrayElemAt: ["$approval.level", -1],
+                                  },
+                                  approvedBy,
+                                ],
+                              },
+                            ],
+                          },
+                          {
+                            $not: [{ $eq: ["$approval", []] }],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                  level !== levels[levels.length - 1] && {
+                    $and: [
+                      {
+                        $in: [
+                          {
+                            $arrayElemAt: ["$approval.status", -1],
+                          },
+                          ["rejected"],
+                        ],
+                      },
+                      {
+                        $in: [
+                          {
+                            $arrayElemAt: ["$approval.level", -1],
+                          },
+                          rejectedBy,
+                        ],
+                      },
+                    ],
+                  },
+                  level === levels[1] && {
+                    $and: [
+                      {
+                        $eq: ["$tags.extraction.type", "automatic"],
+                      },
+                      { $eq: ["$approval", []] },
+                    ],
+                  },
+                ],
+              },
+            };
+
+            // Only add the userId check for the first level if approval is not empty
+            // let userIdCheck = {};
+            // if (level === levels[1] && differentiateFirstLevel) {
+            //   userIdCheck = {
+            //     approval: {
+            //       $elemMatch: {
+            //         userId: { $in: [userId] },
+            //         level: levels[1],
+            //       },
+            //     },
+            //   };
+            // }
+
+            let userIdCheck = {};
+            if (level === levels[1] && differentiateFirstLevel) {
+              userIdCheck = {
+                user: userId, // Only the creator can access
+              };
+            }
+
+            pipeline = [
+              {
+                $match: {
+                  ...matchConditions,
+                  ...expr,
+                  ...userIdCheck,
+                },
+              },
+            ];
+            break;
+          case "approved":
+            pipeline = [
+              {
+                $addFields: {
+                  filteredApproval: {
+                    $filter: {
+                      input: "$approval",
+                      as: "item",
+                      cond: { $eq: ["$$item.level", level] },
+                    },
+                  },
+                },
+              },
+              {
+                $match: {
+                  ...matchConditions,
+                  $expr: {
+                    $and: [
+                      {
+                        $and: [
+                          {
+                            $eq: [
+                              {
+                                $arrayElemAt: ["$filteredApproval.status", -1],
+                              },
+                              status,
+                            ],
+                          },
+                        ],
+                      },
+                      {
+                        $cond: {
+                          if: differentiateFirstLevel,
+                          then: {
+                            $eq: [
+                              {
+                                $arrayElemAt: ["$filteredApproval.userId", -1],
+                              },
+                              userId,
+                            ],
+                          },
+                          else: true,
+                        },
+                      },
+                      {
+                        $not: [{ $eq: ["$approval", []] }],
+                      },
+                      {
+                        $not: [
+                          {
+                            $and: [
+                              {
+                                $in: [
+                                  {
+                                    $arrayElemAt: ["$approval.status", -1],
+                                  },
+                                  ["rejected"],
+                                ],
+                              },
+                              {
+                                $in: [
+                                  {
+                                    $arrayElemAt: ["$approval.level", -1],
+                                  },
+                                  rejectedBy,
+                                ],
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                      // {
+                      //   $not: [
+                      //     {
+                      //       $and: [
+                      //         {
+                      //           $in: [
+                      //             {
+                      //               $arrayElemAt: ["$approval.status", -1],
+                      //             },
+                      //             ["approved"],
+                      //           ],
+                      //         },
+                      //         {
+                      //           $in: [
+                      //             {
+                      //               $arrayElemAt: ["$approval.level", -1],
+                      //             },
+                      //             approvedBy,
+                      //           ],
+                      //         },
+                      //       ],
+                      //     },
+                      //   ],
+                      // }
+                    ],
+                  },
+                },
+              },
+            ];
+            break;
+          case "rejected":
+            pipeline = [
+              {
+                $addFields: {
+                  filteredApproval: {
+                    $filter: {
+                      input: "$approval",
+                      as: "item",
+                      cond: { $eq: ["$$item.level", level] },
+                    },
+                  },
+                },
+              },
+              {
+                $match: {
+                  ...matchConditions,
+                  $expr: {
+                    $and: [
+                      {
+                        $and: [
+                          {
+                            $eq: [
+                              {
+                                $arrayElemAt: ["$filteredApproval.status", -1],
+                              },
+                              status,
+                            ],
+                          },
+                        ],
+                      },
+                      {
+                        $cond: {
+                          if: differentiateFirstLevel,
+                          then: {
+                            $eq: [
+                              {
+                                $arrayElemAt: ["$filteredApproval.userId", -1],
+                              },
+                              userId,
+                            ],
+                          },
+                          else: true,
+                        },
+                      },
+                      {
+                        $not: [{ $eq: ["$approval", []] }],
+                      },
+                      // {
+                      //   $not: [
+                      //     {
+                      //       $and: [
+                      //         {
+                      //           $in: [
+                      //             {
+                      //               $arrayElemAt: ["$approval.status", -1],
+                      //             },
+                      //             ["rejected"],
+                      //           ],
+                      //         },
+                      //         {
+                      //           $in: [
+                      //             {
+                      //               $arrayElemAt: ["$approval.level", -1],
+                      //             },
+                      //             rejectedBy,
+                      //           ],
+                      //         },
+                      //       ],
+                      //     },
+                      //   ],
+                      // },
+                      {
+                        $not: [
+                          {
+                            $and: [
+                              {
+                                $in: [
+                                  {
+                                    $arrayElemAt: ["$approval.status", -1],
+                                  },
+                                  ["approved"],
+                                ],
+                              },
+                              {
+                                $in: [
+                                  {
+                                    $arrayElemAt: ["$approval.level", -1],
+                                  },
+                                  approvedBy,
+                                ],
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                },
+              },
+            ];
+        }
+        break;
+    }
+
+    if (manual && (level === levels[0] || level === levels[1])) {
+      pipeline = [
+        {
+          $match: {
+            ...matchQuery,
+            ...matchConditions,
+            "tags.extraction.type": "manual",
+            approval: { $eq: [] },
+          },
+        },
+      ];
+    } else if (manual) {
+      return {
+        data: [],
+        totalPages: 0,
+      };
+    }
+
+    const approvalStage: any = [
+      {
+        $unwind: {
+          path: "$approval",
+          preserveNullAndEmptyArrays: true,
+        },
+      },
+      {
+        $lookup: {
+          from: "fs.files",
+          localField: "approval.fileId",
+          foreignField: "_id",
+          as: "approval.fileDetails",
+        },
+      },
+      {
+        $unwind: {
+          path: "$approval.fileDetails",
+          preserveNullAndEmptyArrays: true,
+        },
+      },
+      {
+        $lookup: {
+          from: "accounts",
+          localField: "approval.userId",
+          foreignField: "_id",
+          as: "approval.userDetails",
+          pipeline: [
+            {
+              $project: {
+                _id: 1,
+                username: 1,
+                role: 1,
+                level: 1,
+              },
+            },
+          ],
+        },
+      },
+      {
+        $unwind: {
+          path: "$approval.userDetails",
+          preserveNullAndEmptyArrays: true,
+        },
+      },
+      {
+        $group: {
+          _id: "$_id",
+          document: { $first: "$$ROOT" },
+          approvals: {
+            $push: {
+              $mergeObjects: [
+                "$approval",
+                {
+                  file: "$approval.fileDetails",
+                  user: "$approval.userDetails",
+                },
+              ],
+            },
+          },
+        },
+      },
+      {
+        $addFields: {
+          "document.approval": {
+            $filter: {
+              input: "$approvals",
+              as: "approval",
+              cond: { $ne: ["$$approval", {}] },
+            },
+          },
+        },
+      },
+      {
+        $replaceRoot: {
+          newRoot: "$document",
+        },
+      },
+      {
+        $project: {
+          "approval.fileDetails": 0,
+          "approval.userDetails": 0,
+        },
+      },
+    ];
+
+    const lookupStages = additionalFiles.map((obj: any) => ({
+      $lookup: {
+        from: "fs.files",
+        localField: `additionalFiles.${obj}`,
+        foreignField: "_id",
+        as: obj,
+      },
+    }));
+
+    pipeline = [
+      ...pipeline,
+      {
+        $lookup: {
+          from: "fs.files",
+          localField: "file",
+          foreignField: "_id",
+          as: "file",
+        },
+      },
+      {
+        $unwind: {
+          path: "$additionalFiles",
+          preserveNullAndEmptyArrays: true,
+        },
+      },
+      {
+        $lookup: {
+          from: "fs.files",
+          localField: "additionalFiles.fileId",
+          foreignField: "_id",
+          as: "lookupResult",
+        },
+      },
+      {
+        $addFields: {
+          lookupResult: {
+            $cond: {
+              if: { $eq: [{ $size: "$lookupResult" }, 0] },
+              then: [{}],
+              else: "$lookupResult",
+            },
+          },
+        },
+      },
+      {
+        $group: {
+          _id: "$_id",
+          originalFields: { $first: "$$ROOT" },
+          additionalFilesDetails: {
+            $push: {
+              $mergeObjects: ["$additionalFiles", { $first: "$lookupResult" }],
+            },
+          },
+        },
+      },
+      {
+        $replaceRoot: {
+          newRoot: {
+            $mergeObjects: [
+              "$originalFields",
+              { additionalFilesDetails: "$additionalFilesDetails" },
+            ],
+          },
+        },
+      },
+      {
+        $lookup: {
+          from: "fs.files",
+          localField: "filexls",
+          foreignField: "_id",
+          as: "filexls",
+        },
+      },
+      ...lookupStages,
+      ...approvalStage,
+    ];
+
+    if (sortByKey) {
+      const sortStage: any = {};
+      if (sortByKey === "created_At" || sortByKey === "updated_At") {
+        sortStage[`${sortByKey}`] = Number(sort);
+      } else {
+        sortStage[`originalValues.${sortByKey}`] = Number(sort);
+      }
+      pipeline.push({
+        $sort: sortStage,
+      });
+    }
+
+    let countPipeline = [
+      ...pipeline,
+      { $group: { _id: null, count: { $sum: 1 } } },
+    ];
+    if (limit && page) {
+      const skip = (parseInt(page) - 1) * parseInt(limit);
+      pipeline.push({ $skip: skip } as any, { $limit: parseInt(limit) } as any);
+    }
+
+    const [pendingData, totalCount]: any = await Promise.all([
+      Document.aggregate(pipeline),
+      Document.aggregate(countPipeline),
+    ]);
+
+    // fs.writeFileSync('aggregationResult.json', JSON.stringify(pipeline, null, 2));
+
+    let totalPages;
+    if (limit) {
+      totalPages = Math.ceil(totalCount?.[0]?.count / parseInt(limit));
+    }
+
+    return {
+      data: pendingData,
+      totalPages,
+    };
+  } catch (error) {
+    console.log(error?.message);
+    throw new Error(error.message);
+  }
+}