tango-app-api-audit 3.4.51 → 3.4.52

package/package.json

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

package/src/controllers/traxAudit.controllers.js

@@ -66,7 +66,22 @@ export async function workSpace( req, res ) {
                                     { $eq: [ inputData.moduleType, 'eye-test-camera' ] }, '$auditConfigs.traxQueueName.eyeTestCamera',
                                     {
                                       $cond: [
-                                        { $eq: [ inputData.moduleType, 'cleaning' ] }, '$auditConfigs.traxQueueName.cleaning', '$auditConfigs.traxQueueName.scrum' ],
+                                        { $eq: [ inputData.moduleType, 'cleaning' ] }, '$auditConfigs.traxQueueName.cleaning',
+                                        {
+                                          $cond: [
+                                            { $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' ],
+                                                },
+                                              ],
+                                            },
+                                          ],
+                                        },
+                                      ],
                                     },
                                   ],
                                 },
@@ -208,18 +223,11 @@ export async function workSpace( req, res ) {
           },
         },
       },
-      // {
-      //   $group: {
-      //     _id: { clientId: '$clientId', storeId: '$storeId' },
-      //     clientId: { $first: '$clientId' },
-      //     completedStoresCount: { $sum: '$completed' },
-      //   },
-      // },
+
       {
         $group: {
           _id: '$clientId',
           clientId: { $first: '$clientId' },
-          // completedStoresCount: { $first: '$completedStoresCount' },
           completedStoresCount: { $sum: '$completed' },
         },
       },
@@ -544,6 +552,7 @@ export async function getAuditFile( req, res ) {
             };
             break;
           case 'camera-angle-change':
+          case 'anomaly-audit':
             query ={
               storeId: userDetails[0].storeId,
               fileDate: userDetails[0].fileDate,
@@ -632,10 +641,6 @@ export async function getAuditFile( req, res ) {
           const folderPath = list.data;
           if ( folderPath?.length ) {
             for ( let i = 0; i < folderPath.length; i++ ) {
-              // const signedParams ={
-              //   Bucket: msg.inputBucketName,
-              //   file_path: folderPath[i].Key,
-              // };
               const BucketCDN = url.traxAuditInput;
               const data = `${BucketCDN}${ folderPath[i].Key}`;
               files.push(
@@ -682,6 +687,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 );
     }
@@ -722,7 +740,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'? msg.streamName : '';
+      record.streamName = inputData.moduleType == 'camera-angle-change' || inputData.moduleType == 'eye-test-camera' || inputData.moduleType == 'anomaly-audit'? msg.streamName : '';
       record.videoDetails = inputData.moduleType == 'left-in-middle'? {
         'startHour': msg.startHour,
         'inspectHour': msg.inspectHour,
@@ -752,6 +770,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,
@@ -897,10 +916,6 @@ export async function getUpdatedFile( req, res ) {
           logger.info( { folderPath: list, params: params, list: list } );
           if ( folderPath?.length ) {
             for ( let i = 0; i < folderPath.length; i++ ) {
-              // const signedParams ={
-              //   Bucket: msg.inputBucketName,
-              //   file_path: folderPath[i].Key,
-              // };
               const BucketCDN = url.traxAuditInput;
               const data = `${BucketCDN}${ folderPath[i].Key}`;
 
@@ -947,6 +962,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 );
     }
@@ -1393,6 +1421,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,
+          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: inputData.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 );
@@ -1507,6 +1649,7 @@ export async function userAuditHistory( req, res ) {
         },
         ];
         break;
+      case 'anomaly-audit':
       case 'camera-angle-change':
         traxAuditDataQuery= {
           fileDate: '$fileDate', storeId: '$storeId', moduleType: '$moduleType', streamName: '$streamName',
@@ -1694,9 +1837,6 @@ export async function userAuditHistory( req, res ) {
               timezone: 'Asia/Kolkata',
             },
           },
-          // timeSpent: { $round: [
-          //   { $divide: [ '$timeSpent', 60 ] }, 2,
-          // ] },
           timeSpent: {
 
             $cond: [
@@ -1787,6 +1927,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;
@@ -2217,6 +2358,124 @@ 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':
+        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 = [
@@ -2256,24 +2515,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,
                 },
               },
             },
@@ -2725,6 +2972,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 );
@@ -3119,7 +3367,125 @@ 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':
+        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,
@@ -3129,24 +3495,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,
                 },
               },
             },
@@ -3257,7 +3611,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' } },
           ],
 
         },
@@ -3302,6 +3656,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;
@@ -3767,6 +4122,7 @@ export async function overviewTable( req, res ) {
         },
         ];
         break;
+      case 'anomaly-audit':
       case 'camera-angle-change':
         traxAuditDataQuery= {
           fileDate: '$fileDate', storeId: '$storeId', moduleType: '$moduleType', streamName: '$streamName',
@@ -3824,6 +4180,7 @@ export async function overviewTable( req, res ) {
         },
         ];
         break;
+
       default:
         return res.sendError( 'Please give valid modueType', 400 );
     }
@@ -3964,6 +4321,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;
@@ -4400,6 +4758,7 @@ export async function saveDraft( req, res ) {
     let storeQuery = {
       storeId: inputData.storeId,
       fileDate: inputData.fileDate,
+      moduleType: inputData.moduleType,
     };
 
     inputData?.zoneName ? storeQuery['zoneName'] = inputData?.zoneName : null;

package/src/validation/traxAuditValidation.js

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