tango-app-api-audit 3.4.0-alpha.8 → 3.4.0

package/src/controllers/traxAudit.controllers.js

@@ -1,4 +1,4 @@
-import { checkFileExist, download, getDate, getDateWithCustomizeTime, getUTC, insertOpenSearchData, listFileByPath, logger, signedUrl, sqsReceive } from 'tango-app-api-middleware';
+import { checkFileExist, chunkArray, download, getDate, getDateWithCustomizeTime, getUTC, insertOpenSearchData, listFileByPath, logger, signedUrl, sqsReceive } from 'tango-app-api-middleware';
 import { aggregateBinaryAudit, createBinaryAudit, updateOneBinaryAuditModel } from '../service/binaryAudit.service.js';
 import { countDocumentsStore, findOneStore } from '../service/store.service.js';
 import { findOneUser } from '../service/user.service.js';
@@ -18,7 +18,8 @@ export async function getDetectionAuditFile( req, res ) {
     const bucket = JSON.parse( process.env.BUCKET );
     const openSearch = JSON.parse( process.env.OPENSEARCH );
     const inputData = req.query;
-    const data = await getDate( new Date(), new Date() );
+    const previousDate = new Date( new Date() - 1 );
+    const data = await getDate( previousDate, new Date() );
     logger.info( { data: data, function: 'data', newDate: new Date() } );
     logger.info( { userId: req.user._id, queueName: inputData.queueName, moduleType: inputData.moduleType } );
     const start = data.start;
@@ -471,10 +472,9 @@ export async function workSpace( req, res ) {
     const filter =[
       { status: { $in: [ 'active', 'hold' ] } },
       { 'auditConfigs.audit': { $eq: true } },
+      { clientId: { $in: inputData.clientId } },
     ];
-    if ( inputData?.clientId?.length > 0 ) {
-      filter.push( { clientId: { $in: inputData.clientId } } );
-    }
+
     const temp = [];
     const clientQuery = [
       {
@@ -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,
@@ -861,7 +903,8 @@ export async function getAuditFile( req, res ) {
   try {
     const inputData = req.query;
     const openSearch = JSON.parse( process.env.OPENSEARCH );
-    const data = await getDate( new Date(), new Date() );
+    const previousDate = new Date( new Date() - 1 );
+    const data = await getDate( previousDate, new Date() );
     const start = data.start;
     const end = data.end;
     let msg = {};
@@ -908,18 +951,55 @@ export async function getAuditFile( req, res ) {
         break;
 
       case 'inprogress':
-
-        msg ={
-          storeId: userDetails[0].storeId,
-          fileDate: userDetails[0].fileDate,
-          moduleType: userDetails[0].moduleType,
-          tempId: userDetails[0].tempId,
-          question: userDetails[0].question,
-          fileDetails: userDetails[0].fileDetails,
-          inputBucketName: userDetails[0].inputBucketName,
-          questionType: userDetails[0].questionType,
-          streamName: userDetails[0].streamName,
-        };
+        let query = {};
+        switch ( inputData.moduleType ) {
+          case 'unattended-customer':
+            query ={
+              storeId: userDetails[0].storeId,
+              fileDate: userDetails[0].fileDate,
+              tempId: userDetails[0].tempId,
+              moduleType: userDetails[0].moduleType,
+            };
+            break;
+          case 'left-in-middle':
+            query ={
+              storeId: userDetails[0].storeId,
+              fileDate: userDetails[0].fileDate,
+              question: userDetails[0].question,
+              moduleType: userDetails[0].moduleType,
+            };
+            break;
+          case 'uniform-detection':
+            query ={
+              storeId: userDetails[0].storeId,
+              fileDate: userDetails[0].fileDate,
+              moduleType: userDetails[0].moduleType,
+            };
+            break;
+          case 'mobile-detection':
+            query ={
+              storeId: userDetails[0].storeId,
+              fileDate: userDetails[0].fileDate,
+              moduleType: userDetails[0].moduleType,
+            };
+            break;
+          case 'camera-angle-change':
+            query ={
+              storeId: userDetails[0].storeId,
+              fileDate: userDetails[0].fileDate,
+              streamName: userDetails[0].streamName,
+              moduleType: userDetails[0].moduleType,
+            };
+            break;
+          default:
+            return res.sendError( 'Please give valid modueType', 400 );
+        }
+        logger.info( { query: query } );
+        const traxInfo = await findOneTraxAuditData( query );
+        if ( !traxInfo ) {
+          return res.sendError( 'The sorce record not found', 400 );
+        }
+        msg =traxInfo?.sqs?.Body;
         break;
 
       default:
@@ -1072,7 +1152,7 @@ export async function getAuditFile( req, res ) {
         fileDate: msg.fileDate,
         queueName: inputData.queueName,
         auditStatus: 'inprogress',
-        AuditType: 'Audit',
+        auditType: 'Audit',
         fileDateISO: start,
         timeSpent: 0,
         startTime: new Date(),
@@ -1144,6 +1224,175 @@ export async function getAuditFile( req, res ) {
   }
 }
 
+export async function getUpdatedFile( req, res ) {
+  try {
+    const openSearch = JSON.parse( process.env.OPENSEARCH );
+    const inputData = req.body;
+    const msg = req?.TraxData?.sqs?.Body;
+    logger.info( { msg: msg } );
+    let result =[];
+    switch ( inputData.moduleType ) {
+      case 'camera-angle-change':
+        const actualParams ={
+          Bucket: msg.inputBucketName,
+          Key: msg.actual,
+        };
+        const changedParams ={
+          Bucket: msg.inputBucketName,
+          Key: msg.changed,
+        };
+
+        const [ isActualExists, isChangedExists ] = await Promise.all( [ checkFileExist( actualParams ), checkFileExist( changedParams ) ] );
+        result =[
+          {
+            actualCameraImage: isActualExists? await signedUrl( { Bucket: msg.inputBucketName,
+              file_path: msg.actual } ) :'',
+          },
+          {
+            changedCameraImage: isChangedExists? await signedUrl( { Bucket: msg.inputBucketName,
+              file_path: msg.changed } ) : '',
+          },
+        ];
+        break;
+      case 'unattended-customer':
+        for ( let i =0; i< msg.fileDetails.length; i++ ) {
+          const files = [];
+          const params ={
+            Bucket: msg.inputBucketName,
+            file_path: msg?.fileDetails[i]?.folderPath,
+            MaxKeys: 1000,
+          };
+          const list = await listFileByPath( params );
+          const folderPath = list.data;
+          logger.info( { folderPath: list, params: params, list: list } );
+          if ( folderPath?.length ) {
+            for ( let i = 0; i < folderPath.length; i++ ) {
+              //   const img = folderPath[i].Key.split( '/' );
+              //   const image = img[3].split( '.' );
+              //   const indexes = image[0].split( '_' );
+              const signedParams ={
+                Bucket: msg.inputBucketName,
+                file_path: folderPath[i].Key,
+              };
+              const data = await signedUrl( signedParams );
+
+              files.push(
+                  data,
+              );
+            }
+          } else {
+            logger.error( {
+              error: { folderPath: folderPath },
+              function: `getAuditFile - ${inputData.moduleType}`,
+              message: 'Bucket image data not availale',
+            } );
+            return res.sendError( 'Bucket is Empty', 204 );
+          }
+          result.push( {
+            type: msg.fileDetails[i].type,
+            file: files,
+          } );
+        }
+        break;
+      case 'left-in-middle':
+        for ( let i =0; i< msg.fileDetails.length; i++ ) {
+          const files = [];
+          const params ={
+            Bucket: msg.inputBucketName,
+            file_path: msg?.fileDetails[i]?.folderPath,
+            MaxKeys: 1000,
+          };
+          const list = await listFileByPath( params );
+          const folderPath = list.data;
+          logger.info( { folderPath: list, params: params, list: list } );
+          if ( folderPath?.length ) {
+            for ( let i = 0; i < folderPath.length; i++ ) {
+              //   const img = folderPath[i].Key.split( '/' );
+              //   const image = img[3].split( '.' );
+              //   const indexes = image[0].split( '_' );
+              const signedParams ={
+                Bucket: msg.inputBucketName,
+                file_path: folderPath[i].Key,
+              };
+              const data = await signedUrl( signedParams );
+
+              files.push(
+                  data,
+              );
+            }
+          } else {
+            logger.error( {
+              error: { folderPath: folderPath },
+              function: `getAuditFile - ${inputData.moduleType}`,
+              message: 'Bucket image data not availale',
+            } );
+            return res.sendError( 'Bucket is Empty', 204 );
+          }
+          result.push( {
+            type: msg.fileDetails[i].type,
+            file: files,
+          } );
+        }
+        break;
+      default:
+        return res.sendError( 'Please given valid moduleType', 400 );
+    }
+
+    const userdata = await findOneUser( { _id: req.user._id } );
+    const storeQuery = {
+      storeId: inputData.storeId,
+    };
+    const storeFields = {
+      'storeName': 1,
+      'storeProfile.address': 1,
+      'clientId': 1,
+    };
+    const storeInfo = await findOneStore( storeQuery, storeFields );
+
+    const logData = {
+      userId: req.user._id,
+      userName: userdata.name,
+      logType: 'audit',
+      logSubType: 'auditStart',
+      data: {
+        fileDate: msg.fileDate,
+        storeId: msg.storeId,
+        clientId: storeInfo?.clientId,
+        tempId: msg.tempId,
+        value: msg.value,
+        fileDetails: msg.fileDetails,
+        moduleType: inputData.moduleType,
+        question: msg.question,
+        questionType: msg.questionType,
+        streamName: msg.streamName,
+        actaulImage: msg.actual,
+        changedImage: msg.changed,
+      },
+      createdAt: new Date(),
+    };
+    await insertOpenSearchData( openSearch.auditLog, logData );
+
+    return res.sendSuccess( {
+      result: result,
+      storeId: msg.storeId,
+      storeName: storeInfo?.storeName,
+      address: storeInfo?.address,
+      customerId: msg.tempId,
+      moduleType: inputData.moduleType,
+      value: inputData.moduleType == 'left-in-middle'? 'Employee Left in Middle ' : ( inputData.moduleType ).split( '-' ).join( ' ' ),
+      fileDate: msg.fileDate,
+      question: msg.question,
+      questionType: msg.questionType,
+      streamName: msg.streamName,
+      auditId: inputData.auditId,
+    } );
+  } catch ( error ) {
+    const err = error.message || 'Internal Server Error';
+    logger.error( { error: error, data: req.body, function: 'getUpdatedFile' } );
+    return res.sendError( err, 500 );
+  }
+}
+
 export async function saveBinary( req, res ) {
   try {
     const inputData = req.body;
@@ -1151,6 +1400,7 @@ export async function saveBinary( req, res ) {
     const currentTime = dayjs();
     const isoDateTime = dayjs( isoDate );
     const timeDifferenceInMinutes = currentTime.diff( isoDateTime, 'seconds' );
+    const value = inputData.moduleType? inputData.moduleType.replace( /-/g, ' ' ) : '';
     switch ( inputData.moduleType ) {
       case 'unattended-customer':
         let unattendedquery ={
@@ -1170,10 +1420,10 @@ export async function saveBinary( req, res ) {
         };
         let updatDataunattended= await updateOneBinaryAuditModel( unattendedquery, update );
         if ( updatDataunattended.modifiedCount==0 ) {
-          return res.sendError( updatDataunattended, 204 );
+          return res.sendError( 'Update failed, it may be invalid request', 400 );
         }
         logger.info( 'update in binary data', { query: unattendedquery, update: update } );
-        res.sendSuccess( `Successfully update in ${inputData.moduleType} ` );
+        return res.sendSuccess( `Successfully updated in ${value}` );
 
         break;
 
@@ -1194,10 +1444,10 @@ export async function saveBinary( req, res ) {
         };
         let updatDataleft= await updateOneBinaryAuditModel( leftquery, leftupdate );
         if ( updatDataleft.modifiedCount==0 ) {
-          return res.sendError( updatDataleft, 204 );
+          return res.sendError( 'Update failed, it may be invalid request', 400 );
         }
         logger.info( 'update in binary data', { query: leftquery, update: leftupdate } );
-        res.sendSuccess( `Successfully update in ${inputData.moduleType} ` );
+        return res.sendSuccess( `Successfully updated in ${value}` );
 
         break;
 
@@ -1218,17 +1468,16 @@ export async function saveBinary( req, res ) {
         };
         let updatDatacamera= await updateOneBinaryAuditModel( cameraquery, cameraupdate );
         if ( updatDatacamera.modifiedCount==0 ) {
-          return res.sendError( updatDatacamera, 204 );
+          return res.sendError( 'Update failed, it may be invalid request', 400 );
         }
         logger.info( 'update in binary data', { query: cameraquery, update: cameraupdate } );
-        res.sendSuccess( `Successfully update in ${inputData.moduleType} ` );
+        return res.sendSuccess( `Successfully updated in ${value}` );
 
         break;
 
       default:
         res.sendError( 'no data', 204 );
-        break
-        ;
+        break;
     }
   } catch ( error ) {
     const err = error.mesage || 'Internal Server Error';
@@ -1248,6 +1497,7 @@ export async function userAuditHistory( req, res ) {
     let filter = [
       { userId: { $eq: userId } },
       { moduleType: { $eq: inputData.moduleType } },
+      { clientId: { $in: inputData.clientId } },
     ];
 
     if ( inputData.dateType == 'fileDate' ) {
@@ -1280,9 +1530,7 @@ export async function userAuditHistory( req, res ) {
         auditStatus: { $in: inputData.filterByStatus },
       } );
     }
-    if ( inputData?.clientId?.length > 0 ) {
-      filter.push( { clientId: { $in: inputData.clientId } } );
-    }
+
     const query = [
       {
         $match: {
@@ -1476,16 +1724,16 @@ export async function userAuditHistory( req, res ) {
           switch ( inputData.moduleType ) {
             case 'camera-angle-change':
               temp['stream Name'] = element.streamName;
-              temp['User Comments'] = element.userCommands;
+              temp['User Comments'] = element.userComments;
               break;
             case 'unattended-customer':
               temp['Customer ID'] = element.tempId;
               temp['Question'] = element.question;
-              temp['User Comments'] = element.userCommands;
+              temp['User Comments'] = element.userComments;
               break;
             case 'left-in-middle':
               temp['Question'] = element.question;
-              temp['User Comments'] = element.userCommands;
+              temp['User Comments'] = element.userComments;
               break;
             case 'uniform-detection':
               temp['Before Count'] = element.beforeCount;
@@ -1757,11 +2005,9 @@ export async function storeMetrics( req, res ) {
       { fileDateISO: { $gte: dateRange.start } },
       { fileDateISO: { $lte: dateRange.end } },
       { moduleType: { $eq: inputData.moduleType } },
+      { clientId: { $in: inputData.filterByClientId } },
 
     ];
-    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 } } );
@@ -1825,6 +2071,7 @@ export async function storeMetrics( req, res ) {
           },
           tempId: 1,
           streamName: 1,
+          userComments: 1,
           question: 1,
           questionType: 1,
           answer: 1,
@@ -1915,6 +2162,7 @@ export async function storeMetrics( req, res ) {
           streamName: 1,
           question: 1,
           questionType: 1,
+          userComments: 1,
           answer: 1,
           moduleType: 1,
           value: 1,
@@ -1959,6 +2207,191 @@ 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,
+          userComments: 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,
+          userComments: 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: {
@@ -1975,6 +2408,7 @@ export async function storeMetrics( req, res ) {
             { question: { $regex: inputData.searchValue, $options: 'i' } },
             { answer: { $regex: inputData.searchValue, $options: 'i' } },
             { auditStatus: { $regex: inputData.searchValue, $options: 'i' } },
+            { userComments: { $regex: inputData.searchValue, $options: 'i' } },
           ],
         },
       } );
@@ -1988,7 +2422,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 );
@@ -2022,16 +2456,16 @@ export async function storeMetrics( req, res ) {
         switch ( inputData.moduleType ) {
           case 'camera-angle-change':
             temp['stream Name'] = element.streamName;
-            temp['User Comments'] = element.auditStatus;
+            temp['User Comments'] = element.userComments;
             break;
           case 'unattended-customer':
             temp['Customer ID'] = element.tempId;
             temp['Question'] = element.question;
-            temp['User Comments'] = element.auditStatus;
+            temp['User Comments'] = element.userComments;
             break;
           case 'left-in-middle':
             temp['Question'] = element.question;
-            temp['User Comments'] = element.userCommands;
+            temp['User Comments'] = element.userComments;
             temp['Status'] = element.auditStatus;
             break;
           case 'mobile-detection':
@@ -2107,11 +2541,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 ] },
@@ -2379,13 +2812,10 @@ export async function pendingSummaryTable( req, res ) {
       { fileDateISO: { $lte: dateRange.end } },
       { auditStatus: { $ne: 'completed' } },
       { moduleType: { $eq: inputData.moduleType } },
+      { clientId: { $in: inputData.clientId } },
 
     ];
 
-    if ( inputData.clientId.length > 0 ) {
-      filters.push( { clientId: { $in: inputData.clientId } } );
-    }
-
     if ( inputData.filterByAuditType.length > 0 ) {
       filters.push( { auditType: { $in: inputData.filterByAuditType } } );
     }
@@ -2524,8 +2954,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 +2965,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;
@@ -2589,12 +3014,10 @@ export async function overAllAuditSummary( req, res ) {
     let filters =[
       { fileDateISO: { $gte: dateRange.start } },
       { fileDateISO: { $lte: dateRange.end } },
-      { moduleType: { $eq: inputData.moduleType },
-      },
+      { moduleType: { $eq: inputData.moduleType } },
+      { clientId: { $in: inputData.clientId } },
     ];
-    if ( inputData.clientId.length > 0 ) {
-      filters.push( { clientId: { $in: inputData.clientId } } );
-    }
+
     const storeQuery = inputData.clientId.length? { 'edge.firstFile': true, 'clientId': { $in: inputData. clientId } } : { 'edge.firstFile': true };
     temp.installedStores = await countDocumentsStore( storeQuery );
     const auditClientDataQuery =[
@@ -2669,7 +3092,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;
@@ -2708,10 +3181,9 @@ export async function summarySplit( req, res ) {
       { fileDateISO: { $gte: dateRange.start } },
       { fileDateISO: { $lte: dateRange.end } },
       { moduleType: { $eq: inputData.moduleType } },
+      { clientId: { $in: inputData.clientId } },
     ];
-    if ( inputData.clientId.length > 0 ) {
-      filters.push( { clientId: { $in: inputData.clientId } } );
-    }
+
     const query =[
       {
         $match: {
@@ -2822,13 +3294,10 @@ export async function overviewTable( req, res ) {
       { fileDateISO: { $gte: dateRange.start } },
       { fileDateISO: { $lte: dateRange.end } },
       { moduleType: { $eq: inputData.moduleType } },
+      { clientId: { $in: inputData.clientId } },
 
     ];
 
-    if ( inputData.clientId.length > 0 ) {
-      filters.push( { clientId: { $in: inputData.clientId } } );
-    }
-
     if ( inputData.filterByAuditType.length > 0 ) {
       filters.push( { auditType: { $in: inputData.filterByAuditType } } );
     }
@@ -2986,16 +3455,16 @@ export async function overviewTable( req, res ) {
         switch ( inputData.moduleType ) {
           case 'camera-angle-change':
             temp['stream Name'] = element.streamName;
-            temp['User Comments'] = element.userCommands;
+            temp['User Comments'] = element.userComments;
             break;
           case 'unattended-customer':
             temp['Customer ID'] = element.tempId;
             temp['Question'] = element.question;
-            temp['User Comments'] = element.userCommands;
+            temp['User Comments'] = element.userComments;
             break;
           case 'left-in-middle':
             temp['Question'] = element.question;
-            temp['User Comments'] = element.userCommands;
+            temp['User Comments'] = element.userComments;
             break;
           case 'mobile-detection':
             temp['Before Count'] = element.beforeCount;