tango-app-api-audit 3.4.54 → 3.4.55

package/src/controllers/traxAudit.controllers.js

@@ -72,11 +72,8 @@ export async function workSpace( req, res ) {
                                             { $eq: [ inputData.moduleType, 'scrum' ] }, '$auditConfigs.traxQueueName.scrum',
                                             {
                                               $cond: [
-                                                { $eq: [ inputData.moduleType, 'open-time' ] }, '$auditConfigs.traxQueueName.openTime',
-                                                {
-                                                  $cond: [
-                                                    { $eq: [ inputData.moduleType, 'close-time' ] }, '$auditConfigs.traxQueueName.closeTime', '$auditConfigs.traxQueueName.anomaly' ],
-                                                },
+                                                { $and: [ { $eq: [ inputData.moduleType, 'open-time' ] }, { $eq: [ inputData.moduleType, 'close-time' ] } ] }, '$auditConfigs.traxQueueName.openClose', '$auditConfigs.traxQueueName.anomaly',
+
                                               ],
                                             },
                                           ],
@@ -223,7 +220,6 @@ export async function workSpace( req, res ) {
           },
         },
       },
-
       {
         $group: {
           _id: '$clientId',
@@ -375,7 +371,6 @@ export async function workSpace( req, res ) {
 
     const auditUserCount = [ 'mobile-detection', 'uniform-detection', 'hygiene' ].includes( inputData.moduleType )?await aggregateUserEmpDetection( auditFiles ) : await aggregateBinaryAudit( auditFiles );
     const userIncompleteFilesCount = [ 'mobile-detection', 'uniform-detection', 'hygiene' ].includes( inputData.moduleType )?await aggregateUserEmpDetection( userIncompleteFiles ) : await aggregateBinaryAudit( userIncompleteFiles );
-    logger.info( { moduleType: inputData.moduleType, userIncompleteFiles: userIncompleteFilesCount } );
     const userAsignAuditCount = await aggregateAssignAudit( userAsignAudit );
     const completedStoresCount = [ 'mobile-detection', 'uniform-detection', 'hygiene' ].includes( inputData.moduleType )? await aggregateStoreEmpDetection( completedStores ) : await aggregateBinaryAudit( binarCompletedStores );
     const clientAssignedCount = await aggregateAssignAudit( clientAssign );
@@ -552,7 +547,6 @@ export async function getAuditFile( req, res ) {
             };
             break;
           case 'camera-angle-change':
-          case 'anomaly-audit':
             query ={
               storeId: userDetails[0].storeId,
               fileDate: userDetails[0].fileDate,
@@ -570,11 +564,18 @@ export async function getAuditFile( req, res ) {
             };
             break;
           case 'cleaning':
+            query ={
+              storeId: userDetails[0].storeId,
+              fileDate: userDetails[0].fileDate,
+              moduleType: userDetails[0].moduleType,
+            };
+            break;
           case 'scrum':
             query ={
               storeId: userDetails[0].storeId,
               fileDate: userDetails[0].fileDate,
               moduleType: userDetails[0].moduleType,
+              streamName: userDetails[0].moduleType,
             };
             break;
           default:
@@ -629,7 +630,6 @@ export async function getAuditFile( req, res ) {
       case 'unattended-customer':
       case 'left-in-middle':
       case 'cleaning':
-      case 'scrum':
         for ( let i =0; i< msg.fileDetails.length; i++ ) {
           const files = [];
           const params ={
@@ -661,6 +661,35 @@ export async function getAuditFile( req, res ) {
           } );
         }
         break;
+      case 'scrum':
+        for ( let i =0; i< msg.fileDetails.length; i++ ) {
+          const files = [];
+          const params ={
+            Bucket: msg.inputBucketName,
+            Key: msg?.fileDetails[i]?.folderPath,
+          };
+
+          const isFileExists = await checkFileExist( params );
+          if ( isFileExists ) {
+            const data = `${url.traxAuditInput}${msg?.fileDetails[i]?.folderPath}`;
+
+            files.push(
+                data,
+            );
+          } else {
+            logger.error( {
+              error: { folderPath: msg?.fileDetails[i]?.folderPath },
+              function: `getAuditFile - ${inputData.moduleType}`,
+              message: 'Bucket image data not availale',
+            } );
+            return res.sendError( 'File not found', 204 );
+          }
+          result.push( {
+            type: msg.fileDetails[i].type,
+            file: files,
+          } );
+        }
+        break;
       case 'eye-test-camera':
         const eyeTestfiles = [];
 
@@ -672,34 +701,19 @@ export async function getAuditFile( req, res ) {
         const isCameraExists = await checkFileExist( eyeTestparams );
 
         if ( isCameraExists ) {
-          const url = JSON.parse( process.env.URL );
-          logger.info( { url: url, cameraBaseImage: url.cameraBaseImage } );
           const data = `${url.cameraBaseImage}${msg?.filePath}`;
 
           eyeTestfiles.push(
               data,
           );
         } else {
-          return res.sendSuccess( 'No Data found', 204 );
+          return res.sendSuccess( 'No Data Found', 204 );
         }
         result.push( {
           type: 'image',
           file: eyeTestfiles,
         } );
         break;
-      case 'anomaly-audit':
-        for ( let i =0; i< msg.fileDetails.length; i++ ) {
-          const files = [];
-          const data = msg.fileDetails[i].folderPath;
-          files.push(
-              data,
-          );
-          result.push( {
-            type: msg.fileDetails[i].type,
-            file: files,
-          } );
-        }
-        break;
       default:
         return res.sendError( 'Please given valid moduleType', 400 );
     }
@@ -719,7 +733,6 @@ export async function getAuditFile( req, res ) {
       const [ day, month, year ] = msg.fileDate.split( '-' );
       const temp = `${year}-${month}-${day}`;
       let start = new Date( temp );
-      logger.info( { start: start, date: msg.fileDate } );
       const userTimezoneOffset = start.getTimezoneOffset() * 60000;
       start = new Date( start.getTime() - userTimezoneOffset );
       start.setUTCHours( 0, 0, 0, 0 );
@@ -740,7 +753,7 @@ export async function getAuditFile( req, res ) {
         questionType: msg.questionType,
         streamName: msg.streamName,
       };
-      record.streamName = inputData.moduleType == 'camera-angle-change' || inputData.moduleType == 'eye-test-camera' || inputData.moduleType == 'anomaly-audit'? msg.streamName : '';
+      record.streamName = inputData.moduleType == 'camera-angle-change' || inputData.moduleType == 'eye-test-camera' || inputData.moduleType == 'scrum'? msg.streamName : '';
       record.videoDetails = inputData.moduleType == 'left-in-middle'? {
         'startHour': msg.startHour,
         'inspectHour': msg.inspectHour,
@@ -770,7 +783,6 @@ export async function getAuditFile( req, res ) {
           break;
         case 'camera-angle-change':
         case 'eye-test-camera':
-        case 'anomaly-audit':
           getQuery ={
             storeId: msg.storeId,
             fileDate: msg.fileDate,
@@ -779,11 +791,18 @@ export async function getAuditFile( req, res ) {
           };
           break;
         case 'cleaning':
+          getQuery ={
+            storeId: msg.storeId,
+            fileDate: msg.fileDate,
+            moduleType: inputData.moduleType,
+          };
+          break;
         case 'scrum':
           getQuery ={
             storeId: msg.storeId,
             fileDate: msg.fileDate,
             moduleType: inputData.moduleType,
+            streamName: msg.streamName,
           };
           break;
         default:
@@ -903,7 +922,6 @@ export async function getUpdatedFile( req, res ) {
       case 'unattended-customer':
       case 'left-in-middle':
       case 'cleaning':
-      case 'scrum':
         for ( let i =0; i< msg.fileDetails.length; i++ ) {
           const files = [];
           const params ={
@@ -937,6 +955,35 @@ export async function getUpdatedFile( req, res ) {
           } );
         }
         break;
+      case 'scrum':
+        for ( let i =0; i< msg.fileDetails.length; i++ ) {
+          const files = [];
+          const params ={
+            Bucket: msg.inputBucketName,
+            Key: msg?.fileDetails[i]?.folderPath,
+          };
+
+          const isFileExists = await checkFileExist( params );
+          if ( isFileExists ) {
+            const data = `${url.traxAuditInput}${msg?.fileDetails[i]?.folderPath}`;
+
+            files.push(
+                data,
+            );
+          } else {
+            logger.error( {
+              error: { folderPath: folderPath },
+              function: `getAuditFile - ${inputData.moduleType}`,
+              message: 'Bucket image data not availale',
+            } );
+            return res.sendError( 'File not found', 204 );
+          }
+          result.push( {
+            type: msg.fileDetails[i].type,
+            file: files,
+          } );
+        }
+        break;
       case 'eye-test-camera':
         const eyeTestfiles = [];
 
@@ -962,19 +1009,6 @@ export async function getUpdatedFile( req, res ) {
           file: eyeTestfiles,
         } );
         break;
-      case 'anomaly-audit':
-        for ( let i =0; i< msg.fileDetails.length; i++ ) {
-          const files = [];
-          const data = msg.fileDetails[i].folderPath;
-          files.push(
-              data,
-          );
-          result.push( {
-            type: msg.fileDetails[i].type,
-            file: files,
-          } );
-        }
-        break;
       default:
         return res.sendError( 'Please given valid moduleType', 400 );
     }
@@ -1047,8 +1081,6 @@ export async function saveBinary( req, res ) {
     const value = inputData.moduleType? inputData.moduleType.replace( /-/g, ' ' ) : '';
     switch ( inputData.moduleType ) {
       case 'unattended-customer':
-      case 'cleaning':
-      case 'scrum':
         let unattendedquery ={
           _id: inputData.auditId,
           storeId: inputData.storeId,
@@ -1068,66 +1100,6 @@ export async function saveBinary( req, res ) {
         if ( updatDataunattended.modifiedCount==0 ) {
           return res.sendError( 'Update failed, it may be invalid request', 400 );
         }
-        if ( [ 'cleaning', 'scrum' ].includes( inputData.moduleType ) ) {
-          let filter= [
-            {
-              'term': {
-                'storeId.keyword': inputData.storeId,
-              },
-            },
-            {
-              'term': {
-                'fileDate.keyword': inputData.fileDate,
-              },
-            },
-            {
-              'term': {
-                'moduleType.keyword': inputData.moduleType,
-              },
-            },
-          ];
-          let searchQuery={
-            'size': 1,
-            'query': {
-              'bool': {
-                'must': filter,
-              },
-            },
-          };
-          const [ getStore, getClient ] = await Promise.all( [ findOneStore( { storeId: inputData.storeId }, { storeName: 1, storeProfile: 1, spocDetails: 1 } ), findOneClient( { clientId: req.userAudit?.clientId }, { clientName: 1 } ) ] );
-          const getFilePath = await findOneTraxAuditData(
-              {
-                fileDate: inputData.fileDate,
-                storeId: inputData.storeId,
-                moduleType: inputData.moduleType,
-              },
-          );
-          const output = {
-            clientId: req.userAudit?.clientId,
-            clientName: getClient?.clientName,
-            storeId: inputData.storeId,
-            storeName: getStore?.storeName,
-            question: getFilePath?.sqs?.Body?.question,
-            spocName: getStore?.spocDetails? getStore?.spocDetails[0]?.name : '',
-            spocEmail: getStore?.spocDetails? getStore?.spocDetails[0]?.email:'',
-            spocContact: getStore?.spocDetails? getStore?.spocDetails[0].contact:'',
-            address: getStore?.storeProfile?.address,
-            fileDate: inputData.fileDate,
-            moduleType: inputData.moduleType,
-            Answer: inputData.answer,
-            configTime: getFilePath?.sqs?.Body?.configTime,
-            inputBucketName: getFilePath?.sqs?.Body?.inputBucketName,
-            folderPath: [ 'cleaning', 'scrum' ].includes( inputData.moduleType ) ? getFilePath?.sqs?.Body?.fileDetails[0]?.outputFilePath : folderPath.split( '/' ).slice( 0, -1 ).join( '/' ) + '/',
-            createdAt: new Date(),
-          };
-          const searchData= await getOpenSearchData( openSearch.traxDetectionOutput, searchQuery );
-          logger.info( { length: searchData?.body?.hits?.hits?.length, _id: searchData?.body?.hits?.hits[0]?._id, output: output } );
-          if ( searchData?.body?.hits?.hits?.length >0 ) {
-            await updateOpenSearchData( openSearch.traxDetectionOutput, searchData?.body?.hits?.hits[0]?._id, { doc: output } );
-          } else {
-            await insertOpenSearchData( openSearch.traxDetectionOutput, output );
-          }
-        }
         const logData2 = {
           userId: req.user._id,
           userName: req.user.userName,
@@ -1140,8 +1112,6 @@ export async function saveBinary( req, res ) {
             moduleType: req.userAudit?.moduleType,
             queueName: req.userAudit?.queueName,
             clientId: req.userAudit?.clientId,
-            // beforeCount: req.userAudit?.beforeCount,
-            // afterCount: inputData.employeeCount,
             startTime: req.userAudit?.startTime,
             streamName: req.userAudit?.streamName,
             tempId: req.userAudit?.tempId,
@@ -1157,63 +1127,87 @@ export async function saveBinary( req, res ) {
         return res.sendSuccess( `Successfully updated in ${value}` );
 
         break;
-
-      case 'uniform-detection':
-        let uniformDetectionQuery ={
+      case 'cleaning':
+        let cleaningQuery ={
           _id: inputData.auditId,
           storeId: inputData.storeId,
           fileDate: inputData.fileDate,
-          // tempId: inputData.tempId,
           moduleType: inputData.moduleType,
         };
 
-        let updateUniform={
+        let cleaningUpdate={
           auditStatus: 'completed',
           answer: inputData.answer,
           userComments: inputData.userComments || '',
           endTime: new Date(),
           timeSpent: timeDifferenceInMinutes,
         };
-        let updatDataUniform= await updateOneBinaryAuditModel( uniformDetectionQuery, updateUniform );
-        if ( updatDataUniform.modifiedCount==0 ) {
+        let updatDataCleaning= await updateOneBinaryAuditModel( cleaningQuery, cleaningUpdate );
+        if ( updatDataCleaning.modifiedCount==0 ) {
           return res.sendError( 'Update failed, it may be invalid request', 400 );
         }
-        const getFilePath = await findOneTraxAuditData(
+        let cleaningFilter= [
+          {
+            'term': {
+              'storeId.keyword': inputData.storeId,
+            },
+          },
+          {
+            'term': {
+              'fileDate.keyword': inputData.fileDate,
+            },
+          },
+          {
+            'term': {
+              'moduleType.keyword': inputData.moduleType,
+            },
+          },
+        ];
+        let cleaningSearchQuery={
+          'size': 1,
+          'query': {
+            'bool': {
+              'must': cleaningFilter,
+            },
+          },
+        };
+        const [ getStore, getClient ] = await Promise.all( [ findOneStore( { storeId: inputData.storeId }, { storeName: 1, storeProfile: 1, spocDetails: 1 } ), findOneClient( { clientId: req.userAudit?.clientId }, { clientName: 1 } ) ] );
+        const getCleaningFilePath = await findOneTraxAuditData(
             {
               fileDate: inputData.fileDate,
               storeId: inputData.storeId,
               moduleType: inputData.moduleType,
-              tempId: inputData.tempId,
             },
         );
-        if ( !getFilePath ) {
-          return res.sendError( ' SQS is not sent due to Inserted Data is not there', 400 );
-        }
-        const sqsProduceQueue = {
-          QueueUrl: `${sqs.url}${sqs.uniformOutput}`,
-          MessageBody: JSON.stringify( {
-            storeId: inputData.storeId,
-            fileDate: inputData.fileDate,
-            tempId: inputData.tempId,
-            moduleType: inputData.moduleType,
-            answer: inputData.answer,
-            inputBucketName: getFilePath?.sqs?.Body?.inputBucketName,
-            filePath: getFilePath?.sqs?.Body?.filePath,
-          } ),
+        const output = {
+          clientId: req.userAudit?.clientId,
+          clientName: getClient?.clientName,
+          storeId: inputData.storeId,
+          storeName: getStore?.storeName,
+          question: getCleaningFilePath?.sqs?.Body?.question,
+          spocName: getStore?.spocDetails? getStore?.spocDetails[0]?.name : '',
+          spocEmail: getStore?.spocDetails? getStore?.spocDetails[0]?.email:'',
+          spocContact: getStore?.spocDetails? getStore?.spocDetails[0].contact:'',
+          address: getStore?.storeProfile?.address,
+          fileDate: inputData.fileDate,
+          moduleType: inputData.moduleType,
+          Answer: inputData.answer,
+          configTime: getCleaningFilePath?.sqs?.Body?.configTime,
+          isDownTime: getCleaningFilePath?.sqs?.Body?.isDownTime,
+          downTime: getCleaningFilePath?.sqs?.Body?.downTime,
+          inputBucketName: getCleaningFilePath?.sqs?.Body?.inputBucketName,
+          folderPath: getCleaningFilePath?.sqs?.Body?.fileDetails[0]?.outputFilePath,
+          createdAt: new Date(),
         };
-        const sqsQueue = await sendMessageToQueue(
-            sqsProduceQueue.QueueUrl,
-            sqsProduceQueue.MessageBody,
-        );
-
-        if ( sqsQueue.statusCode ) {
-          logger.error( {
-            error: `${sqsQueue}`,
-            type: 'UPLOAD_ERROR',
-          } );
-          return res.sendError( 'SQS not sent', 500 );
+        const cleaningSearchData= await getOpenSearchData( openSearch.traxDetectionOutput, cleaningSearchQuery );
+        logger.info( { length: cleaningSearchData?.body?.hits?.hits?.length, _id: cleaningSearchData?.body?.hits?.hits[0]?._id, output: output } );
+        if ( cleaningSearchData?.body?.hits?.hits?.length >0 ) {
+          await updateOpenSearchData( openSearch.traxDetectionOutput, cleaningSearchData?.body?.hits?.hits[0]?._id, { doc: output } );
+        } else {
+          await insertOpenSearchData( openSearch.traxDetectionOutput, output );
         }
-        const logData3 = {
+
+        const logDataClean = {
           userId: req.user._id,
           userName: req.user.userName,
           logType: 'traxAudit',
@@ -1225,8 +1219,6 @@ export async function saveBinary( req, res ) {
             moduleType: req.userAudit?.moduleType,
             queueName: req.userAudit?.queueName,
             clientId: req.userAudit?.clientId,
-            // beforeCount: req.userAudit?.beforeCount,
-            // afterCount: inputData.employeeCount,
             startTime: req.userAudit?.startTime,
             streamName: req.userAudit?.streamName,
             tempId: req.userAudit?.tempId,
@@ -1238,30 +1230,108 @@ export async function saveBinary( req, res ) {
           },
           createdAt: Date.now(),
         };
-        await insertOpenSearchData( openSearch.auditLog, logData3 );
+        await insertOpenSearchData( openSearch.auditLog, logDataClean );
         return res.sendSuccess( `Successfully updated in ${value}` );
-        break;
 
-      case 'left-in-middle':
-        let leftquery ={
+        break;
+      case 'scrum':
+        let scrumQuery ={
           _id: inputData.auditId,
           storeId: inputData.storeId,
           fileDate: inputData.fileDate,
-          question: inputData.question,
+          tempId: inputData.tempId,
           moduleType: inputData.moduleType,
         };
-        let leftupdate={
+
+        let scrumUpdate={
           auditStatus: 'completed',
           answer: inputData.answer,
           userComments: inputData.userComments || '',
           endTime: new Date(),
           timeSpent: timeDifferenceInMinutes,
         };
-        let updatDataleft= await updateOneBinaryAuditModel( leftquery, leftupdate );
-        if ( updatDataleft.modifiedCount==0 ) {
+        let updateScrum= await updateOneBinaryAuditModel( scrumQuery, scrumUpdate );
+        if ( updateScrum.modifiedCount==0 ) {
           return res.sendError( 'Update failed, it may be invalid request', 400 );
         }
-        const logData1 = {
+
+        let scrumFilter= [
+          {
+            'term': {
+              'storeId.keyword': inputData.storeId,
+            },
+          },
+          {
+            'term': {
+              'fileDate.keyword': inputData.fileDate,
+            },
+          },
+          {
+            'term': {
+              'moduleType.keyword': inputData.moduleType,
+            },
+          },
+          {
+            'term': {
+              'streamName.keyword': req.userAudit?.streamName,
+            },
+          },
+        ];
+        let scrumSearchQuery={
+          'size': 1,
+          'query': {
+            'bool': {
+              'must': scrumFilter,
+            },
+          },
+        };
+        const [ getStore1, getClient1 ] = await Promise.all( [ findOneStore( { storeId: inputData.storeId }, { storeName: 1, storeProfile: 1, spocDetails: 1 } ), findOneClient( { clientId: req.userAudit?.clientId }, { clientName: 1 } ) ] );
+        const getScrumFilePath = await findOneTraxAuditData(
+            {
+              fileDate: inputData.fileDate,
+              storeId: inputData.storeId,
+              moduleType: inputData.moduleType,
+              streamName: req.userAudit?.streamName,
+            },
+        );
+        logger.info( { getScrumFilePath: getScrumFilePath, data: {
+          fileDate: inputData.fileDate,
+          storeId: inputData.storeId,
+          moduleType: inputData.moduleType,
+          streamName: req.userAudit?.streamName,
+        }, mesage: '.............1' } );
+        const scrumOutput = {
+          clientId: req.userAudit?.clientId,
+          clientName: getClient1?.clientName,
+          storeId: inputData.storeId,
+          storeName: getStore1?.storeName,
+          streamName: req.userAudit?.streamName,
+          question: getScrumFilePath?.sqs?.Body?.question,
+          spocName: getStore1?.spocDetails? getStore1?.spocDetails[0]?.name : '',
+          spocEmail: getStore1?.spocDetails? getStore1?.spocDetails[0]?.email:'',
+          spocContact: getStore1?.spocDetails? getStore1?.spocDetails[0].contact:'',
+          address: getStore1?.storeProfile?.address,
+          fileDate: inputData.fileDate,
+          moduleType: inputData.moduleType,
+          Answer: inputData.answer,
+          configTime: getScrumFilePath?.sqs?.Body?.configTime,
+          huddleDuration: getScrumFilePath?.sqs?.Body?.huddleDuration,
+          huddleSlot: getScrumFilePath?.sqs?.Body?.huddleSlot,
+          isDownTime: getScrumFilePath?.sqs?.Body?.isDownTime,
+          downTime: getScrumFilePath?.sqs?.Body?.downTime,
+          inputBucketName: getScrumFilePath?.sqs?.Body?.inputBucketName,
+          folderPath: getScrumFilePath?.sqs?.Body?.fileDetails[0]?.outputFilePath,
+          createdAt: new Date(),
+        };
+        const scrumSearchData= await getOpenSearchData( openSearch.traxDetectionOutput, scrumSearchQuery );
+        logger.info( { length: scrumSearchData?.body?.hits?.hits?.length, _id: scrumSearchData?.body?.hits?.hits[0]?._id, output: scrumOutput } );
+        if ( scrumSearchData?.body?.hits?.hits?.length >0 ) {
+          await updateOpenSearchData( openSearch.traxDetectionOutput, scrumSearchData?.body?.hits?.hits[0]?._id, { doc: scrumOutput } );
+        } else {
+          await insertOpenSearchData( openSearch.traxDetectionOutput, scrumOutput );
+        }
+
+        const scrumLogData = {
           userId: req.user._id,
           userName: req.user.userName,
           logType: 'traxAudit',
@@ -1273,8 +1343,6 @@ export async function saveBinary( req, res ) {
             moduleType: req.userAudit?.moduleType,
             queueName: req.userAudit?.queueName,
             clientId: req.userAudit?.clientId,
-            // beforeCount: req.userAudit?.beforeCount,
-            // afterCount: inputData.employeeCount,
             startTime: req.userAudit?.startTime,
             streamName: req.userAudit?.streamName,
             tempId: req.userAudit?.tempId,
@@ -1286,17 +1354,150 @@ export async function saveBinary( req, res ) {
           },
           createdAt: Date.now(),
         };
-        await insertOpenSearchData( openSearch.auditLog, logData1 );
+        await insertOpenSearchData( openSearch.auditLog, scrumLogData );
         return res.sendSuccess( `Successfully updated in ${value}` );
 
         break;
 
-      case 'camera-angle-change':
-        let cameraquery ={
+      case 'uniform-detection':
+        let uniformDetectionQuery ={
           _id: inputData.auditId,
           storeId: inputData.storeId,
           fileDate: inputData.fileDate,
-          streamName: inputData.streamName,
+          // tempId: inputData.tempId,
+          moduleType: inputData.moduleType,
+        };
+
+        let updateUniform={
+          auditStatus: 'completed',
+          answer: inputData.answer,
+          userComments: inputData.userComments || '',
+          endTime: new Date(),
+          timeSpent: timeDifferenceInMinutes,
+        };
+        let updatDataUniform= await updateOneBinaryAuditModel( uniformDetectionQuery, updateUniform );
+        if ( updatDataUniform.modifiedCount==0 ) {
+          return res.sendError( 'Update failed, it may be invalid request', 400 );
+        }
+        const getFilePath = await findOneTraxAuditData(
+            {
+              fileDate: inputData.fileDate,
+              storeId: inputData.storeId,
+              moduleType: inputData.moduleType,
+              tempId: inputData.tempId,
+            },
+        );
+        if ( !getFilePath ) {
+          return res.sendError( ' SQS is not sent due to Inserted Data is not there', 400 );
+        }
+        const sqsProduceQueue = {
+          QueueUrl: `${sqs.url}${sqs.uniformOutput}`,
+          MessageBody: JSON.stringify( {
+            storeId: inputData.storeId,
+            fileDate: inputData.fileDate,
+            tempId: inputData.tempId,
+            moduleType: inputData.moduleType,
+            answer: inputData.answer,
+            inputBucketName: getFilePath?.sqs?.Body?.inputBucketName,
+            filePath: getFilePath?.sqs?.Body?.filePath,
+          } ),
+        };
+        const sqsQueue = await sendMessageToQueue(
+            sqsProduceQueue.QueueUrl,
+            sqsProduceQueue.MessageBody,
+        );
+
+        if ( sqsQueue.statusCode ) {
+          logger.error( {
+            error: `${sqsQueue}`,
+            type: 'UPLOAD_ERROR',
+          } );
+          return res.sendError( 'SQS not sent', 500 );
+        }
+        const logData3 = {
+          userId: req.user._id,
+          userName: req.user.userName,
+          logType: 'traxAudit',
+          logSubType: 'auditDone',
+          logData: {
+            fileDate: req.userAudit?.fileDate,
+            auditType: req.userAudit?.auditType,
+            storeId: req.userAudit?.storeId,
+            moduleType: req.userAudit?.moduleType,
+            queueName: req.userAudit?.queueName,
+            clientId: req.userAudit?.clientId,
+            // beforeCount: req.userAudit?.beforeCount,
+            // afterCount: inputData.employeeCount,
+            startTime: req.userAudit?.startTime,
+            streamName: req.userAudit?.streamName,
+            tempId: req.userAudit?.tempId,
+            question: req.userAudit?.question,
+            result: req.userAudit?.answer,
+            endTime: Date.now(),
+            timeSpent: timeDifferenceInMinutes,
+            auditId: new mongoose.Types.ObjectId( inputData.auditId ),
+          },
+          createdAt: Date.now(),
+        };
+        await insertOpenSearchData( openSearch.auditLog, logData3 );
+        return res.sendSuccess( `Successfully updated in ${value}` );
+        break;
+
+      case 'left-in-middle':
+        let leftquery ={
+          _id: inputData.auditId,
+          storeId: inputData.storeId,
+          fileDate: inputData.fileDate,
+          question: inputData.question,
+          moduleType: inputData.moduleType,
+        };
+        let leftupdate={
+          auditStatus: 'completed',
+          answer: inputData.answer,
+          userComments: inputData.userComments || '',
+          endTime: new Date(),
+          timeSpent: timeDifferenceInMinutes,
+        };
+        let updatDataleft= await updateOneBinaryAuditModel( leftquery, leftupdate );
+        if ( updatDataleft.modifiedCount==0 ) {
+          return res.sendError( 'Update failed, it may be invalid request', 400 );
+        }
+        const logData1 = {
+          userId: req.user._id,
+          userName: req.user.userName,
+          logType: 'traxAudit',
+          logSubType: 'auditDone',
+          logData: {
+            fileDate: req.userAudit?.fileDate,
+            auditType: req.userAudit?.auditType,
+            storeId: req.userAudit?.storeId,
+            moduleType: req.userAudit?.moduleType,
+            queueName: req.userAudit?.queueName,
+            clientId: req.userAudit?.clientId,
+            // beforeCount: req.userAudit?.beforeCount,
+            // afterCount: inputData.employeeCount,
+            startTime: req.userAudit?.startTime,
+            streamName: req.userAudit?.streamName,
+            tempId: req.userAudit?.tempId,
+            question: req.userAudit?.question,
+            result: req.userAudit?.answer,
+            endTime: Date.now(),
+            timeSpent: timeDifferenceInMinutes,
+            auditId: new mongoose.Types.ObjectId( inputData.auditId ),
+          },
+          createdAt: Date.now(),
+        };
+        await insertOpenSearchData( openSearch.auditLog, logData1 );
+        return res.sendSuccess( `Successfully updated in ${value}` );
+
+        break;
+
+      case 'camera-angle-change':
+        let cameraquery ={
+          _id: inputData.auditId,
+          storeId: inputData.storeId,
+          fileDate: inputData.fileDate,
+          streamName: inputData.streamName,
           moduleType: inputData.moduleType,
         };
         let cameraupdate={
@@ -1421,120 +1622,6 @@ export async function saveBinary( req, res ) {
           return res.sendSuccess( `Successfully updated in ${value}` );
         }
 
-      case 'anomaly-audit':
-        let anomalyQury ={
-          _id: inputData.auditId,
-          storeId: inputData.storeId,
-          fileDate: inputData.fileDate,
-          tempId: inputData.tempId,
-          moduleType: inputData.moduleType,
-        };
-
-        let anomalyRecord={
-          auditStatus: 'completed',
-          answer: inputData.answer,
-          userComments: inputData.userComments || '',
-          endTime: new Date(),
-          timeSpent: timeDifferenceInMinutes,
-        };
-        let updatedAnomaly= await updateOneBinaryAuditModel( anomalyQury, anomalyRecord );
-        if ( updatedAnomaly==0 ) {
-          return res.sendError( 'Update failed, it may be invalid request', 400 );
-        }
-        let anomalyFilter= [
-          {
-            'term': {
-              'storeId.keyword': inputData.storeId,
-            },
-          },
-          {
-            'term': {
-              'fileDate.keyword': inputData.fileDate,
-            },
-          },
-          {
-            'term': {
-              'moduleType.keyword': inputData.moduleType,
-            },
-          },
-          {
-            'term': {
-              'moduleType.keyword': inputData.streamName,
-            },
-          },
-        ];
-        let anomalySearchQuery={
-          'size': 1,
-          'query': {
-            'bool': {
-              'must': anomalyFilter,
-            },
-          },
-        };
-        const [ getStore, getClient ] = await Promise.all( [ findOneStore( { storeId: inputData.storeId }, { storeName: 1, storeProfile: 1, spocDetails: 1 } ), findOneClient( { clientId: req.userAudit?.clientId }, { clientName: 1 } ) ] );
-        const getData = await findOneTraxAuditData(
-            {
-              fileDate: inputData.fileDate,
-              storeId: inputData.storeId,
-              moduleType: inputData.moduleType,
-              streamName: req.userAudit?.streamName,
-            },
-        );
-        const output = {
-          clientId: req.userAudit?.clientId,
-          clientName: getClient?.clientName,
-          storeId: inputData.storeId,
-          storeName: getStore?.storeName,
-          question: getData?.sqs?.Body?.question,
-          spocName: getStore?.spocDetails? getStore?.spocDetails[0]?.name : '',
-          spocEmail: getStore?.spocDetails? getStore?.spocDetails[0]?.email:'',
-          spocContact: getStore?.spocDetails? getStore?.spocDetails[0].contact:'',
-          address: getStore?.storeProfile?.address,
-          fileDate: inputData.fileDate,
-          moduleType: inputData.moduleType,
-          Answer: inputData.answer,
-          configTime: getData?.sqs?.Body?.configTime,
-          inputBucketName: getData?.sqs?.Body?.inputBucketName,
-          incidentType: getData?.sqs?.Body?.incidentType,
-          incidentId: getData?.sqs?.Body?.incidentId,
-          incidentTime: getData?.sqs?.Body?.incidentTime,
-          thumnailImage: getData?.sqs?.Body?.thumnailImage,
-          folderPath: getData?.sqs?.Body?.fileDetails[0]?.outputFilePath,
-          createdAt: new Date(),
-        };
-        const anomalySearchData= await getOpenSearchData( openSearch.traxDetectionOutput, anomalySearchQuery );
-        logger.info( { length: anomalySearchData?.body?.hits?.hits?.length, _id: anomalySearchData?.body?.hits?.hits[0]?._id, output: output } );
-        if ( anomalySearchData?.body?.hits?.hits?.length >0 ) {
-          await updateOpenSearchData( openSearch.traxDetectionOutput, anomalySearchData?.body?.hits?.hits[0]?._id, { doc: output } );
-        } else {
-          await insertOpenSearchData( openSearch.traxDetectionOutput, output );
-        }
-
-        const logData4 = {
-          userId: req.user._id,
-          userName: req.user.userName,
-          logType: 'traxAudit',
-          logSubType: 'auditDone',
-          logData: {
-            fileDate: req.userAudit?.fileDate,
-            auditType: req.userAudit?.auditType,
-            storeId: req.userAudit?.storeId,
-            moduleType: req.userAudit?.moduleType,
-            queueName: req.userAudit?.queueName,
-            clientId: req.userAudit?.clientId,
-            startTime: req.userAudit?.startTime,
-            streamName: req.userAudit?.streamName,
-            tempId: req.userAudit?.tempId,
-            question: req.userAudit?.question,
-            result: req.userAudit?.answer,
-            endTime: Date.now(),
-            timeSpent: timeDifferenceInMinutes,
-            auditId: new mongoose.Types.ObjectId( inputData.auditId ),
-          },
-          createdAt: Date.now(),
-        };
-        await insertOpenSearchData( openSearch.auditLog, logData4 );
-        return res.sendSuccess( `Successfully updated in ${value}` );
 
       default:
         res.sendError( 'No Data', 204 );
@@ -1649,7 +1736,6 @@ export async function userAuditHistory( req, res ) {
         },
         ];
         break;
-      case 'anomaly-audit':
       case 'camera-angle-change':
         traxAuditDataQuery= {
           fileDate: '$fileDate', storeId: '$storeId', moduleType: '$moduleType', streamName: '$streamName',
@@ -1837,6 +1923,9 @@ export async function userAuditHistory( req, res ) {
               timezone: 'Asia/Kolkata',
             },
           },
+          // timeSpent: { $round: [
+          //   { $divide: [ '$timeSpent', 60 ] }, 2,
+          // ] },
           timeSpent: {
 
             $cond: [
@@ -1927,7 +2016,6 @@ export async function userAuditHistory( req, res ) {
 
           };
           switch ( inputData.moduleType ) {
-            case 'anomaly-audit':
             case 'camera-angle-change':
               temp['stream Name'] = element.streamName;
               temp['Result'] = element.answer;
@@ -2256,225 +2344,107 @@ export async function clientMetrics( req, res ) {
           {
             $match: { clientStatus: { $in: inputData.filterByStatus } },
           },
-
-      );
-    }
-
-    if ( inputData.searchValue && inputData.searchValue!== '' ) {
-      query.push( {
-        $match: {
-          $or: [
-            { clientId: { $regex: inputData.searchValue, $options: 'i' } },
-            { clientName: { $regex: inputData.searchValue, $options: 'i' } },
-            { moduleType: { $regex: inputData.searchValue, $options: 'i' } },
-            { clientStatus: { $regex: inputData.searchValue, $options: 'i' } },
-          ],
-
-        },
-      } );
-    }
-    if ( inputData.sortColumnName ) {
-      const sortBy = inputData.sortBy || -1;
-      const sortColumn = inputData.sortColumnName;
-      query.push( {
-        $sort: { [sortColumn]: sortBy },
-      },
-      );
-    }
-
-    const count = await aggregateTraxAuditData( query );
-    if ( count.length == 0 ) {
-      return res.sendError( 'No Data Found', 204 );
-    }
-
-    if ( inputData.isExport ) {
-      query.push( { $limit: 10000 } );
-    } else {
-      query.push( {
-        $skip: offset,
-      },
-      {
-        $limit: limit,
-      } );
-    }
-    if ( inputData.isExport ) {
-      query.push(
-          {
-            $project: {
-              '_id': 0,
-              'File Date': '$fileDate',
-              'Brand Name': '$clientName',
-              'Brand Id': '$clientId',
-              'Product Type': '$value',
-              'Installed Stores': '$installedStore',
-              'Audit Stores': '$totalFilesCount',
-              'Inprogress Stores': '$inprogressStoresCount',
-              'Not Assigned Stores': '$notAssignedCount',
-              'Completed Stores': '$completedStores',
-              'Status': '$clientStatus',
-            },
-          },
-      );
-    }
-
-    const result = await aggregateTraxAuditData( query );
-    if ( result.length == 0 ) {
-      return res.sendError( 'No Data Found', 204 );
-    }
-    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.error( { error: error, message: req.body, function: 'clientMetrics' } );
-    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 } },
-      { moduleType: { $eq: inputData.moduleType } },
-      { clientId: { $in: inputData.filterByClientId } },
-
-    ];
-
-    if ( inputData.filterByStoreId && inputData.filterByStoreId?.length > 0 ) {
-      filter.push( { storeId: { $in: inputData.filterByStoreId } } );
-    }
-
-    if ( inputData.filterByStatus && inputData.filterByStatus?.length > 0 ) {
-      [ 'mobile-detection', 'uniform-detection', 'hygiene' ].includes( inputData.moduleType )? filter.push( { status: { $in: inputData.filterByStatus } } ) : filter.push( { auditStatus: { $in: inputData.filterByStatus } } );
-    }
-
-    if ( inputData.filterByAuditType && inputData.filterByAuditType?.length > 0 ) {
-      filter.push( { auditType: { $in: inputData.filterByAuditType } } );
-    }
-    let traxAuditDataQuery ={};
-    let traxAuditDataFilter = [];
-    switch ( inputData.moduleType ) {
-      case 'unattended-customer':
-        traxAuditDataQuery= {
-          fileDate: '$fileDate', storeId: '$storeId', tempId: '$tempId', moduleType: '$moduleType',
-        };
-        traxAuditDataFilter=[ {
-          $eq: [ '$fileDate', '$$fileDate' ],
-        },
-        {
-          $eq: [ '$storeId', '$$storeId' ],
-        },
-        {
-          $eq: [ '$tempId', '$$tempId' ],
-        },
-        {
-          $eq: [ '$moduleType', '$$moduleType' ],
-        },
-        ];
-        break;
-      case 'left-in-middle':
-        traxAuditDataQuery= {
-          fileDate: '$fileDate', storeId: '$storeId', tempId: '$tempId', moduleType: '$moduleType',
-        };
-        traxAuditDataFilter=[ {
-          $eq: [ '$fileDate', '$$fileDate' ],
-        },
-        {
-          $eq: [ '$storeId', '$$storeId' ],
-        },
-        {
-          $eq: [ '$question', '$$question' ],
-        },
-        {
-          $eq: [ '$moduleType', '$$moduleType' ],
-        },
-        ];
-        break;
-      case 'uniform-detection':
-      case 'mobile-detection':
-      case 'scrum':
-      case 'cleaning':
-        traxAuditDataQuery= {
-          fileDate: '$fileDate', storeId: '$storeId', moduleType: '$moduleType',
-        };
-        traxAuditDataFilter=[ {
-          $eq: [ '$fileDate', '$$fileDate' ],
-        },
-        {
-          $eq: [ '$storeId', '$$storeId' ],
-        },
-        {
-          $eq: [ '$moduleType', '$$moduleType' ],
-        },
-        ];
-        break;
-      case 'anomaly-audit':
-      case 'camera-angle-change':
-        traxAuditDataQuery= {
-          fileDate: '$fileDate', storeId: '$storeId', moduleType: '$moduleType', streamName: '$streamName',
-        };
-        traxAuditDataFilter=[ {
-          $eq: [ '$fileDate', '$$fileDate' ],
-        },
-        {
-          $eq: [ '$storeId', '$$storeId' ],
-        },
-        {
-          $eq: [ '$streamName', '$$streamName' ],
-        },
-        {
-          $eq: [ '$moduleType', '$$moduleType' ],
-        },
-        ];
-        break;
-      case 'hygiene':
-        traxAuditDataQuery= {
-          fileDate: '$fileDate', storeId: '$storeId', moduleType: '$moduleType', zoneName: '$zoneName',
-        };
-        traxAuditDataFilter=[ {
-          $eq: [ '$fileDate', '$$fileDate' ],
-        },
-        {
-          $eq: [ '$storeId', '$$storeId' ],
-        },
-        {
-          $eq: [ '$zoneName', '$$zoneName' ],
-        },
-        {
-          $eq: [ '$moduleType', '$$moduleType' ],
-        },
-        ];
-        break;
-      case 'eye-test-camera':
-        traxAuditDataQuery= {
-          fileDate: '$fileDate', storeId: '$storeId', moduleType: '$moduleType', question: '$question', streamName: '$streamName',
-        };
-        traxAuditDataFilter=[ {
-          $eq: [ '$fileDate', '$$fileDate' ],
-        },
-        {
-          $eq: [ '$storeId', '$$storeId' ],
-        },
-        {
-          $eq: [ '$question', '$$question' ],
-        },
-        {
-          $eq: [ '$streamName', '$$streamName' ],
-        },
-        {
-          $eq: [ '$moduleType', '$$moduleType' ],
+
+      );
+    }
+
+    if ( inputData.searchValue && inputData.searchValue!== '' ) {
+      query.push( {
+        $match: {
+          $or: [
+            { clientId: { $regex: inputData.searchValue, $options: 'i' } },
+            { clientName: { $regex: inputData.searchValue, $options: 'i' } },
+            { moduleType: { $regex: inputData.searchValue, $options: 'i' } },
+            { clientStatus: { $regex: inputData.searchValue, $options: 'i' } },
+          ],
+
         },
-        ];
-        break;
-      default:
-        return res.sendError( 'Please give valid modueType', 400 );
+      } );
+    }
+    if ( inputData.sortColumnName ) {
+      const sortBy = inputData.sortBy || -1;
+      const sortColumn = inputData.sortColumnName;
+      query.push( {
+        $sort: { [sortColumn]: sortBy },
+      },
+      );
+    }
+
+    const count = await aggregateTraxAuditData( query );
+    if ( count.length == 0 ) {
+      return res.sendError( 'No Data Found', 204 );
+    }
+
+    if ( inputData.isExport ) {
+      query.push( { $limit: 10000 } );
+    } else {
+      query.push( {
+        $skip: offset,
+      },
+      {
+        $limit: limit,
+      } );
+    }
+    if ( inputData.isExport ) {
+      query.push(
+          {
+            $project: {
+              '_id': 0,
+              'File Date': '$fileDate',
+              'Brand Name': '$clientName',
+              'Brand Id': '$clientId',
+              'Product Type': '$value',
+              'Installed Stores': '$installedStore',
+              'Audit Stores': '$totalFilesCount',
+              'Inprogress Stores': '$inprogressStoresCount',
+              'Not Assigned Stores': '$notAssignedCount',
+              'Completed Stores': '$completedStores',
+              'Status': '$clientStatus',
+            },
+          },
+      );
+    }
+
+    const result = await aggregateTraxAuditData( query );
+    if ( result.length == 0 ) {
+      return res.sendError( 'No Data Found', 204 );
+    }
+    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.error( { error: error, message: req.body, function: 'clientMetrics' } );
+    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 } },
+      { moduleType: { $eq: inputData.moduleType } },
+      { clientId: { $in: inputData.filterByClientId } },
+
+    ];
+
+    if ( inputData.filterByStoreId && inputData.filterByStoreId?.length > 0 ) {
+      filter.push( { storeId: { $in: inputData.filterByStoreId } } );
+    }
+
+    if ( inputData.filterByStatus && inputData.filterByStatus?.length > 0 ) {
+      [ 'mobile-detection', 'uniform-detection', 'hygiene' ].includes( inputData.moduleType )? filter.push( { status: { $in: inputData.filterByStatus } } ) : filter.push( { auditStatus: { $in: inputData.filterByStatus } } );
+    }
+
+    if ( inputData.filterByAuditType && inputData.filterByAuditType?.length > 0 ) {
+      filter.push( { auditType: { $in: inputData.filterByAuditType } } );
     }
 
 
@@ -2515,12 +2485,24 @@ export async function storeMetrics( req, res ) {
       {
         $lookup: {
           from: 'traxAuditData',
-          let: traxAuditDataQuery,
+          let: {
+            fileDate: '$fileDate', storeId: '$storeId', zoneName: '$zoneName',
+          },
           pipeline: [
             {
               $match: {
                 $expr: {
-                  $and: traxAuditDataFilter,
+                  $and: [
+                    {
+                      $eq: [ '$fileDate', '$$fileDate' ],
+                    },
+                    {
+                      $eq: [ '$storeId', '$$storeId' ],
+                    },
+                    {
+                      $eq: [ '$zoneName', '$$zoneName' ],
+                    },
+                  ],
                 },
               },
             },
@@ -2972,7 +2954,6 @@ export async function storeMetrics( req, res ) {
         };
         switch ( inputData.moduleType ) {
           case 'camera-angle-change':
-          case 'anomaly-audit':
             temp['stream Name'] = element.streamName;
             temp['User Comments'] = element.userComments;
             temp['Status'] = toCamelCase( element.auditStatus );
@@ -3367,125 +3348,7 @@ export async function pendingSummaryTable( req, res ) {
     if ( inputData.filterByStatus.length > 0 ) {
       filters.push( { auditStatus: { $in: inputData.filterByStatus } } );
     }
-
-    let traxAuditDataQuery={};
-    let traxAuditDataFilter = [];
-    switch ( inputData.moduleType ) {
-      case 'unattended-customer':
-        traxAuditDataQuery= {
-          fileDate: '$fileDate', storeId: '$storeId', tempId: '$tempId', moduleType: '$moduleType',
-        };
-        traxAuditDataFilter=[ {
-          $eq: [ '$fileDate', '$$fileDate' ],
-        },
-        {
-          $eq: [ '$storeId', '$$storeId' ],
-        },
-        {
-          $eq: [ '$tempId', '$$tempId' ],
-        },
-        {
-          $eq: [ '$moduleType', '$$moduleType' ],
-        },
-        ];
-        break;
-      case 'left-in-middle':
-        traxAuditDataQuery= {
-          fileDate: '$fileDate', storeId: '$storeId', tempId: '$tempId', moduleType: '$moduleType',
-        };
-        traxAuditDataFilter=[ {
-          $eq: [ '$fileDate', '$$fileDate' ],
-        },
-        {
-          $eq: [ '$storeId', '$$storeId' ],
-        },
-        {
-          $eq: [ '$question', '$$question' ],
-        },
-        {
-          $eq: [ '$moduleType', '$$moduleType' ],
-        },
-        ];
-        break;
-      case 'uniform-detection':
-      case 'mobile-detection':
-      case 'scrum':
-      case 'cleaning':
-        traxAuditDataQuery= {
-          fileDate: '$fileDate', storeId: '$storeId', moduleType: '$moduleType',
-        };
-        traxAuditDataFilter=[ {
-          $eq: [ '$fileDate', '$$fileDate' ],
-        },
-        {
-          $eq: [ '$storeId', '$$storeId' ],
-        },
-        {
-          $eq: [ '$moduleType', '$$moduleType' ],
-        },
-        ];
-        break;
-      case 'anomaly-audit':
-      case 'camera-angle-change':
-        traxAuditDataQuery= {
-          fileDate: '$fileDate', storeId: '$storeId', moduleType: '$moduleType', streamName: '$streamName',
-        };
-        traxAuditDataFilter=[ {
-          $eq: [ '$fileDate', '$$fileDate' ],
-        },
-        {
-          $eq: [ '$storeId', '$$storeId' ],
-        },
-        {
-          $eq: [ '$streamName', '$$streamName' ],
-        },
-        {
-          $eq: [ '$moduleType', '$$moduleType' ],
-        },
-        ];
-        break;
-      case 'hygiene':
-        traxAuditDataQuery= {
-          fileDate: '$fileDate', storeId: '$storeId', moduleType: '$moduleType', zoneName: '$zoneName',
-        };
-        traxAuditDataFilter=[ {
-          $eq: [ '$fileDate', '$$fileDate' ],
-        },
-        {
-          $eq: [ '$storeId', '$$storeId' ],
-        },
-        {
-          $eq: [ '$zoneName', '$$zoneName' ],
-        },
-        {
-          $eq: [ '$moduleType', '$$moduleType' ],
-        },
-        ];
-        break;
-      case 'eye-test-camera':
-        traxAuditDataQuery= {
-          fileDate: '$fileDate', storeId: '$storeId', moduleType: '$moduleType', question: '$question', streamName: '$streamName',
-        };
-        traxAuditDataFilter=[ {
-          $eq: [ '$fileDate', '$$fileDate' ],
-        },
-        {
-          $eq: [ '$storeId', '$$storeId' ],
-        },
-        {
-          $eq: [ '$question', '$$question' ],
-        },
-        {
-          $eq: [ '$streamName', '$$streamName' ],
-        },
-        {
-          $eq: [ '$moduleType', '$$moduleType' ],
-        },
-        ];
-        break;
-      default:
-        return res.sendError( 'Please give valid modueType', 400 );
-    } const query =[
+    const query =[
       {
         $match: {
           $and: filters,
@@ -3495,12 +3358,24 @@ export async function pendingSummaryTable( req, res ) {
       {
         $lookup: {
           from: 'traxAuditData',
-          let: traxAuditDataQuery,
+          let: {
+            fileDate: '$fileDate', storeId: '$storeId', zoneName: '$zoneName',
+          },
           pipeline: [
             {
               $match: {
                 $expr: {
-                  $and: traxAuditDataFilter,
+                  $and: [
+                    {
+                      $eq: [ '$fileDate', '$$fileDate' ],
+                    },
+                    {
+                      $eq: [ '$storeId', '$$storeId' ],
+                    },
+                    {
+                      $eq: [ '$zoneName', '$$zoneName' ],
+                    },
+                  ],
                 },
               },
             },
@@ -3611,7 +3486,7 @@ export async function pendingSummaryTable( req, res ) {
             { userName: { $regex: inputData.searchValue, $options: 'i' } },
             { userEmail: { $regex: inputData.searchValue, $options: 'i' } },
             { value: { $regex: inputData.searchValue, $options: 'i' } },
-            { question: { $regex: inputData.searchValue, $options: 'i' } },
+            { question: { $regex: inputData.searchData, $options: 'i' } },
           ],
 
         },
@@ -3656,7 +3531,6 @@ export async function pendingSummaryTable( req, res ) {
           'Status': toCamelCase( element.auditStatus ),
         };
         switch ( inputData.moduleType ) {
-          case 'anomaly-audit':
           case 'camera-angle-change':
             temp['stream Name'] = element.streamName;
             break;
@@ -4122,7 +3996,6 @@ export async function overviewTable( req, res ) {
         },
         ];
         break;
-      case 'anomaly-audit':
       case 'camera-angle-change':
         traxAuditDataQuery= {
           fileDate: '$fileDate', storeId: '$storeId', moduleType: '$moduleType', streamName: '$streamName',
@@ -4180,7 +4053,6 @@ export async function overviewTable( req, res ) {
         },
         ];
         break;
-
       default:
         return res.sendError( 'Please give valid modueType', 400 );
     }
@@ -4321,7 +4193,6 @@ export async function overviewTable( req, res ) {
         };
 
         switch ( inputData.moduleType ) {
-          case 'anomaly-audit':
           case 'camera-angle-change':
             temp['stream Name'] = element.streamName;
             temp['User Comments'] = element.userComments;