tango-app-api-audit 3.4.0-alpha.13 → 3.4.0-alpha.15

package/package.json

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

package/src/controllers/traxAudit.controllers.js

@@ -619,6 +619,48 @@ export async function workSpace( req, res ) {
       },
     ];
 
+    const binarCompletedStores = [
+      {
+        $match: {
+          $and: [
+            { clientId: { $in: clientList } },
+            { fileDate: { $eq: latestDate } },
+            { moduleType: { $eq: inputData.moduleType } },
+          ],
+        },
+      },
+      {
+        $project: {
+          clientId: 1,
+          completed: {
+            $cond: [ { $eq: [ '$auditStatus', 'completed' ] }, 1, 0 ],
+          },
+        },
+      },
+      // {
+      //   $group: {
+      //     _id: { clientId: '$clientId', storeId: '$storeId' },
+      //     clientId: { $first: '$clientId' },
+      //     completedStoresCount: { $sum: '$completed' },
+      //   },
+      // },
+      {
+        $group: {
+          _id: '$clientId',
+          clientId: { $first: '$clientId' },
+          // completedStoresCount: { $first: '$completedStoresCount' },
+          completedStoresCount: { $sum: '$completed' },
+        },
+      },
+      {
+        $project: {
+          _id: 0,
+          clientId: 1,
+          completedStoresCount: 1,
+        },
+      },
+    ];
+
     const auditFiles = [
       {
         $match: {
@@ -754,7 +796,7 @@ export async function workSpace( req, res ) {
     const auditUserCount = inputData.moduleType.includes( [ 'uniform-detection', 'mobile-detection' ] )?await aggregateUserEmpDetection( auditFiles ) : await aggregateBinaryAudit( auditFiles );
     const userIncompleteFilesCount = inputData.moduleType.includes( [ 'uniform-detection', 'mobile-detection' ] )?await aggregateUserEmpDetection( userIncompleteFiles ) : await aggregateBinaryAudit( userIncompleteFiles );
     const userAsignAuditCount = await aggregateAssignAudit( userAsignAudit );
-    const completedStoresCount = inputData.moduleType.includes( [ 'uniform-detection', 'mobile-detection' ] )? await aggregateStoreEmpDetection( completedStores ) : await aggregateBinaryAudit( completedStores );
+    const completedStoresCount = inputData.moduleType.includes( [ 'uniform-detection', 'mobile-detection' ] )? await aggregateStoreEmpDetection( completedStores ) : await aggregateBinaryAudit( binarCompletedStores );
     const clientAssignedCount = await aggregateAssignAudit( clientAssign );
     const auditStoreData = await aggregateTraxAuditData(
         auditStoreDataQuery,
@@ -1959,6 +2001,189 @@ export async function storeMetrics( req, res ) {
 
     ];
 
+    const binaryQuery = [
+      {
+        $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: {
+          auditId: '$_id',
+          _id: 0,
+          fileDate: 1,
+          storeId: 1,
+          storeName: '$stores.storeName',
+          clientName: '',
+          clientId: 1,
+          moduleType: 1,
+          value: {
+            $replaceAll: { input: '$moduleType', find: '-', replacement: ' ' },
+          },
+          tempId: 1,
+          streamName: 1,
+          question: 1,
+          questionType: 1,
+          answer: 1,
+          // userId: {
+          //   $arrayElemAt: [ '$userId', { $subtract: [ { $size: '$userId' }, 1 ] } ],    //need to check if no data
+          // },
+          userId: 1,
+          auditType: 1,
+          beforeCount: 1,
+          afterCount: { $ifNull: [ '$afterCount', null ] },
+          accuracy: { $cond: [ { $eq: [ '$auditStatus', 'completed' ] }, { $round: [
+            {
+              $multiply: [ { $divide: [ '$afterCount', '$beforeCount' ] }, 100 ],
+            }, 1,
+          ],
+          }, null ] },
+          timeSpent: 1,
+          status: 1,
+          auditStatus: 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: {
+          auditId: 1,
+          fileDate: 1,
+          storeId: 1,
+          storeName: 1,
+          userName: '$users.userName',
+          userEmail: '$users.userEmail',
+          clientId: 1,
+          clientName: '$client.clientName',
+          tempId: 1,
+          streamName: 1,
+          question: 1,
+          questionType: 1,
+          answer: 1,
+          moduleType: 1,
+          value: 1,
+          auditType: 1,
+          beforeCount: 1,
+          afterCount: { $ifNull: [ '$afterCount', null ] },
+          accuracy: { $cond: [ { $eq: [ '$auditStatus', 'completed' ] }, { $round: [
+            {
+              $multiply: [ { $divide: [ '$afterCount', '$beforeCount' ] }, 100 ],
+            }, 1,
+          ],
+          }, null ] },
+          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,
+          auditStatus: 1,
+        },
+      },
+
+    ];
+
     if ( inputData.searchValue && inputData.searchValue !== '' ) {
       query.push( {
         $match: {
@@ -1988,7 +2213,7 @@ export async function storeMetrics( req, res ) {
       },
       );
     }
-    const count = inputData.moduleType.includes( [ 'uniform-detection', 'mobile-detection' ] )?await aggregateStoreEmpDetection( query ) : await aggregateBinaryAudit( query );
+    const count = inputData.moduleType.includes( [ 'uniform-detection', 'mobile-detection' ] )?await aggregateStoreEmpDetection( query ) : await aggregateBinaryAudit( binaryQuery );
 
     if ( count.length == 0 ) {
       return res.sendError( 'No data Found', 204 );
@@ -2107,11 +2332,10 @@ export async function userMetrics( req, res ) {
           userId: 1,
           fileDate: 1,
           startTime: 1,
+          endTime: 1,
           beforeCount: 1,
           moduleType: 1,
           afterCount: 1,
-          checkIntime: 1,
-          checkOutTime: 1,
           totalCompletedFiles: { $cond: [ { $eq: [ '$auditStatus', 'completed' ] }, 1, 0 ] },
           beforeCount: 1,
           afterCount: { $cond: [ { $eq: [ '$auditStatus', 'completed' ] }, '$afterCount', 0 ] },
@@ -2524,8 +2748,6 @@ export async function pendingSummaryTable( req, res ) {
       result.forEach( ( element ) => {
         const temp = {
           'Store ID': element.storeId,
-          'Result': element.answer,
-          'userComments': element.userComments,
           'File Date': element.fileDate,
           'Product Type': element.value,
           'Audit Type': element.auditType,
@@ -2537,16 +2759,13 @@ export async function pendingSummaryTable( req, res ) {
         switch ( inputData.moduleType ) {
           case 'camera-angle-change':
             temp['stream Name'] = element.streamName;
-            temp['User Comments'] = element.userCommands;
             break;
           case 'unattended-customer':
             temp['Customer ID'] = element.tempId;
             temp['Question'] = element.question;
-            temp['User Comments'] = element.userCommands;
             break;
           case 'left-in-middle':
             temp['Question'] = element.question;
-            temp['User Comments'] = element.userCommands;
             break;
           case 'mobile-detection':
             temp['Before Count'] = element.beforeCount;
@@ -2669,7 +2888,57 @@ export async function overAllAuditSummary( req, res ) {
         },
       },
     ];
-    const storeAudit = inputData.moduleType.includes( [ 'uniform-detection', 'mobile-detection' ] )?await aggregateStoreEmpDetection( storeAuditQuery ) : await aggregateBinaryAudit( storeAuditQuery );
+
+    const binaryAuditQuery =[
+      {
+        $match: {
+          $and: filters,
+        },
+
+      },
+      {
+        $project: {
+          completedStores: { $cond: [ { $eq: [ '$auditStatus', 'completed' ] }, 1, 0 ] },
+          auditInprogress: { $cond: [ { $and: [ { $in: [ '$auditStatus', [ 'inprogress' ] ] }, { $eq: [ '$auditType', 'Audit' ] } ] }, 1, 0 ] },
+          reAuditInprogress: { $cond: [ { $and: [ { $in: [ '$auditStatus', [ 'inprogress' ] ] }, { $eq: [ '$auditType', 'ReAudit' ] } ] }, 1, 0 ] },
+          draft: { $cond: [ { $eq: [ '$auditStatus', 'drafted' ] }, 1, 0 ] },
+          assigned: { $cond: [ { $eq: [ '$auditStatus', 'assigned' ] }, 1, 0 ] },
+          exceptNoAssigned: { $cond: { if: { $not: { $in: [ '$auditStatus', [ 'skipped', 'not_assign' ] ] } }, then: 1, else: 0 } },
+          auditCompleted: { $cond: [ { $and: [ { $in: [ '$auditStatus', [ 'completed' ] ] }, { $eq: [ '$auditType', 'Audit' ] } ] }, 1, 0 ] },
+          reAuditCompleted: { $cond: [ { $and: [ { $in: [ '$auditStatus', [ 'completed' ] ] }, { $eq: [ '$auditType', 'ReAudit' ] } ] }, 1, 0 ] },
+
+
+        },
+      },
+      {
+        $group: {
+          _id: null,
+          completedStores: { $sum: '$completedStores' },
+          auditInprogress: { $sum: '$auditInprogress' },
+          reAuditInprogress: { $sum: '$reAuditInprogress' },
+          draft: { $sum: '$draft' },
+          assigned: { $sum: '$assigned' },
+          exceptNoAssigned: { $sum: '$exceptNoAssigned' },
+          auditCompleted: { $sum: '$auditCompleted' },
+          reAuditCompleted: { $sum: '$reAuditCompleted' },
+        },
+      },
+      {
+        $project: {
+          completedStores: 1,
+          inprogressStores: { $subtract: [ temp.auditStores, '$completedStores' ] },
+          auditInprogress: 1,
+          reAuditInprogress: 1,
+          draft: 1,
+          assigned: 1,
+          exceptNoAssigned: { $subtract: [ temp.auditStores, '$exceptNoAssigned' ] },
+          auditCompleted: 1,
+          reAuditCompleted: 1,
+        },
+      },
+    ];
+
+    const storeAudit = inputData.moduleType.includes( [ 'uniform-detection', 'mobile-detection' ] )?await aggregateStoreEmpDetection( storeAuditQuery ) : await aggregateBinaryAudit( binaryAuditQuery );
     if ( storeAudit.length > 0 ) {
       temp.inprogressStores= storeAudit[0].inprogressStores;
       temp.completedStores = storeAudit[0].completedStores;