tango-app-api-audit 1.0.53 → 1.0.54

package/package.json

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

package/src/controllers/audit.controllers.js

@@ -1884,3 +1884,539 @@ export async function clientMetrics( req, res ) {
     return res.sendError( err, 500 );
   }
 }
+
+export async function storeMetrics( 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 } },
+
+    ];
+    if ( inputData.filterByClientId && inputData.filterByClientId?.length > 0 ) {
+      filter.push( { clientId: { $in: inputData.filterByClientId } } );
+    }
+
+    if ( inputData.filterByStoreId && inputData.filterByStoreId?.length > 0 ) {
+      filter.push( { storeId: { $in: inputData.filterByStoreId } } );
+    }
+
+    if ( inputData.filterByStatus && inputData.filterByStatus?.length > 0 ) {
+      filter.push( { status: { $in: inputData.filterByStatus } } );
+    }
+
+    if ( inputData.filterByAuditType && inputData.filterByAuditType?.length > 0 ) {
+      filter.push( { auditType: { $in: inputData.filterByAuditType } } );
+    }
+
+    if ( inputData.filterByModuleType && inputData.filterByModuleType?.length > 0 ) {
+      filter.push( { moduleType: { $in: inputData.filterByModuleType } } );
+    }
+
+
+    const query = [
+      {
+        $match: {
+          $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: '$store.storeName',
+          clientName: '',
+          clientId: 1,
+          zoneName: 1,
+          moduleType: 1,
+          userId: {
+            $arrayElemAt: [ '$userId', { $subtract: [ { $size: '$userId' }, 1 ] } ],
+          },
+          auditType: 1,
+          beforeCount: 1,
+          afterCount: { $ifNull: [ '$afterCount', null ] },
+          accuracy: { $round: [
+            { $divide: [
+              { $multiply: [ { $ifNull: [ '$afterCount', 0 ] }, '$beforeCount' ] }, 100,
+            ] }, 2,
+          ],
+
+          },
+          timeSpent: 1,
+          status: 1,
+        },
+      },
+      {
+        $lookup: {
+          from: 'users',
+          let: { userId: '$userId' },
+          pipeline: [
+            {
+              $match: {
+                $expr: {
+                  $eq: [ '$_id', '$$userId' ],
+                },
+              },
+            },
+            {
+              $project: {
+                _id: 0,
+                userName: 1,
+                userEmail: '$email',
+              },
+            },
+          ], as: 'users',
+        },
+      },
+      {
+        $unwind: {
+          path: '$users',
+          preserveNullAndEmptyArrays: true,
+        },
+      },
+      {
+        $lookup: {
+          from: 'clients',
+          let: { clientId: '$clientId' },
+          pipeline: [
+            {
+              $match: {
+                $expr: {
+                  $eq: [ '$clientId', '$$clientId' ],
+                },
+              },
+            },
+            {
+              $project: {
+                _id: 0,
+                clientName: 1,
+              },
+            },
+          ], as: 'client',
+        },
+      },
+      {
+        $unwind: {
+          path: '$client',
+          preserveNullAndEmptyArrays: true,
+        },
+      },
+      {
+        $project: {
+          _id: 0,
+          fileDate: 1,
+          storeId: 1,
+          storeName: '$stores.storeName',
+          userName: '$users.userName',
+          userEmail: '$users.userEmail',
+          clientId: 1,
+          clientName: '$client.clientName',
+          zoneName: 1,
+          moduleType: 1,
+          auditType: 1,
+          beforeCount: 1,
+          afterCount: { $ifNull: [ '$afterCount', null ] },
+          accuracy: { $round: [
+            { $divide: [
+              { $multiply: [ { $ifNull: [ '$afterCount', 0 ] }, '$beforeCount' ] }, 100,
+            ] }, 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,
+        },
+      },
+
+    ];
+
+    if ( inputData.searchValue && inputData.searchValue !== '' ) {
+      query.push( {
+        $match: {
+          $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' } },
+            { moduleType: { $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 ) {
+      return res.sendError( 'No data Found', 204 );
+    }
+    if ( !inputData.isExport ) {
+      query.push( {
+        $skip: offset,
+      },
+      {
+        $limit: limit,
+      } );
+    } else {
+      query.push( { $limit: 10000 } );
+    }
+    const result = await aggregateStoreAudit( query );
+    if ( inputData.isExport ) {
+      const exportdata = [];
+      result.forEach( ( element ) => {
+        exportdata.push( {
+          'File Date': element.fileDate,
+          '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,
+          'Accuracy': element.accuracy,
+          'Time Spent': element.timeSpent,
+          'Status': element.status,
+        } );
+      } );
+      await download( exportdata, res );
+      return;
+    }
+    return res.sendSuccess( { result: result, count: count.length } );
+  } catch ( error ) {
+    const err = error.message || 'Internal Server Error';
+    logger.error( { error: error, data: req.body, function: 'storeMetrics' } );
+    return res.sendError( err, 500 );
+  }
+}
+
+export async function userMetrics( 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 = [];
+    if ( inputData.dateType == 'auditedDate' ) {
+      filter.push(
+          { updatedAt: { $gte: dateRange.start } },
+          { updatedAt: { $lte: dateRange.end } },
+
+      );
+    } else {
+      filter.push(
+          { fileDateISO: { $gte: dateRange.start } },
+          { fileDateISO: { $lte: dateRange.end } },
+
+      );
+    }
+    if ( inputData?.filterByModuleType?.length> 0 ) {
+      filter.push(
+          { moduleType: { $in: inputData.filterByModuleType } },
+      );
+    }
+    if ( inputData?.filterByStatus?.length> 0 ) {
+      filter.push(
+          { auditStatus: { $in: inputData.filterByStatus } },
+      );
+    }
+    if ( inputData?.filterByUser?.length> 0 ) {
+      const temp = inputData.filterByUser.map( ( item ) => new mongoose.Types.ObjectId( item ) );
+      logger.info( { temp: temp } );
+      filter.push(
+          { userId: { $in: temp } },
+      );
+    }
+
+    const query = [
+      {
+        $match: {
+          $and: filter,
+        },
+      },
+      {
+        $project: {
+          userId: 1,
+          fileDate: 1,
+          startTime: 1,
+          endTime: 1,
+          totalCompletedFiles: { $cond: [ { $eq: [ '$auditStatus', 'completed' ] }, 1, 0 ] },
+          beforeCount: 1,
+          afterCount: { $cond: [ { $eq: [ '$auditStatus', 'completed' ] }, '$afterCount', 0 ] },
+        },
+      },
+      {
+        $group: {
+          _id: { userId: '$userId', fileDate: '$fileDate' },
+          userId: { $first: '$userId' },
+          fileDate: { $first: '$fileDate' },
+          totalCompletedFiles: { $sum: '$totalCompletedFiles' },
+          beforeCount: { $sum: '$beforeCount' },
+          afterCount: { $sum: '$afterCount' },
+          checkIntime: { $first: '$startTime' },
+          checkOutTime: { $last: '$endTime' },
+
+        },
+      },
+      {
+        $project: {
+          _id: 0,
+          userId: 1,
+          fileDate: 1,
+          totalCompletedFiles: 1,
+          beforeCount: 1,
+          afterCount: 1,
+          mappingPerc: { $round: [
+            { $multiply: [
+              { $divide: [ '$afterCount', '$beforeCount' ] }, 100,
+            ] }, 2,
+          ] },
+          checkIntime: 1,
+          checkOutTime: 1,
+          differenceInSeconds: {
+            $divide: [ { $subtract: [ '$checkOutTime', '$checkIntime' ] }, 1000 ],
+          },
+        },
+      },
+      {
+        $project: {
+          userId: 1,
+          fileDate: 1,
+          totalCompletedFiles: 1,
+          beforeCount: 1,
+          afterCount: 1,
+          checkIntime: 1,
+          checkOutTime: 1,
+          mappingPerc: 1,
+          hours: { $floor: { $divide: [ '$differenceInSeconds', 3600 ] } },
+          minutes: { $floor: { $divide: [ { $mod: [ '$differenceInSeconds', 3600 ] }, 60 ] } },
+          seconds: { $mod: [ '$differenceInSeconds', 60 ] },
+        },
+      },
+      {
+        $project: {
+          event: 1,
+          userId: 1,
+          fileDate: 1,
+          totalCompletedFiles: 1,
+          beforeCount: 1,
+          afterCount: 1,
+          checkIntime: 1,
+          checkOutTime: 1,
+          hours: {
+            $cond: {
+              if: { $lt: [ '$hours', 10 ] },
+              then: { $concat: [ '0', { $toString: { $round: [ '$hours', 0 ] } } ] },
+              else: { $toString: { $round: [ '$hours', 0 ] } },
+            },
+          },
+          minutes: {
+            $cond: {
+              if: { $lt: [ '$minutes', 10 ] },
+              then: { $concat: [ '0', { $toString: { $round: [ '$minutes', 0 ] } } ] },
+              else: { $toString: { $round: [ '$minutes', 0 ] } },
+            },
+          },
+          seconds: {
+            $cond: {
+              if: { $lt: [ '$seconds', 10 ] },
+              then: { $concat: [ '0', { $toString: { $round: [ '$seconds', 0 ] } } ] },
+              else: { $toString: { $round: [ '$seconds', 0 ] } },
+            },
+          },
+
+        },
+      },
+      {
+        $project: {
+          event: 1,
+          userId: 1,
+          fileDate: 1,
+          totalCompletedFiles: 1,
+          beforeCount: 1,
+          afterCount: 1,
+          checkIntime: 1,
+          zoneName: 1,
+          checkOutTime: 1,
+          workingHours: {
+            $concat: [ '$hours', ':', '$minutes', ':', '$seconds' ],
+          },
+        },
+      },
+      {
+        $lookup: {
+          from: 'users',
+          let: { userId: '$userId' },
+          pipeline: [
+            {
+              $match: {
+                $expr: {
+                  $eq: [ '$_id', '$$userId' ],
+                },
+              },
+            },
+            {
+              $project: {
+                _id: 0,
+                userName: 1,
+              },
+            },
+          ], as: 'userInfo',
+        },
+      },
+      {
+        $unwind: {
+          path: '$userInfo', preserveNullAndEmptyArrays: true,
+        },
+      },
+      {
+        $project: {
+          event: 1,
+          userName: '$userInfo.userName',
+          userId: 1,
+          fileDate: 1,
+          totalCompletedFiles: 1,
+          beforeCount: 1,
+          afterCount: 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,
+        },
+      },
+    ];
+    if ( inputData.searchValue && inputData.searchValue!== '' ) {
+      query.push( {
+        $match: {
+          $or: [
+            { userName: { $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 aggregateUserAudit( 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',
+              'User Name': '$userName',
+              'User Id': '$userId',
+              'Total Completed Files Count': '$totalCompletedFiles',
+              'Total efore Count': '$beforeCount',
+              'Total After Count': '$afterCount',
+              'check Intime': '$checkIntime',
+              'check OutTime': '$checkOutTime',
+              'working Hours': '$workingHours',
+            },
+          },
+      );
+    }
+
+
+    const result = await aggregateUserAudit( 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/controllers/auditMetrics.controllers.js

@@ -12,533 +12,6 @@ import { getReauditImg } from './audit.controllers.js';
 // import { listQueue } from 'tango-app-api-middleware/src/utils/aws/sqs.js';
 
 
-export async function storeMetrics( 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 } },
-    ];
-    if ( inputData.filterByClientId && inputData.filterByClientId?.length > 0 ) {
-      filter.push( { clientId: { $in: inputData.filterByClientId } } );
-    }
-
-    if ( inputData.filterByStoreId && inputData.filterByStoreId?.length > 0 ) {
-      filter.push( { storeId: { $in: inputData.filterByStoreId } } );
-    }
-
-    if ( inputData.filterByStatus && inputData.filterByStatus?.length > 0 ) {
-      filter.push( { status: { $in: inputData.filterByStatus } } );
-    }
-
-    if ( inputData.filterByType && inputData.filterByType?.length > 0 ) {
-      filter.push( { auditType: { $in: inputData.filterByType } } );
-    }
-
-
-    const query = [
-      {
-        $match: {
-          $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: '$store.storeName',
-          clientName: '',
-          clientId: 1,
-          userId: {
-            $arrayElemAt: [ '$userId', { $subtract: [ { $size: '$userId' }, 1 ] } ],
-          },
-          auditType: 1,
-          beforeCount: 1,
-          afterCount: { $ifNull: [ '$afterCount', null ] },
-          accuracy: { $round: [
-            { $divide: [
-              { $multiply: [ { $ifNull: [ '$afterCount', 0 ] }, '$beforeCount' ] }, 100,
-            ] }, 2,
-          ],
-
-          },
-          timeSpent: 1,
-          status: 1,
-        },
-      },
-      {
-        $lookup: {
-          from: 'users',
-          let: { userId: '$userId' },
-          pipeline: [
-            {
-              $match: {
-                $expr: {
-                  $eq: [ '$_id', '$$userId' ],
-                },
-              },
-            },
-            {
-              $project: {
-                _id: 0,
-                userName: 1,
-                userEmail: '$email',
-              },
-            },
-          ], as: 'users',
-        },
-      },
-      {
-        $unwind: {
-          path: '$users',
-          preserveNullAndEmptyArrays: true,
-        },
-      },
-      {
-        $lookup: {
-          from: 'clients',
-          let: { clientId: '$clientId' },
-          pipeline: [
-            {
-              $match: {
-                $expr: {
-                  $eq: [ '$clientId', '$$clientId' ],
-                },
-              },
-            },
-            {
-              $project: {
-                _id: 0,
-                clientName: 1,
-              },
-            },
-          ], as: 'client',
-        },
-      },
-      {
-        $unwind: {
-          path: '$client',
-          preserveNullAndEmptyArrays: true,
-        },
-      },
-      {
-        $project: {
-          _id: 0,
-          fileDate: 1,
-          storeId: 1,
-          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,
-            ] }, 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,
-        },
-      },
-
-    ];
-
-    if ( inputData.searchValue && inputData.searchValue !== '' ) {
-      query.push( {
-        $match: {
-          $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 ) {
-      return res.sendError( 'No data Found', 204 );
-    }
-    if ( !inputData.isExport ) {
-      query.push( {
-        $skip: offset,
-      },
-      {
-        $limit: limit,
-      } );
-    } else {
-      query.push( { $limit: 10000 } );
-    }
-    const result = await aggregateStoreAudit( query );
-    if ( inputData.isExport ) {
-      const exportdata = [];
-      result.forEach( ( element ) => {
-        exportdata.push( {
-          'File Date': element.fileDate,
-          '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,
-          'Accuracy': element.accuracy,
-          'Time Spent': element.timeSpent,
-          'Status': element.status,
-        } );
-      } );
-      await download( exportdata, res );
-      return;
-    }
-    return res.sendSuccess( { result: result, count: count.length } );
-  } catch ( error ) {
-    const err = error.message || 'Internal Server Error';
-    logger.error( { error: error, data: req.body, function: 'storeMetrics' } );
-    return res.sendError( err, 500 );
-  }
-}
-
-
-export async function userMetrics( 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 = [];
-    if ( inputData.fileType == 'auditedDate' ) {
-      filter.push(
-          { updatedAt: { $gte: dateRange.start } },
-          { updatedAt: { $lte: dateRange.end } },
-
-      );
-    } else {
-      filter.push(
-          { fileDateISO: { $gte: dateRange.start } },
-          { fileDateISO: { $lte: dateRange.end } },
-
-      );
-    }
-    if ( inputData?.filterByAuditType?.length> 0 ) {
-      filter.push(
-          { moduleType: { $in: inputData.filterByAuditType } },
-      );
-    }
-    if ( inputData?.filterByStatus?.length> 0 ) {
-      filter.push(
-          { auditStatus: { $in: inputData.filterByStatus } },
-      );
-    }
-    if ( inputData?.filterByUser?.length> 0 ) {
-      const temp = inputData.filterByUser.map( ( item ) => new mongoose.Types.ObjectId( item ) );
-      logger.info( { temp: temp } );
-      filter.push(
-          { userId: { $in: temp } },
-      );
-    }
-
-    const query = [
-      {
-        $match: {
-          $and: filter,
-        },
-      },
-      {
-        $project: {
-          userId: 1,
-          fileDate: 1,
-          startTime: 1,
-          endTime: 1,
-          totalCompletedFiles: { $cond: [ { $eq: [ '$auditStatus', 'completed' ] }, 1, 0 ] },
-          beforeCount: 1,
-          afterCount: { $cond: [ { $eq: [ '$auditStatus', 'completed' ] }, '$afterCount', 0 ] },
-        },
-      },
-      {
-        $group: {
-          _id: { userId: '$userId', fileDate: '$fileDate' },
-          userId: { $first: '$userId' },
-          fileDate: { $first: '$fileDate' },
-          totalCompletedFiles: { $sum: '$totalCompletedFiles' },
-          beforeCount: { $sum: '$beforeCount' },
-          afterCount: { $sum: '$afterCount' },
-          checkIntime: { $first: '$startTime' },
-          checkOutTime: { $last: '$endTime' },
-
-        },
-      },
-      {
-        $project: {
-          _id: 0,
-          userId: 1,
-          fileDate: 1,
-          totalCompletedFiles: 1,
-          beforeCount: 1,
-          afterCount: 1,
-          mappingPerc: { $round: [
-            { $multiply: [
-              { $divide: [ '$afterCount', '$beforeCount' ] }, 100,
-            ] }, 2,
-          ] },
-          checkIntime: 1,
-          checkOutTime: 1,
-          differenceInSeconds: {
-            $divide: [ { $subtract: [ '$checkOutTime', '$checkIntime' ] }, 1000 ],
-          },
-        },
-      },
-      {
-        $project: {
-          userId: 1,
-          fileDate: 1,
-          totalCompletedFiles: 1,
-          beforeCount: 1,
-          afterCount: 1,
-          checkIntime: 1,
-          checkOutTime: 1,
-          mappingPerc: 1,
-          hours: { $floor: { $divide: [ '$differenceInSeconds', 3600 ] } },
-          minutes: { $floor: { $divide: [ { $mod: [ '$differenceInSeconds', 3600 ] }, 60 ] } },
-          seconds: { $mod: [ '$differenceInSeconds', 60 ] },
-        },
-      },
-      {
-        $project: {
-          event: 1,
-          userId: 1,
-          fileDate: 1,
-          totalCompletedFiles: 1,
-          beforeCount: 1,
-          afterCount: 1,
-          checkIntime: 1,
-          checkOutTime: 1,
-          hours: {
-            $cond: {
-              if: { $lt: [ '$hours', 10 ] },
-              then: { $concat: [ '0', { $toString: { $round: [ '$hours', 0 ] } } ] },
-              else: { $toString: { $round: [ '$hours', 0 ] } },
-            },
-          },
-          minutes: {
-            $cond: {
-              if: { $lt: [ '$minutes', 10 ] },
-              then: { $concat: [ '0', { $toString: { $round: [ '$minutes', 0 ] } } ] },
-              else: { $toString: { $round: [ '$minutes', 0 ] } },
-            },
-          },
-          seconds: {
-            $cond: {
-              if: { $lt: [ '$seconds', 10 ] },
-              then: { $concat: [ '0', { $toString: { $round: [ '$seconds', 0 ] } } ] },
-              else: { $toString: { $round: [ '$seconds', 0 ] } },
-            },
-          },
-
-        },
-      },
-      {
-        $project: {
-          event: 1,
-          userId: 1,
-          fileDate: 1,
-          totalCompletedFiles: 1,
-          beforeCount: 1,
-          afterCount: 1,
-          checkIntime: 1,
-          zoneName: 1,
-          checkOutTime: 1,
-          workingHours: {
-            $concat: [ '$hours', ':', '$minutes', ':', '$seconds' ],
-          },
-        },
-      },
-      {
-        $lookup: {
-          from: 'users',
-          let: { userId: '$userId' },
-          pipeline: [
-            {
-              $match: {
-                $expr: {
-                  $eq: [ '$_id', '$$userId' ],
-                },
-              },
-            },
-            {
-              $project: {
-                _id: 0,
-                userName: 1,
-              },
-            },
-          ], as: 'userInfo',
-        },
-      },
-      {
-        $unwind: {
-          path: '$userInfo', preserveNullAndEmptyArrays: true,
-        },
-      },
-      {
-        $project: {
-          event: 1,
-          userName: '$userInfo.userName',
-          userId: 1,
-          fileDate: 1,
-          totalCompletedFiles: 1,
-          beforeCount: 1,
-          afterCount: 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,
-        },
-      },
-    ];
-    if ( inputData.searchValue && inputData.searchValue!== '' ) {
-      query.push( {
-        $match: {
-          $or: [
-            { userName: { $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 aggregateUserAudit( 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',
-              'User Name': '$userName',
-              'User Id': '$userId',
-              'Total Completed Files Count': '$totalCompletedFiles',
-              'Total efore Count': '$beforeCount',
-              'Total After Count': '$afterCount',
-              'check Intime': '$checkIntime',
-              'check OutTime': '$checkOutTime',
-              'working Hours': '$workingHours',
-            },
-          },
-      );
-    }
-
-
-    const result = await aggregateUserAudit( 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 );
-  }
-}
-
 export async function overViewCard( req, res ) {
   try {
     const inputData = req.body;

package/src/docs/audit.docs.js

@@ -1,4 +1,4 @@
-import { auditStoreSchema, clientMetricsSchema, clientSchema, getDraftedDataSchema, getFileSchema, saveDraftSchema, saveSchema, userAuditHistorySchema, userSchema, workSpaceSchema } from '../dtos/audit.dtos.js';
+import { auditStoreSchema, clientMetricsSchema, clientSchema, getDraftedDataSchema, getFileSchema, saveDraftSchema, saveSchema, storeMetricsSchema, userAuditHistorySchema, userMetricsSchema, userSchema, workSpaceSchema } from '../dtos/audit.dtos.js';
 import j2s from 'joi-to-swagger';
 
 export const auditDocs = {
@@ -308,5 +308,50 @@ export const auditDocs = {
       },
     },
   },
+  '/v3/audit/metrics/store-metrics': {
+    post: {
+      tags: [ 'Audit Metrics' ],
+      description: `Get list of store wise details with date range and client Id`,
+      operationId: 'store-metrics',
+      parameters: {},
+      requestBody: {
+        content: {
+          'application/json': {
+            schema: j2s( storeMetricsSchema ).swagger,
+          },
+        },
+      },
+      responses: {
+        200: { description: 'Successful' },
+        401: { description: 'Unauthorized User' },
+        422: { description: 'Field Error' },
+        500: { description: 'Server Error' },
+        204: { description: 'Not Found' },
+      },
+    },
+  },
+
+  '/v3/audit/metrics/user-metrics': {
+    post: {
+      tags: [ 'Audit Metrics' ],
+      description: `Get list of file wise details with date range and users`,
+      operationId: 'user-metrics',
+      parameters: {},
+      requestBody: {
+        content: {
+          'application/json': {
+            schema: j2s( userMetricsSchema ).swagger,
+          },
+        },
+      },
+      responses: {
+        200: { description: 'Successful' },
+        401: { description: 'Unauthorized User' },
+        422: { description: 'Field Error' },
+        500: { description: 'Server Error' },
+        204: { description: 'Not Found' },
+      },
+    },
+  },
 
 };

package/src/docs/auditMetrics.docs.js

@@ -1,5 +1,5 @@
 import j2s from 'joi-to-swagger';
-import { auditImageValidSchema, getAuditImagesSchema, overAllAuditSummarySchema, overViewCardSchema, overViewTableSchema, reTriggerValidSchema, storeMetricsSchema, summarySplitSchema, userMetricsSchema } from '../dtos/auditMetrics.dtos.js';
+import { auditImageValidSchema, getAuditImagesSchema, overAllAuditSummarySchema, overViewCardSchema, overViewTableSchema, reTriggerValidSchema, summarySplitSchema } from '../dtos/auditMetrics.dtos.js';
 
 export const auditMetricsDocs = {
 
@@ -27,50 +27,6 @@ export const auditMetricsDocs = {
   },
 
 
-  '/v3/audit-metrics/store-metrics': {
-    post: {
-      tags: [ 'Audit Metrics' ],
-      description: `Get list of store wise details with date range and client Id`,
-      operationId: 'store-metrics',
-      parameters: {},
-      requestBody: {
-        content: {
-          'application/json': {
-            schema: j2s( storeMetricsSchema ).swagger,
-          },
-        },
-      },
-      responses: {
-        200: { description: 'Successful' },
-        401: { description: 'Unauthorized User' },
-        422: { description: 'Field Error' },
-        500: { description: 'Server Error' },
-        204: { description: 'Not Found' },
-      },
-    },
-  },
-  '/v3/audit-metrics/user-metrics': {
-    post: {
-      tags: [ 'Audit Metrics' ],
-      description: `Get list of file wise details with date range and users`,
-      operationId: 'user-metrics',
-      parameters: {},
-      requestBody: {
-        content: {
-          'application/json': {
-            schema: j2s( userMetricsSchema ).swagger,
-          },
-        },
-      },
-      responses: {
-        200: { description: 'Successful' },
-        401: { description: 'Unauthorized User' },
-        422: { description: 'Field Error' },
-        500: { description: 'Server Error' },
-        204: { description: 'Not Found' },
-      },
-    },
-  },
   '/v3/audit-metrics/overview-card': {
     post: {
       tags: [ 'Audit Metrics' ],

package/src/dtos/audit.dtos.js

@@ -182,3 +182,47 @@ export const clientMetricsSchema = joi.object(
 export const clientMetricsValid = {
   body: clientMetricsSchema,
 };
+
+
+export const storeMetricsSchema = joi.object(
+    {
+      fromDate: joi.string().required(),
+      toDate: joi.string().required(),
+      searchValue: joi.string().optional().allow( '' ),
+      filterByClientId: joi.array().required(),
+      filterByStoreId: joi.array().optional(),
+      filterByStatus: joi.array().optional(),
+      filterByAuditType: joi.array().optional(),
+      filterByModuleType: 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 storeMetricsValid = {
+  body: storeMetricsSchema,
+};
+
+export const userMetricsSchema = joi.object(
+    {
+      fromDate: joi.string().required(),
+      toDate: joi.string().required(),
+      dateType: joi.string().required(),
+      searchValue: joi.string().optional().allow( '' ),
+      filterByUser: joi.array().optional(),
+      filterByModuleType: joi.array().optional(),
+      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 userMetricsValid = {
+  body: userMetricsSchema,
+};

package/src/dtos/auditMetrics.dtos.js

@@ -14,49 +14,6 @@ export const getAuditImagesValid = {
 };
 
 
-export const storeMetricsSchema = joi.object(
-    {
-      fromDate: joi.string().required(),
-      toDate: joi.string().required(),
-      searchValue: joi.string().optional().allow( '' ),
-      filterByClientId: joi.array().required(),
-      filterByStoreId: joi.array().optional(),
-      filterByStatus: joi.array().optional(),
-      filterByType: 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 storeMetricsValid = {
-  body: storeMetricsSchema,
-};
-
-
-export const userMetricsSchema = joi.object(
-    {
-      fromDate: joi.string().required(),
-      toDate: joi.string().required(),
-      fileType: joi.string().required(),
-      searchValue: joi.string().optional().allow( '' ),
-      filterByUser: joi.array().optional(),
-      filterByAuditType: joi.array().optional(),
-      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 userMetricsValid = {
-  body: userMetricsSchema,
-};
-
 export const overViewCardSchema = joi.object(
     {
       fromDate: joi.string().required(),

package/src/routes/audit.routes.js

@@ -1,8 +1,8 @@
 import express from 'express';
 import { isExistsQueue, validateUserAudit } from '../validation/audit.validation.js';
 import { isAllowedSessionHandler, validate } from 'tango-app-api-middleware';
-import { auditStoreList, auditUserList, clientMetrics, clients, getAuditFile, getDraftedData, save, saveDraft, userAuditHistory, workSpace } from '../controllers/audit.controllers.js';
-import { auditStoreValid, clientMetricsValid, clientValid, getDraftedDataValid, getFileValid, saveDraftValid, saveValid, userAuditHistoryValid, workSpaceValid } from '../dtos/audit.dtos.js';
+import { auditStoreList, auditUserList, clientMetrics, clients, getAuditFile, getDraftedData, save, saveDraft, storeMetrics, userAuditHistory, userMetrics, workSpace } from '../controllers/audit.controllers.js';
+import { auditStoreValid, clientMetricsValid, clientValid, getDraftedDataValid, getFileValid, saveDraftValid, saveValid, storeMetricsValid, userAuditHistoryValid, userMetricsValid, workSpaceValid } from '../dtos/audit.dtos.js';
 
 export const auditRouter = express.Router();
 
@@ -22,6 +22,8 @@ auditRouter.get( '/work-space', isAllowedSessionHandler, validate( workSpaceVali
 // Audit Metrics
 auditRouter.post( '/metrics/user-audit-history', isAllowedSessionHandler, validate( userAuditHistoryValid ), userAuditHistory );
 auditRouter.post( '/metrics/client-metrics', isAllowedSessionHandler, validate( clientMetricsValid ), clientMetrics );
+auditRouter.post( '/metrics/store-metrics', isAllowedSessionHandler, validate( storeMetricsValid ), storeMetrics );
+auditRouter.post( '/metrics/user-metrics', isAllowedSessionHandler, validate( userMetricsValid ), userMetrics );
 
 
 export default auditRouter;

package/src/routes/auditMetrics.routes.js

@@ -1,16 +1,13 @@
 
 import express from 'express';
 import { isAllowedSessionHandler, validate } from 'tango-app-api-middleware';
-import { auditImages, overAllAuditSummary, overViewCard, overViewTable, reTrigger, storeMetrics, summarySplit, userMetrics } from '../controllers/auditMetrics.controllers.js';
-import { auditImageValid, overAllAuditSummaryValid, overViewCardValid, overViewTableValid, reTriggerValid, storeMetricsValid, summarySplitValid, userMetricsValid, viewLogValid } from '../dtos/auditMetrics.dtos.js';
+import { auditImages, overAllAuditSummary, overViewCard, overViewTable, reTrigger, summarySplit } from '../controllers/auditMetrics.controllers.js';
+import { auditImageValid, overAllAuditSummaryValid, overViewCardValid, overViewTableValid, reTriggerValid, summarySplitValid, viewLogValid } from '../dtos/auditMetrics.dtos.js';
 import { isAuditDocumentExist, isAuditInputFolderExist } from '../validation/audit.validation.js';
 
 export const auditMetricsRouter = express.Router();
 
 
-auditMetricsRouter.post( '/store-metrics', isAllowedSessionHandler, validate( storeMetricsValid ), storeMetrics );
-
-auditMetricsRouter.post( '/user-metrics', isAllowedSessionHandler, validate( userMetricsValid ), userMetrics );
 auditMetricsRouter.post( '/overview-card', isAllowedSessionHandler, validate( overViewCardValid ), overViewCard );
 auditMetricsRouter.post( '/summary-split-up', isAllowedSessionHandler, validate( summarySplitValid ), summarySplit );
 auditMetricsRouter.post( '/overview-table', isAllowedSessionHandler, validate( overViewTableValid ), overViewTable );