tango-app-api-audit 1.0.41 → 1.0.42

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-audit",
-    "version": "1.0.41",
+    "version": "1.0.42",
     "description": "audit & audit metrics apis",
     "main": "index.js",
     "type": "module",

package/src/controllers/auditMetrics.controllers.js

@@ -63,14 +63,6 @@ export async function userAuditHistory( req, res ) {
     ];
 
 
-    if ( inputData.sortColumnName ) {
-      const sortBy = inputData.sortBy || -1;
-      query.push( {
-        $sort: { [inputData.sortColumName]: sortBy },
-      },
-      );
-    }
-
     query.push( {
       $lookup: {
         from: 'stores',
@@ -93,17 +85,50 @@ export async function userAuditHistory( req, res ) {
 
     } );
 
+
     query.push( {
       $unwind: {
         path: '$store', preserveNullAndEmptyArrays: true,
       },
     } );
 
+    query.push( {
+      $lookup: {
+        from: 'clients',
+        let: { clientId: '$clientId' },
+        pipeline: [
+          {
+            $match: {
+              $expr: {
+                $eq: [ '$clientId', '$$clientId' ],
+              },
+            },
+          },
+          {
+            $project: {
+              clientName: 1,
+            },
+          },
+        ], as: 'client',
+      },
+
+    } );
+
+
+    query.push( {
+      $unwind: {
+        path: '$client', preserveNullAndEmptyArrays: true,
+      },
+    } );
+
     query.push( {
       $project: {
         storeId: 1,
         userId: 1,
         storeName: '$store.storeName',
+        clientId: 1,
+        clientName: 'client.clientName',
+        fileDate: 1,
         auditType: 1,
         zoneName: 1,
         moduleType: 1,
@@ -112,14 +137,51 @@ export async function userAuditHistory( req, res ) {
         accuracy: { $round: [
           {
             $divide: [ { $multiply: [ '$beforeCount', { $ifNull: [ '$afterCount', 0 ] } ] }, 100 ],
-          }, 2,
+          }, 1,
         ],
         },
-        startTime: 1,
-        endTime: 1,
-        timeSpent: { $round: [
-          { $divide: [ '$timeSpent', 60 ] }, 2,
-        ] },
+        startTime: {
+          $dateToString: {
+            format: '%Y-%m-%d %H:%M:%S',
+            date: '$startTime',
+            timezone: 'Asia/Kolkata',
+          },
+        },
+        endTime: {
+          $dateToString: {
+            format: '%Y-%m-%d %H:%M:%S',
+            date: '$endTime',
+            timezone: 'Asia/Kolkata',
+          },
+        },
+        // timeSpent: { $round: [
+        //   { $divide: [ '$timeSpent', 60 ] }, 2,
+        // ] },
+        timeSpent: {
+
+          $cond: [
+            { $lt: [ '$timeSpent', 60 ] }, // Case 1: If less than 60 seconds
+            { $concat: [ { $toString: '$timeSpent' }, ' sec' ] },
+            {
+              $cond: [
+                { $lt: [ '$timeSpent', 3600 ] }, // Case 2: If less than 60 minutes (3600 seconds)
+                {
+                  $concat: [
+                    { $toString: { $round: [ { $divide: [ '$timeSpent', 60 ] }, 1 ] } }, // Convert to minutes
+                    ' min',
+                  ],
+                },
+                {
+                  $concat: [
+                    { $toString: { $round: [ { $divide: [ '$timeSpent', 3600 ] }, 1 ] } }, // Convert to hours
+                    ' hr',
+                  ],
+                },
+              ],
+            },
+          ],
+
+        },
         auditStatus: 1,
         createdAt: 1,
       },
@@ -129,17 +191,26 @@ export async function userAuditHistory( req, res ) {
       query.push( {
         $match: {
           $or: [
+            { clientName: { $regex: inputData.searchValue, $options: 'i' } },
+            { clientType: { $regex: inputData.searchValue, $options: 'i' } },
             { zoneName: { $regex: inputData.searchValue, $options: 'i' } },
-            { storeId: { $regex: inputData.storeId, $options: 'i' } },
-            { storeName: { $regex: inputData.storeName, $options: 'i' } },
-            { moduleType: { $regex: inputData.moduleType, $options: 'i' } },
-            { auditStatus: { $regex: inputData.auditStatus, $options: 'i' } },
+            { storeId: { $regex: inputData.searchValue, $options: 'i' } },
+            { storeName: { $regex: inputData.searchValue, $options: 'i' } },
+            { moduleType: { $regex: inputData.searchValue, $options: 'i' } },
+            { auditStatus: { $regex: inputData.searchValue, $options: 'i' } },
           ],
 
         },
       } );
     }
 
+    if ( inputData.sortColumnName ) {
+      const sortBy = inputData.sortBy || -1;
+      query.push( {
+        $sort: { [inputData.sortColumName]: sortBy },
+      },
+      );
+    }
     const count = await aggregateUserAudit( query );
     if ( count.length == 0 ) {
       return res.sendError( 'No Data Found', 204 );
@@ -151,6 +222,8 @@ export async function userAuditHistory( req, res ) {
         const exportData = [];
         chunk.forEach( ( element ) => {
           exportData.push( {
+            'Client Id': element.clientId,
+            'Client Name': element.clientName,
             'Store Id': element.storeId,
             'Store Name': element.storeName,
             'Type': element.auditType,
@@ -163,7 +236,7 @@ export async function userAuditHistory( req, res ) {
             'End Time': element.endTime,
             'Time Spent': element.timeSpent,
             'Audit Status': element.auditStatus,
-            'CreatedAt': element.createdAt,
+            'CreatedAt': dayjs( element.createdAt ).format( 'YYYY,MMM D' ),
 
           } );
         } );
@@ -184,7 +257,7 @@ export async function userAuditHistory( req, res ) {
     } );
     const result = await aggregateUserAudit( query );
 
-    return res.sendSuccess( { result: result } );
+    return res.sendSuccess( { result: result, count: count.length } );
   } catch ( error ) {
     const err = error.message || 'Internal Server Error';
     logger.info( { error: error, message: req.body, function: 'userAuditHistory' } );
@@ -214,6 +287,10 @@ export async function storeMetrics( req, res ) {
       filter.push( { status: { $in: inputData.filterByStatus } } );
     }
 
+    if ( inputData.filterByType && inputData.filterByType?.length > 0 ) {
+      filter.push( { auditType: { $in: inputData.filterByType } } );
+    }
+
 
     const query = [
       {
@@ -221,16 +298,45 @@ export async function storeMetrics( req, res ) {
           $and: filter,
         },
       },
+
+      {
+        $lookup: {
+          from: 'stores',
+          let: { storeId: '$storeId' },
+          pipeline: [
+            {
+              $match: {
+                $expr: {
+                  $eq: [ '$storeId', '$$storeId' ],
+                },
+              },
+            },
+            {
+              $project: {
+                _id: 0,
+                storeName: 1,
+              },
+            },
+          ], as: 'stores',
+        },
+      },
+      {
+        $unwind: {
+          path: '$stores',
+          preserveNullAndEmptyArrays: true,
+        },
+      },
       {
         $project: {
           _id: 0,
           fileDate: 1,
           storeId: 1,
-          storeName: '$storeId',
+          storeName: '$store.storeName',
+          clientName: '',
+          clientId: 1,
           userId: {
             $arrayElemAt: [ '$userId', { $subtract: [ { $size: '$userId' }, 1 ] } ],
           },
-          clientId: 1,
           auditType: 1,
           beforeCount: 1,
           afterCount: { $ifNull: [ '$afterCount', null ] },
@@ -247,56 +353,56 @@ export async function storeMetrics( req, res ) {
       },
       {
         $lookup: {
-          from: 'stores',
-          let: { storeId: '$storeId' },
+          from: 'users',
+          let: { userId: '$userId' },
           pipeline: [
             {
               $match: {
                 $expr: {
-                  $eq: [ '$storeId', '$$storeId' ],
+                  $eq: [ '$_id', '$$userId' ],
                 },
               },
             },
             {
               $project: {
                 _id: 0,
-                storeName: 1,
+                userName: 1,
+                userEmail: '$email',
               },
             },
-          ], as: 'stores',
+          ], as: 'users',
         },
       },
       {
         $unwind: {
-          path: '$stores',
+          path: '$users',
           preserveNullAndEmptyArrays: true,
         },
       },
       {
         $lookup: {
-          from: 'users',
-          let: { userId: '$userId' },
+          from: 'clients',
+          let: { clientId: '$clientId' },
           pipeline: [
             {
               $match: {
                 $expr: {
-                  $eq: [ '$_id', '$$userId' ],
+                  $eq: [ '$clientId', '$$clientId' ],
                 },
               },
             },
             {
               $project: {
                 _id: 0,
-                userName: 1,
-                userEmail: '$email',
+                clientName: 1,
               },
             },
-          ], as: 'users',
+          ], as: 'client',
         },
       },
       {
         $unwind: {
-          path: '$users',
+          path: '$client',
           preserveNullAndEmptyArrays: true,
         },
       },
@@ -308,19 +414,43 @@ export async function storeMetrics( req, res ) {
           storeName: '$stores.storeName',
           userName: '$users.userName',
           userEmail: '$users.userEmail',
-
           clientId: 1,
+          clientName: '$client.clientName',
           auditType: 1,
           beforeCount: 1,
           afterCount: { $ifNull: [ '$afterCount', null ] },
           accuracy: { $round: [
             { $divide: [
               { $multiply: [ { $ifNull: [ '$afterCount', 0 ] }, '$beforeCount' ] }, 100,
-            ] }, 2,
+            ] }, 1,
           ],
 
           },
-          timeSpent: 1,
+          timeSpent: {
+
+            $cond: [
+              { $lt: [ '$timeSpent', 60 ] }, // Case 1: If less than 60 seconds
+              { $concat: [ { $toString: '$timeSpent' }, ' sec' ] },
+              {
+                $cond: [
+                  { $lt: [ '$timeSpent', 3600 ] }, // Case 2: If less than 60 minutes (3600 seconds)
+                  {
+                    $concat: [
+                      { $toString: { $round: [ { $divide: [ '$timeSpent', 60 ] }, 1 ] } }, // Convert to minutes
+                      ' min',
+                    ],
+                  },
+                  {
+                    $concat: [
+                      { $toString: { $round: [ { $divide: [ '$timeSpent', 3600 ] }, 1 ] } }, // Convert to hours
+                      ' hr',
+                    ],
+                  },
+                ],
+              },
+            ],
+
+          },
           status: 1,
         },
       },
@@ -333,10 +463,23 @@ export async function storeMetrics( req, res ) {
           $or: [
             { clientId: { $regex: inputData.searchValue, $options: 'i' } },
             { clientName: { $regex: inputData.searchValue, $options: 'i' } },
+            { storeId: { $regex: inputData.searchValue, $options: 'i' } },
+            { storeName: { $regex: inputData.searchValue, $options: 'i' } },
+            { userName: { $regex: inputData.searchValue, $options: 'i' } },
+            { status: { $regex: inputData.searchValue, $options: 'i' } },
+            { auditType: { $regex: inputData.searchValue, $options: 'i' } },
           ],
         },
       } );
     }
+
+    if ( inputData.sortColumnName ) {
+      const sortBy = inputData.sortBy || -1;
+      query.push( {
+        $sort: { [inputData.sortColumName]: sortBy },
+      },
+      );
+    }
     const count = await aggregateStoreAudit( query );
 
     if ( count.length == 0 ) {
@@ -361,6 +504,7 @@ export async function storeMetrics( req, res ) {
           'Store Id': element.storeId,
           'Store Name': element.storeName,
           'Client Id': element.clientId,
+          'Client Name': element.clientName,
           'User Name': element.userName,
           'User Email': element.userEmail,
           'Audit Type': element.auditType,
@@ -389,6 +533,7 @@ export async function clientMetrics( req, res ) {
     let filter = [
       { fileDateISO: { $gte: dateRange.start } },
       { fileDateISO: { $lte: dateRange.end } },
+      { moduleType: { $eq: 'traffic' } },
 
     ];
     if ( inputData?.filterByClient?.length> 0 ) {
@@ -396,11 +541,6 @@ export async function clientMetrics( req, res ) {
           { clientId: { $in: inputData.filterByClient } },
       );
     }
-    if ( inputData?.filterByAuditType?.length> 0 ) {
-      filter.push(
-          { clientId: { $in: inputData.filterByAuditType } },
-      );
-    }
     const query = [
       {
         $match: {
@@ -438,6 +578,7 @@ export async function clientMetrics( req, res ) {
             {
               $project: {
                 completedStores: { $cond: [ { $eq: [ '$status', 'completed' ] }, 1, 0 ] },
+                notAssignedStores: { $cond: [ { $eq: [ '$status', 'not_assign' ] }, 1, 0 ] },
                 inprogressStores: { $cond: [ { $in: [ '$status', [ 'inprogress', 'drafted', 'assigned' ] ] }, 1, 0 ] },
               },
             },
@@ -446,6 +587,8 @@ export async function clientMetrics( req, res ) {
                 _id: { clientId: '$clientId', fileDate: '$fileDate' },
                 completedStores: { $sum: '$completedStores' },
                 inprogressStores: { $sum: '$inprogressStores' },
+                notAssignedStores: { $sum: '$notAssignedStores' },
+                fileCount: { $sum: 1 },
               },
             },
             {
@@ -453,6 +596,8 @@ export async function clientMetrics( req, res ) {
                 _id: 0,
                 completedStores: 1,
                 inprogressStores: 1,
+                notAssignedStores: 1,
+                fileCount: 1,
                 completionPercentage: { $ifNull: [
                   {
                     $round: [ {
@@ -487,15 +632,18 @@ export async function clientMetrics( req, res ) {
           clientName: 1,
           totalFilesCount: 1,
           installedStore: 1,
+          notAssignedStores: '$storeAudit.notAssignedStores',
           inprogressStoresCount: '$storeAudit.inprogressStores',
+          fileCount: '$storeAudit.fileCount',
           notAssignedCount: 1,
-          clientStatus: { $cond: [ { $gt: [ '$storeAudit.inprogressStores', 0 ] }, 'not-taken', { $cond: [ { $gt: [ '$notAssignedCount', 0 ] }, 'pending', 'completed' ] } ] },
+          clientStatus: { $cond: [ { $eq: [ '$storeAudit.fileCount', 0 ] }, 'not-taken', { $cond: [ { $or: [ { $gt: [ '$notAssignedCount', 0 ] }, { $gt: [ '$storeAudit.notAssignedStores', 0 ] } ] }, 'pending', 'completed' ] } ] },
           completedStores: '$storeAudit.completedStores',
           completionPercentage: '$storeAudit.completionPercentage',
 
         },
       },
     ];
+
     if ( inputData.searchValue && inputData.searchValue!== '' ) {
       query.push( {
         $match: {
@@ -537,6 +685,7 @@ export async function clientMetrics( req, res ) {
               'Audit Stores': '$totalFilesCount',
               'Inprogress Stores': '$inprogressStoresCount',
               'Not Assigned': '$notAssignedCount',
+              'Not Assigned Stores': '$notAssignedStores',
               'Completed': '$completedStores',
               'Status': '$clientStatus',
             },
@@ -580,7 +729,7 @@ export async function userMetrics( req, res ) {
     }
     if ( inputData?.filterByAuditType?.length> 0 ) {
       filter.push(
-          { clientId: { $in: inputData.filterByAuditType } },
+          { moduleType: { $in: inputData.filterByAuditType } },
       );
     }
     if ( inputData?.filterByStatus?.length> 0 ) {
@@ -609,9 +758,8 @@ export async function userMetrics( req, res ) {
           startTime: 1,
           endTime: 1,
           totalCompletedFiles: { $cond: [ { $eq: [ '$auditStatus', 'completed' ] }, 1, 0 ] },
-          beforeCount: { $cond: [ { $eq: [ '$auditStatus', 'completed' ] }, '$beforeCount', 0 ] },
+          beforeCount: 1,
           afterCount: { $cond: [ { $eq: [ '$auditStatus', 'completed' ] }, '$afterCount', 0 ] },
-          zoneName: 1,
         },
       },
       {
@@ -624,7 +772,6 @@ export async function userMetrics( req, res ) {
           afterCount: { $sum: '$afterCount' },
           checkIntime: { $first: '$startTime' },
           checkOutTime: { $last: '$endTime' },
-          zoneName: { $last: '$zoneNmae' },
 
         },
       },
@@ -636,7 +783,6 @@ export async function userMetrics( req, res ) {
           totalCompletedFiles: 1,
           beforeCount: 1,
           afterCount: 1,
-          zoneName: 1,
           mappingPerc: { $round: [
             { $multiply: [
               { $divide: [ '$afterCount', '$beforeCount' ] }, 100,
@@ -658,7 +804,6 @@ export async function userMetrics( req, res ) {
           afterCount: 1,
           checkIntime: 1,
           checkOutTime: 1,
-          zoneName: 1,
           mappingPerc: 1,
           hours: { $floor: { $divide: [ '$differenceInSeconds', 3600 ] } },
           minutes: { $floor: { $divide: [ { $mod: [ '$differenceInSeconds', 3600 ] }, 60 ] } },
@@ -675,7 +820,6 @@ export async function userMetrics( req, res ) {
           afterCount: 1,
           checkIntime: 1,
           checkOutTime: 1,
-          zoneName: 1,
           hours: {
             $cond: {
               if: { $lt: [ '$hours', 10 ] },
@@ -748,12 +892,23 @@ export async function userMetrics( req, res ) {
           userName: '$userInfo.userName',
           userId: 1,
           fileDate: 1,
-          zoneName: 1,
           totalCompletedFiles: 1,
           beforeCount: 1,
           afterCount: 1,
-          checkIntime: 1,
-          checkOutTime: 1,
+          checkIntime: {
+            $dateToString: {
+              format: '%Y-%m-%d %H:%M:%S',
+              date: '$checkIntime',
+              timezone: 'Asia/Kolkata',
+            },
+          },
+          checkOutTime: {
+            $dateToString: {
+              format: '%Y-%m-%d %H:%M:%S',
+              date: '$checkOutTime',
+              timezone: 'Asia/Kolkata',
+            },
+          },
           workingHours: 1,
         },
       },
@@ -762,7 +917,7 @@ export async function userMetrics( req, res ) {
       query.push( {
         $match: {
           $or: [
-            { clientId: { $regex: inputData.searchValue, $options: 'i' } },
+            { userName: { $regex: inputData.searchValue, $options: 'i' } },
             { clientName: { $regex: inputData.searchValue, $options: 'i' } },
           ],
 
@@ -794,7 +949,6 @@ export async function userMetrics( req, res ) {
               'File Date': '$fileDate',
               'User Name': '$userName',
               'User Id': '$userId',
-              'Zone Name': '$zoneName',
               'Total Completed Files Count': '$totalCompletedFiles',
               'Total efore Count': '$beforeCount',
               'Total After Count': '$afterCount',

package/src/controllers/zoneAudit.controller.js

@@ -921,6 +921,10 @@ export async function storeMetrics( req, res ) {
       filter.push( { status: { $in: inputData.filterByStatus } } );
     }
 
+    if ( inputData.filterByType && inputData.filterByType?.length > 0 ) {
+      filter.push( { auditType: { $in: inputData.filterByType } } );
+    }
+
     const query = [
       {
         $match: {
@@ -958,6 +962,8 @@ export async function storeMetrics( req, res ) {
           fileDate: 1,
           storeId: 1,
           storeName: '$store.storeName',
+          clientName: '',
+          clientId: 1,
           userId: {
             $arrayElemAt: [ '$userId', { $subtract: [ { $size: '$userId' }, 1 ] } ],
           },
@@ -978,56 +984,56 @@ export async function storeMetrics( req, res ) {
       },
       {
         $lookup: {
-          from: 'stores',
-          let: { storeId: '$storeId' },
+          from: 'users',
+          let: { userId: '$userId' },
           pipeline: [
             {
               $match: {
                 $expr: {
-                  $eq: [ '$storeId', '$$storeId' ],
+                  $eq: [ '$_id', '$$userId' ],
                 },
               },
             },
             {
               $project: {
                 _id: 0,
-                storeName: 1,
+                userName: 1,
+                userEmail: '$email',
               },
             },
-          ], as: 'stores',
+          ], as: 'users',
         },
       },
       {
         $unwind: {
-          path: '$stores',
+          path: '$users',
           preserveNullAndEmptyArrays: true,
         },
       },
       {
         $lookup: {
-          from: 'users',
-          let: { userId: '$userId' },
+          from: 'clients',
+          let: { clientId: '$clientId' },
           pipeline: [
             {
               $match: {
                 $expr: {
-                  $eq: [ '$_id', '$$userId' ],
+                  $eq: [ '$clientId', '$$clientId' ],
                 },
               },
             },
             {
               $project: {
                 _id: 0,
-                userName: 1,
-                userEmail: '$email',
+                clientName: 1,
               },
             },
-          ], as: 'users',
+          ], as: 'client',
         },
       },
       {
         $unwind: {
-          path: '$users',
+          path: '$client',
           preserveNullAndEmptyArrays: true,
         },
       },
@@ -1039,19 +1045,43 @@ export async function storeMetrics( req, res ) {
           storeName: '$stores.storeName',
           userName: '$users.userName',
           userEmail: '$users.userEmail',
-
           clientId: 1,
+          clientName: '$client.clientName',
           auditType: 1,
           beforeCount: 1,
           afterCount: { $ifNull: [ '$afterCount', null ] },
           accuracy: { $round: [
             { $divide: [
               { $multiply: [ { $ifNull: [ '$afterCount', 0 ] }, '$beforeCount' ] }, 100,
-            ] }, 2,
+            ] }, 1,
           ],
 
           },
-          timeSpent: 1,
+          timeSpent: {
+
+            $cond: [
+              { $lt: [ '$timeSpent', 60 ] }, // Case 1: If less than 60 seconds
+              { $concat: [ { $toString: '$timeSpent' }, ' sec' ] },
+              {
+                $cond: [
+                  { $lt: [ '$timeSpent', 3600 ] }, // Case 2: If less than 60 minutes (3600 seconds)
+                  {
+                    $concat: [
+                      { $toString: { $round: [ { $divide: [ '$timeSpent', 60 ] }, 1 ] } }, // Convert to minutes
+                      ' min',
+                    ],
+                  },
+                  {
+                    $concat: [
+                      { $toString: { $round: [ { $divide: [ '$timeSpent', 3600 ] }, 1 ] } }, // Convert to hours
+                      ' hr',
+                    ],
+                  },
+                ],
+              },
+            ],
+
+          },
           status: 1,
         },
       },
@@ -1064,10 +1094,24 @@ export async function storeMetrics( req, res ) {
           $or: [
             { clientId: { $regex: inputData.searchValue, $options: 'i' } },
             { clientName: { $regex: inputData.searchValue, $options: 'i' } },
+            { storeId: { $regex: inputData.searchValue, $options: 'i' } },
+            { storeName: { $regex: inputData.searchValue, $options: 'i' } },
+            { userName: { $regex: inputData.searchValue, $options: 'i' } },
+            { status: { $regex: inputData.searchValue, $options: 'i' } },
+            { auditType: { $regex: inputData.searchValue, $options: 'i' } },
           ],
         },
       } );
     }
+
+    if ( inputData.sortColumnName ) {
+      const sortBy = inputData.sortBy || -1;
+      query.push( {
+        $sort: { [inputData.sortColumName]: sortBy },
+      },
+      );
+    }
+
     const count = await aggregateStoreZoneAudit( query );
 
     if ( count.length == 0 ) {
@@ -1092,6 +1136,7 @@ export async function storeMetrics( req, res ) {
           'Store Id': element.storeId,
           'Store Name': element.storeName,
           'Client Id': element.clientId,
+          'Client Name': element.clientName,
           'User Name': element.userName,
           'User Email': element.userEmail,
           'Audit Type': element.auditType,
@@ -1110,3 +1155,186 @@ export async function storeMetrics( req, res ) {
     return res.sendError( err, 500 );
   }
 }
+
+export async function clientMetrics( req, res ) {
+  try {
+    const inputData = req.body;
+    const limit = inputData.limit || 10;
+    const offset = inputData.offset ? ( inputData.offset - 1 ) * limit : 0;
+    const dateRange = await getUTC( new Date( inputData.fromDate ), new Date( inputData.toDate ) );
+    let filter = [
+      { fileDateISO: { $gte: dateRange.start } },
+      { fileDateISO: { $lte: dateRange.end } },
+      { moduleType: { $eq: 'zone' } },
+
+    ];
+    if ( inputData?.filterByClient?.length> 0 ) {
+      filter.push(
+          { clientId: { $in: inputData.filterByClient } },
+      );
+    }
+    const query = [
+      {
+        $match: {
+          $and: filter,
+        },
+      },
+      {
+        $project: {
+          fileDate: 1,
+          clientId: 1,
+          clientName: 1,
+          queueName: 1,
+          installedStore: 1,
+          totalFilesCount: 1,
+          notAssignedCount: { $ifNull: [ 0, 0 ] },
+          clientStatus: { $ifNull: [ '', '' ] },
+        },
+      },
+      {
+        $lookup: {
+          'from': 'storeZoneAudit',
+          'let': { clientId: '$clientId', fileDate: '$fileDate', totalAuditFiles: '$totalAuditFiles' },
+          'pipeline': [
+
+            {
+              $match: {
+                $expr: {
+                  $and: [
+                    { $eq: [ '$clientId', '$$clientId' ] },
+                    { $eq: [ '$fileDate', '$$fileDate' ] },
+                  ],
+                },
+              },
+            },
+            {
+              $project: {
+                completedStores: { $cond: [ { $eq: [ '$status', 'completed' ] }, 1, 0 ] },
+                notAssignedStores: { $cond: [ { $eq: [ '$status', 'not_assign' ] }, 1, 0 ] },
+                inprogressStores: { $cond: [ { $in: [ '$status', [ 'inprogress', 'drafted', 'assigned' ] ] }, 1, 0 ] },
+              },
+            },
+            {
+              $group: {
+                _id: { clientId: '$clientId', fileDate: '$fileDate' },
+                completedStores: { $sum: '$completedStores' },
+                inprogressStores: { $sum: '$inprogressStores' },
+                notAssignedStores: { $sum: '$notAssignedStores' },
+                fileCount: { $sum: 1 },
+              },
+            },
+            {
+              $project: {
+                _id: 0,
+                completedStores: 1,
+                inprogressStores: 1,
+                notAssignedStores: 1,
+                fileCount: 1,
+                completionPercentage: { $ifNull: [
+                  {
+                    $round: [ {
+                      $multiply: [
+                        100, {
+                          $divide: [
+                            '$completedStores', '$$totalAuditFiles',
+                          ],
+                        },
+                      ],
+                    }, 1 ],
+
+                  },
+                  0,
+                ],
+                },
+              },
+            },
+          ], 'as': 'storeZoneAudit',
+        },
+      },
+      {
+        $unwind: {
+          path: '$storeZoneAudit',
+          preserveNullAndEmptyArrays: true,
+        },
+      },
+      {
+        $project: {
+          fileDate: 1,
+          clientId: 1,
+          clientName: 1,
+          totalFilesCount: 1,
+          installedStore: 1,
+          fileCount: '$storeZoneAudit.fileCount',
+          notAssignedStores: '$storeZoneAudit.notAssignedStores',
+          inprogressStoresCount: '$storeZoneAudit.inprogressStores',
+          notAssignedCount: 1,
+          clientStatus: { $cond: [ { $eq: [ '$storeZoneAudit.fileCount', 0 ] }, 'not-taken', { $cond: [ { $or: [ { $gt: [ '$notAssignedCount', 0 ] }, { $gt: [ '$storeZoneAudit.notAssignedStores', 0 ] } ] }, 'pending', 'completed' ] } ] },
+          completedStores: '$storeZoneAudit.completedStores',
+          completionPercentage: '$storeZoneAudit.completionPercentage',
+
+        },
+      },
+    ];
+
+    if ( inputData.searchValue && inputData.searchValue!== '' ) {
+      query.push( {
+        $match: {
+          $or: [
+            { clientId: { $regex: inputData.searchValue, $options: 'i' } },
+            { clientName: { $regex: inputData.searchValue, $options: 'i' } },
+          ],
+
+        },
+      } );
+    }
+    if ( inputData.sortColumnName ) {
+      const sortBy = inputData.sortBy || -1;
+      query.push( {
+        $sort: { [inputData.sortColumName]: sortBy },
+      },
+      );
+    }
+
+    const count = await aggregateAuditClientData( query );
+    if ( count.length == 0 ) {
+      return res.sendError( 'No Data Found', 204 );
+    }
+
+    query.push(
+        { $skip: offset },
+        { $limit: limit },
+    );
+    if ( inputData.isExport ) {
+      query.push(
+          {
+            $project: {
+              '_id': 0,
+              'File Date': '$fileDate',
+              'Client Name': '$clientName',
+              'Client Id': '$clientId',
+              'Completed Percentage': '$completionPercentage',
+              'Installed Stores': '$installedStore',
+              'Audit Stores': '$totalFilesCount',
+              'Inprogress Stores': '$inprogressStoresCount',
+              'Not Assigned': '$notAssignedCount',
+              'Not Assigned Stores': '$notAssignedStores',
+              'Completed': '$completedStores',
+              'Status': '$clientStatus',
+            },
+          },
+      );
+    }
+
+
+    const result = await aggregateAuditClientData( query );
+    if ( inputData.isExport ) {
+      await download( result, res );
+      return;
+    }
+    return res.sendSuccess( { result: result, count: count.length } );
+  } catch ( error ) {
+    const err = error.error || 'Internal Server Error';
+    logger.info( { error: error, message: req.body, function: 'clientMetrics' } );
+    return res.sendError( err, 500 );
+  }
+}

package/src/docs/zoneAudit.docs.js

@@ -1,5 +1,5 @@
 import j2s from 'joi-to-swagger';
-import { getDraftedDataSchema, getFileSchema, saveDraftSchema, saveSchema, storeMetricsSchema, workSpaceSchema } from '../dtos/zoneAudit.dtos.js';
+import { clientMetricsSchema, getDraftedDataSchema, getFileSchema, saveDraftSchema, saveSchema, storeMetricsSchema, workSpaceSchema } from '../dtos/zoneAudit.dtos.js';
 
 export const zoneAuditDocs = {
   '/v3/zone-audit/get-file': {
@@ -179,4 +179,27 @@ export const zoneAuditDocs = {
     },
   },
 
+  '/v3/zone-audit/metrics/client-metrics': {
+    post: {
+      tags: [ 'Zone Audit Metrics' ],
+      description: `Get list of client wise details with date range`,
+      operationId: 'metrics/client-metrics',
+      parameters: {},
+      requestBody: {
+        content: {
+          'application/json': {
+            schema: j2s( clientMetricsSchema ).swagger,
+          },
+        },
+      },
+      responses: {
+        200: { description: 'Successful' },
+        401: { description: 'Unauthorized User' },
+        422: { description: 'Field Error' },
+        500: { description: 'Server Error' },
+        204: { description: 'Not Found' },
+      },
+    },
+  },
+
 };

package/src/dtos/auditMetrics.dtos.js

@@ -45,7 +45,7 @@ export const storeMetricsSchema = joi.object(
       filterByClientId: joi.array().required(),
       filterByStoreId: joi.array().optional(),
       filterByStatus: joi.array().optional(),
-      filterByAuditType: joi.array().optional(),
+      filterByType: joi.array().optional(),
       sortColumnName: joi.string().optional(),
       sortBy: joi.number().optional(),
       limit: joi.number().optional(),
@@ -62,7 +62,6 @@ export const clientMetricsSchema = joi.object(
     {
       fromDate: joi.string().required(),
       toDate: joi.string().required(),
-      filterByAuditType: joi.array().optional(),
       searchValue: joi.string().optional().allow( '' ),
       filterByClient: joi.array().required(),
       filterByStatus: joi.array().optional(),

package/src/dtos/zoneAudit.dtos.js

@@ -108,3 +108,22 @@ export const storeMetricsValid = {
   body: storeMetricsSchema,
 };
 
+export const clientMetricsSchema = joi.object(
+    {
+      fromDate: joi.string().required(),
+      toDate: joi.string().required(),
+      searchValue: joi.string().optional().allow( '' ),
+      filterByClient: joi.array().required(),
+      filterByStatus: joi.array().optional(),
+      sortColumnName: joi.string().optional(),
+      sortBy: joi.number().optional(),
+      limit: joi.number().optional(),
+      offset: joi.number().optional(),
+      isExport: joi.boolean().optional(),
+    },
+);
+
+export const clientMetricsValid = {
+  body: clientMetricsSchema,
+};
+

package/src/routes/zone.routes.js

@@ -1,9 +1,8 @@
 import { Router } from 'express';
-import { getDraftedDataValid, getFileValid, saveDraftValid, saveValid, workSpaceValid } from '../dtos/zoneAudit.dtos.js';
+import { clientMetricsValid, getDraftedDataValid, getFileValid, saveDraftValid, saveValid, storeMetricsValid, workSpaceValid } from '../dtos/zoneAudit.dtos.js';
 import { isExistsQueue, validateUserAudit } from '../validation/audit.validation.js';
 import { isAllowedSessionHandler, validate } from 'tango-app-api-middleware';
-import { getDraftedData, getZoneAuditFile, save, saveDraft, storeMetrics, workSpace } from '../controllers/zoneAudit.controller.js';
-import { storeMetricsValid } from '../dtos/auditMetrics.dtos.js';
+import { clientMetrics, getDraftedData, getZoneAuditFile, save, saveDraft, storeMetrics, workSpace } from '../controllers/zoneAudit.controller.js';
 
 export const zoneAuditRouter=Router();
 
@@ -17,3 +16,4 @@ zoneAuditRouter.get( '/work-space', isAllowedSessionHandler, validate( workSpace
 // metrics
 
 zoneAuditRouter.post( '/metrics/store-metrics', isAllowedSessionHandler, validate( storeMetricsValid ), storeMetrics );
+zoneAuditRouter.post( '/metrics/client-metrics', isAllowedSessionHandler, validate( clientMetricsValid ), clientMetrics );