tango-app-api-audit 3.4.59 → 3.4.61

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-audit",
-    "version": "3.4.59",
+    "version": "3.4.61",
     "description": "audit & audit metrics apis",
     "main": "index.js",
     "type": "module",
@@ -26,8 +26,8 @@
         "mongodb": "^6.7.0",
         "nodemon": "^3.1.3",
         "swagger-ui-express": "^5.0.1",
-        "tango-api-schema": "^2.2.93",
-        "tango-app-api-middleware": "^3.1.48",
+        "tango-api-schema": "^2.2.95",
+        "tango-app-api-middleware": "^3.1.71",
         "winston": "^3.13.0",
         "winston-daily-rotate-file": "^5.0.0"
     },

package/src/controllers/audit.controllers.js

@@ -4845,6 +4845,9 @@ export async function auditViewLogs( req, res ) {
           break;
         case 'uniform-detection':
         case 'mobile-detection':
+        case 'cleaning':
+        case 'open-time':
+        case 'close-time':
           logsQuery = {
             'size': 100,
             'query': {
@@ -4956,41 +4959,41 @@ export async function auditViewLogs( req, res ) {
             ],
           };
           break;
-        case 'scrum':
+
         case 'cleaning':
-          logsQuery = {
-            'size': 100,
-            'query': {
-              'bool': {
-                'must': [
-                  {
-                    'term': {
-                      'logData.fileDate.keyword': inputData.fileDate,
-                    },
-                  },
-                  {
-                    'term': {
-                      'logData.storeId.keyword': inputData.storeId,
-                    },
-                  },
-                  {
-                    'term': {
-                      'logData.moduleType.keyword': inputData.moduleType,
-                    },
-                  },
-                  {
-                    'terms': {
-                      'logSubType.keyword': [ 'auditDone', 'reTrigger' ],
-                    },
-                  },
-                ],
-              },
-            },
-            'sort': [
-              { createdAt: { order: 'desc' } },
-            ],
-          };
-          break;
+          // logsQuery = {
+          //   'size': 100,
+          //   'query': {
+          //     'bool': {
+          //       'must': [
+          //         {
+          //           'term': {
+          //             'logData.fileDate.keyword': inputData.fileDate,
+          //           },
+          //         },
+          //         {
+          //           'term': {
+          //             'logData.storeId.keyword': inputData.storeId,
+          //           },
+          //         },
+          //         {
+          //           'term': {
+          //             'logData.moduleType.keyword': inputData.moduleType,
+          //           },
+          //         },
+          //         {
+          //           'terms': {
+          //             'logSubType.keyword': [ 'auditDone', 'reTrigger' ],
+          //           },
+          //         },
+          //       ],
+          //     },
+          //   },
+          //   'sort': [
+          //     { createdAt: { order: 'desc' } },
+          //   ],
+          // };
+          // break;
         default:
           return res.sendError( 'Please give valid modueType', 400 );
       }

package/src/controllers/traxAudit.controllers.js

@@ -1,4 +1,4 @@
-import { checkFileExist, chunkArray, download, getDate, getDateWithCustomizeTime, getJsonFileData, getObject, getOpenSearchData, getUTC, insertOpenSearchData, listFileByPath, logger, signedUrl, sqsReceive, updateOpenSearchData } from 'tango-app-api-middleware';
+import { checkFileExist, chunkArray, download, getDate, getDateWithCustomizeTime, getJsonFileData, getObject, getOpenSearchData, getUTC, insertOpenSearchData, listFileByPath, logger, signedUrl, sqsReceive, updateOpenSearchData, sendMessageToQueue, listQueue, copyImage } from 'tango-app-api-middleware';
 import { aggregateBinaryAudit, findOneBinaryAudit, updateOneBinaryAuditModel, updateOneUpsertBinaryAudit } from '../service/binaryAudit.service.js';
 import { countDocumentsStore, findOneStore } from '../service/store.service.js';
 import { findOneUser } from '../service/user.service.js';
@@ -8,7 +8,6 @@ import { aggregateClient, findOneClient } from '../service/client.service.js';
 import dayjs from 'dayjs';
 import { aggregateAssignAudit } from '../service/assignAudit.service.js';
 import { aggregateStoreEmpDetection, updateManyStoreEmpDetection, updateOneStoreEmpDetection } from '../service/storeEmpDetection.service.js';
-import { listQueue, sendMessageToQueue } from 'tango-app-api-middleware/src/utils/aws/sqs.js';
 import _ from 'lodash';
 import mongoose from 'mongoose';
 import { findOneAuditLog, createAuditLog,
@@ -19,7 +18,6 @@ import {
 import { updateOneEmpDetectionOutput } from '../service/empDetectionOutput.service.js';
 import axios from 'axios';
 import FormData from 'form-data';
-
 export async function workSpace( req, res ) {
   try {
     const inputData = req.body;
@@ -547,6 +545,7 @@ export async function getAuditFile( req, res ) {
             };
             break;
           case 'camera-angle-change':
+          case 'anomaly-audit':
             query ={
               storeId: userDetails[0].storeId,
               fileDate: userDetails[0].fileDate,
@@ -714,6 +713,19 @@ export async function getAuditFile( 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 );
     }
@@ -753,7 +765,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 == 'scrum'? msg.streamName : '';
+      record.streamName =[ 'camera-angle-change', 'eye-test-camera', 'anomaly-audit', 'scrum' ].includes( inputData.moduleType )? msg.streamName : '';
       record.videoDetails = inputData.moduleType == 'left-in-middle'? {
         'startHour': msg.startHour,
         'inspectHour': msg.inspectHour,
@@ -783,6 +795,7 @@ 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,
@@ -1009,6 +1022,19 @@ 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 );
     }
@@ -1239,7 +1265,7 @@ export async function saveBinary( req, res ) {
           _id: inputData.auditId,
           storeId: inputData.storeId,
           fileDate: inputData.fileDate,
-          tempId: inputData.tempId,
+          streamName: req.userAudit?.streamName,
           moduleType: inputData.moduleType,
         };
 
@@ -1294,12 +1320,6 @@ export async function saveBinary( req, res ) {
               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,
@@ -1622,6 +1642,120 @@ 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,
+          streamName: req.userAudit?.streamName,
+          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': {
+              'streamName.keyword': inputData.streamName,
+            },
+          },
+        ];
+        let anomalySearchQuery={
+          'size': 1,
+          'query': {
+            'bool': {
+              'must': anomalyFilter,
+            },
+          },
+        };
+        const [ getStore2, getClient2 ] = 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 anomalyOutput = {
+          clientId: req.userAudit?.clientId,
+          clientName: getClient2?.clientName,
+          storeId: inputData.storeId,
+          storeName: getStore2?.storeName,
+          question: getData?.sqs?.Body?.question,
+          spocName: getStore2?.spocDetails? getStore2?.spocDetails[0]?.name : '',
+          spocEmail: getStore2?.spocDetails? getStore2?.spocDetails[0]?.email:'',
+          spocContact: getStore2?.spocDetails? getStore2?.spocDetails[0].contact:'',
+          address: getStore2?.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: anomalyOutput } );
+        if ( anomalySearchData?.body?.hits?.hits?.length >0 ) {
+          await updateOpenSearchData( openSearch.traxDetectionOutput, anomalySearchData?.body?.hits?.hits[0]?._id, { doc: anomalyOutput } );
+        } else {
+          await insertOpenSearchData( openSearch.traxDetectionOutput, anomalyOutput );
+        }
+
+        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 );
@@ -1738,6 +1872,7 @@ export async function userAuditHistory( req, res ) {
         },
         ];
         break;
+      case 'anomaly-audit':
       case 'camera-angle-change':
         traxAuditDataQuery= {
           fileDate: '$fileDate', storeId: '$storeId', moduleType: '$moduleType', streamName: '$streamName',
@@ -1925,9 +2060,6 @@ export async function userAuditHistory( req, res ) {
               timezone: 'Asia/Kolkata',
             },
           },
-          // timeSpent: { $round: [
-          //   { $divide: [ '$timeSpent', 60 ] }, 2,
-          // ] },
           timeSpent: {
 
             $cond: [
@@ -2018,6 +2150,7 @@ 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;
@@ -2450,6 +2583,126 @@ export async function storeMetrics( req, res ) {
     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':
+      case 'open-time':
+      case 'close-time':
+        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 = [
@@ -2489,24 +2742,12 @@ export async function storeMetrics( req, res ) {
       {
         $lookup: {
           from: 'traxAuditData',
-          let: {
-            fileDate: '$fileDate', storeId: '$storeId', zoneName: '$zoneName',
-          },
+          let: traxAuditDataQuery,
           pipeline: [
             {
               $match: {
                 $expr: {
-                  $and: [
-                    {
-                      $eq: [ '$fileDate', '$$fileDate' ],
-                    },
-                    {
-                      $eq: [ '$storeId', '$$storeId' ],
-                    },
-                    {
-                      $eq: [ '$zoneName', '$$zoneName' ],
-                    },
-                  ],
+                  $and: traxAuditDataFilter,
                 },
               },
             },
@@ -2958,6 +3199,7 @@ 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 );
@@ -3354,7 +3596,127 @@ export async function pendingSummaryTable( req, res ) {
     if ( inputData.filterByStatus.length > 0 ) {
       filters.push( { auditStatus: { $in: inputData.filterByStatus } } );
     }
-    const query =[
+
+    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':
+      case 'open-time':
+      case 'close-time':
+        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 =[
       {
         $match: {
           $and: filters,
@@ -3364,24 +3726,12 @@ export async function pendingSummaryTable( req, res ) {
       {
         $lookup: {
           from: 'traxAuditData',
-          let: {
-            fileDate: '$fileDate', storeId: '$storeId', zoneName: '$zoneName',
-          },
+          let: traxAuditDataQuery,
           pipeline: [
             {
               $match: {
                 $expr: {
-                  $and: [
-                    {
-                      $eq: [ '$fileDate', '$$fileDate' ],
-                    },
-                    {
-                      $eq: [ '$storeId', '$$storeId' ],
-                    },
-                    {
-                      $eq: [ '$zoneName', '$$zoneName' ],
-                    },
-                  ],
+                  $and: traxAuditDataFilter,
                 },
               },
             },
@@ -3492,7 +3842,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.searchData, $options: 'i' } },
+            { question: { $regex: inputData.searchValue, $options: 'i' } },
           ],
 
         },
@@ -3537,6 +3887,7 @@ 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;
@@ -4006,6 +4357,7 @@ export async function overviewTable( req, res ) {
         },
         ];
         break;
+      case 'anomaly-audit':
       case 'camera-angle-change':
         traxAuditDataQuery= {
           fileDate: '$fileDate', storeId: '$storeId', moduleType: '$moduleType', streamName: '$streamName',
@@ -4063,6 +4415,7 @@ export async function overviewTable( req, res ) {
         },
         ];
         break;
+
       default:
         return res.sendError( 'Please give valid modueType', 400 );
     }
@@ -4203,6 +4556,7 @@ 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;
@@ -4544,12 +4898,12 @@ export async function getDetectionAuditFile( req, res ) {
             const mapimg = {
               img_path: data,
               img_name: time,
-              img_id: `${item?.file_path}_${time}`,
+              img_id: `${item?.file_path}__${time}`,
             };
             files.push( {
               img_path: data,
               img_name: time,
-              img_id: `${item?.file_path}_${time}`,
+              img_id: `${item?.file_path}__${time}`,
               selected: false,
               dropped: false,
               singleDetection: false,
@@ -4794,6 +5148,7 @@ export async function getDraftedData( req, res ) {
 export async function save( req, res ) {
   try {
     const openSearch = JSON.parse( process.env.OPENSEARCH );
+    const bucket = JSON.parse( process.env.BUCKET );
     const sqs = JSON.parse( process.env.SQS );
     const inputData = req.body;
     const isoDate = req.userAudit?.startTime;
@@ -4823,12 +5178,7 @@ export async function save( req, res ) {
 
       logger.info( { userUpdate: userUpdate, storeUpdate: storeUpdate, function: 'saveUpdate' } );
       const getFilePath = await findOneTraxAuditData(
-          {
-            fileDate: inputData.fileDate,
-            storeId: inputData.storeId,
-            zoneName: inputData.zoneName,
-            moduleType: inputData.moduleType,
-          },
+          query,
       );
       if ( !getFilePath ) {
         return res.sendError( 'SQS is not sent due to Inserted Data is not there', 400 );
@@ -4870,7 +5220,7 @@ export async function save( req, res ) {
         }
       }
 
-      const outputFilePath = tempId[0]?.split( '_' );
+      const outputFilePath = tempId[0]?.split( '__' );
       // trax output in open serach
       const folderPath = getFilePath?.sqs?.Body?.folderPath;
       const output = {
@@ -4889,9 +5239,9 @@ export async function save( req, res ) {
         inputBucketName: getFilePath?.sqs?.Body?.inputBucketName,
         tempId: tempId,
         count: inputData.employeeCount,
-        time: [ 'open-time', 'close-time' ].includes( inputData?.moduleType )?outputFilePath[1]:'',
+        time: [ 'open-time', 'close-time' ].includes( inputData?.moduleType )?outputFilePath?outputFilePath[1]:'':'',
         bufferTime: [ 'open-time', 'close-time' ].includes( inputData?.moduleType )? getFilePath?.sqs?.Body?.bufferTime : '',
-        folderPath: [ 'open-time', 'close-time' ].includes( inputData?.moduleType )? outputFilePath[0]: folderPath.split( '/' ).slice( 0, -1 ).join( '/' ) + '/',
+        folderPath: [ 'open-time', 'close-time' ].includes( inputData?.moduleType )?outputFilePath? outputFilePath[0]:'': folderPath.split( '/' ).slice( 0, -1 ).join( '/' ) + '/',
         createdAt: new Date(),
       };
       let filter= [
@@ -4931,6 +5281,17 @@ export async function save( req, res ) {
         await insertOpenSearchData( openSearch.traxDetectionOutput, output );
       }
 
+      if ( [ 'open-time', 'close-time' ].includes( inputData.moduleType ) && outputFilePath ) {
+        const temp = inputData.moduleType.split( '-' );
+        const copyParams = {
+          Bucket: bucket.outputSnap,
+          CopySource: `/${getFilePath?.sqs?.Body?.inputBucketName}/${outputFilePath[0]}`,
+          Key: `${inputData.storeId}/${ inputData.fileDate}/operation_snaps/${temp[0]}.jpeg`,
+        };
+
+        await copyImage( copyParams );
+      }
+
       const logData = {
         userId: req.user._id,
         userName: req.user.userName,
@@ -4954,6 +5315,7 @@ export async function save( req, res ) {
         },
         createdAt: Date.now(),
       };
+
       await insertOpenSearchData( openSearch.auditLog, logData );
       return res.sendSuccess( { result: 'Updated Successfully' } );
     } else {
@@ -4995,8 +5357,8 @@ export async function reTrigger( req, res ) {
       default:
         return res.sendError( 'Please give valid module type' );
     }
-    if ( !getQueueName || queueName == '' ) {
-      return res.sendError( 'queueName does not create', 400 );
+    if ( !getQueueName || [ null, '', undefined ].includes( queueName ) ) {
+      return res.sendError( `The queueName ${queueName} does not create`, 400 );
     }
     let getQuery ={
       storeId: message.storeId,

package/src/validation/traxAuditValidation.js

@@ -90,6 +90,7 @@ export async function isTraxAuditDocumentExist( req, res, next ) {
         break;
       case 'camera-angle-change':
       case 'eye-test-camera':
+      case 'anomaly-audit':
       case 'scrum':
         query ={
           storeId: inputData.storeId,