tango-app-api-trax 3.9.58 → 3.9.60

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-trax",
-    "version": "3.9.58",
+    "version": "3.9.60",
     "description": "Trax",
     "main": "index.js",
     "type": "module",

package/src/controllers/teaxFlag.controller.js

@@ -415,24 +415,18 @@ export const flagCardsV1 = async ( req, res ) => {
       detectionFlag: { count: 0 },
     };
 
-    let requestData = req.body;
+    const requestData = req.body;
 
     const findQuery = [
       {
         $match: {
           client_id: clientId,
           date_iso: { $gte: adjustedFromDate, $lte: adjustedToDate },
-          $or: clientId === '11' ?
-        [
-          { store_id: { $in: storeId } },
-          { store_id: { $eq: '' }, userEmail: { $in: requestData.userEmailes } },
-          { aiStoreList: { $in: storeId } },
-        ] :
-        [
-          { store_id: { $in: storeId } },
-          { store_id: { $eq: '' }, userEmail: { $in: requestData.userEmailes } },
-          { aiStoreList: { $in: storeId } },
-        ],
+          $or: [
+            { store_id: { $in: storeId } },
+            { store_id: { $eq: '' }, userEmail: { $in: requestData.userEmailes } },
+            { aiStoreList: { $in: storeId } },
+          ],
         },
       },
       {
@@ -444,51 +438,38 @@ export const flagCardsV1 = async ( req, res ) => {
       {
         $group: {
           _id: null,
-          totalFlag: { $sum: { $add: [ '$questionFlag', '$timeFlag' ] } },
           questionFlag: { $sum: '$questionFlag' },
           delayInSubmission: { $sum: '$timeFlag' },
         },
       },
     ];
 
-    const getOverallChecklistData = await processedchecklistService.aggregate( findQuery );
+    // These three lookups are independent of one another, so run them concurrently
+    // instead of sequentially (Mongo aggregation + config find + detection Lambda).
+    const detectionPayload = { fromDate, toDate, storeId, clientId };
+    const lambdaURL = 'https://f65azvtljclaxp6l7rnx65cdmm0lcgvp.lambda-url.ap-south-1.on.aws/';
 
-    if ( !getOverallChecklistData.length ) {
-      const resVal = {
-        'flagCards': {
-          'totalFlag': 0,
-          'questionFlag': {
-            'count': 0,
-          },
-          'delayInSubmission': {
-            'count': 0,
-          },
-          'detectionFlag': {
-            'count': 0,
+    const [ getOverallChecklistData, publishedAiChecklists, resultData ] = await Promise.all( [
+      processedchecklistService.aggregate( findQuery ),
+      checklistconfigService.find(
+          {
+            client_id: clientId,
+            publish: true,
+            checkListType: { $in: [ 'customerunattended', 'mobileusagedetection', 'staffleftinthemiddle', 'storeopenandclose', 'uniformdetection', 'cleaning', 'scrum', 'outsidebusinesshoursqueuetracking', 'halfshutter', 'tvcompliance', 'cameratampering', 'queuealert', 'staffgrouping', 'boxalert', 'employeeCount', 'storehygienemonitoring', 'unattendeddetection' ] },
           },
-        },
-      };
-      return res.sendSuccess( resVal );
+          { checkListType: 1 },
+      ),
+      LamdaServiceCall( lambdaURL, detectionPayload ),
+    ] );
+
+    if ( !getOverallChecklistData.length ) {
+      return res.sendSuccess( { flagCards } );
     }
 
     const [ data ] = getOverallChecklistData;
-    if ( data.totalFlag ) flagCards.totalFlag = data.totalFlag;
     if ( data.questionFlag ) flagCards.questionFlag.count = data.questionFlag;
     if ( data.delayInSubmission ) flagCards.delayInSubmission.count = data.delayInSubmission;
-
-    const publishedAiChecklists = await checklistconfigService.find(
-        {
-          client_id: clientId,
-          publish: true,
-          checkListType: { $in: [ 'customerunattended', 'mobileusagedetection', 'staffleftinthemiddle', 'storeopenandclose', 'uniformdetection', 'cleaning', 'scrum', 'outsidebusinesshoursqueuetracking', 'halfshutter', 'tvcompliance', 'cameratampering', 'queuealert', 'staffgrouping', 'boxalert', 'employeeCount', 'storehygienemonitoring', 'unattendeddetection', 'employeemonitoring', 'activitymonitoring' ] },
-        },
-        { checkListType: 1 },
-    );
-
-    const detectionPayload = { fromDate, toDate, storeId, clientId };
-    const lambdaURL = 'https://f65azvtljclaxp6l7rnx65cdmm0lcgvp.lambda-url.ap-south-1.on.aws/';
-    const resultData = await LamdaServiceCall( lambdaURL, detectionPayload );
-
+    flagCards.totalFlag = flagCards.questionFlag.count + flagCards.delayInSubmission.count;
 
     const published = publishedAiChecklists.map( ( val ) => val?.checkListType );
 
@@ -941,7 +922,9 @@ export const flagTablesV1 = async ( req, res ) => {
 
 
 // Lamda Service Call //
-async function LamdaServiceCall( url, data ) {
+async function LamdaServiceCall( url, data, timeoutMs = 8000 ) {
+  const controller = new AbortController();
+  const timer = setTimeout( () => controller.abort(), timeoutMs );
   try {
     const requestOptions = {
       method: 'POST',
@@ -949,17 +932,20 @@ async function LamdaServiceCall( url, data ) {
         'Content-Type': 'application/json',
       },
       body: JSON.stringify( data ),
+      keepalive: true,
+      signal: controller.signal,
     };
     const response = await fetch( url, requestOptions );
     if ( !response.ok ) {
       throw new Error( `Response status: ${response.status}` );
-      return false;
     }
     const json = await response.json();
     return json;
   } catch ( error ) {
     logger.error( { error: error, message: data, function: 'LamdaServiceCall' } );
     return false;
+  } finally {
+    clearTimeout( timer );
   }
 }
 
@@ -2021,25 +2007,27 @@ export const flagComparisonCardsV2 = async ( req, res ) => {
         clientId: requestData.clientId,
       };
 
-      const publishedAiChecklists = await checklistconfigService.find(
-          {
-            client_id: requestData.clientId,
-            publish: true,
-            checkListType: { $in: [ 'customerunattended', 'mobileusagedetection', 'staffleftinthemiddle', 'storeopenandclose', 'uniformdetection', 'cleaning', 'scrum', 'outsidebusinesshoursqueuetracking', 'halfshutter', 'tvcompliance', 'cameratampering', 'queuealert', 'staffgrouping', 'boxalert', 'employeeCount', 'storehygienemonitoring', 'unattendeddetection', 'employeemonitoring', 'activitymonitoring' ] },
-          },
-          { checkListType: 1 },
-      );
+      // The config lookup and the detection Lambda are independent — run them together.
+      const LamdaURL = 'https://f65azvtljclaxp6l7rnx65cdmm0lcgvp.lambda-url.ap-south-1.on.aws/';
+      const [ publishedAiChecklists, resultData ] = await Promise.all( [
+        checklistconfigService.find(
+            {
+              client_id: requestData.clientId,
+              publish: true,
+              checkListType: { $in: [ 'customerunattended', 'mobileusagedetection', 'staffleftinthemiddle', 'storeopenandclose', 'uniformdetection', 'cleaning', 'scrum', 'outsidebusinesshoursqueuetracking', 'halfshutter', 'tvcompliance', 'cameratampering', 'queuealert', 'staffgrouping', 'boxalert', 'employeeCount', 'storehygienemonitoring', 'unattendeddetection', 'employeemonitoring' ] },
+            },
+            { checkListType: 1 },
+        ),
+        LamdaServiceCall( LamdaURL, detectionPayload ),
+      ] );
       // if ( !publishedAiChecklists?.length ) {
       //   return 0;
       // }
-
-      const LamdaURL = 'https://f65azvtljclaxp6l7rnx65cdmm0lcgvp.lambda-url.ap-south-1.on.aws/';
-      const resultData = await LamdaServiceCall( LamdaURL, detectionPayload );
       const published = publishedAiChecklists.map( ( val ) => val?.checkListType );
       if ( resultData?.status_code === '200' ) {
         let result = 0;
         let ai = 0;
-        if ( !publishedAiChecklists?.length ) {
+        if ( publishedAiChecklists?.length ) {
           published.forEach( ( item ) => {
             if ( resultData[item] ) {
               result += resultData[item];
@@ -2052,11 +2040,12 @@ export const flagComparisonCardsV2 = async ( req, res ) => {
       return 0;
     };
 
-    const [ rangeOneData, rangeTwoData, rangeOneDetectionCount, rangeTwoDetectionCount ] = await Promise.all( [
+    const [ rangeOneData, rangeTwoData, rangeOneDetectionCount, rangeTwoDetectionCount, traxMonthlyComparisonData ] = await Promise.all( [
       processedchecklistService.aggregate( createFindQuery( rangeOneFromDate, rangeOneToDate ) ),
       processedchecklistService.aggregate( createFindQuery( rangeTwoFromDate, rangeTwoToDate ) ),
       getDetectionCount( rangeOneFromDate, rangeOneToDate ),
       getDetectionCount( rangeTwoFromDate, rangeTwoToDate ),
+      clientService.findOne( { clientId: requestData.clientId }, { traxMonthlyComparison: 1 } ),
     ] );
 
     // console.log( 'rangeOneFromDate =>', rangeOneFromDate );
@@ -2085,7 +2074,6 @@ export const flagComparisonCardsV2 = async ( req, res ) => {
       flagComparisonCards.runAIComparisonFlag = calculateComparison( rangeOneDetectionCount.ai, rangeTwoDetectionCount.ai );
     }
     flagComparisonCards.traxMonthlyComparison = false;
-    let traxMonthlyComparisonData = await clientService.findOne( { clientId: requestData.clientId }, { traxMonthlyComparison: 1 } );
     if ( traxMonthlyComparisonData && traxMonthlyComparisonData.traxMonthlyComparison ) {
       flagComparisonCards.traxMonthlyComparison = traxMonthlyComparisonData.traxMonthlyComparison;
     }
@@ -2106,6 +2094,8 @@ export const flagTablesV2 = async ( req, res ) => {
     toDate = new Date( toDate.getTime() - userTimezoneOffset );
     toDate.setUTCHours( 23, 59, 59, 59 );
     let result = {};
+    let limit = parseInt( requestData?.limit ) || 10;
+    let skip = limit * ( requestData?.offset ) || 0;
 
     const lamdaUrl = JSON.parse( process.env.LAMBDAURL );
 
@@ -2114,19 +2104,19 @@ export const flagTablesV2 = async ( req, res ) => {
     findAndQuery.push(
         { client_id: requestData.clientId },
         { date_iso: { $gte: fromDate, $lte: toDate } },
-        // { $or: [ { store_id: { $in: requestData.storeId } }, { store_id: { $eq: '' }, userEmail: { $in: requestData.userEmailes } }, { aiStoreList: { $in: requestData.storeId } } ] },
+        { $or: [ { store_id: { $in: requestData.storeId } }, { store_id: { $eq: '' }, userEmail: { $in: requestData.userEmailes } }, { aiStoreList: { $in: requestData.storeId } } ] },
         // { $or: [ { store_id: { $in: requestData.storeId } }, { store_id: { $eq: '' }, userEmail: { $in: requestData.userEmailes } } ] },
     );
-    if ( requestData.clientId == '11' ) {
-      findAndQuery.push(
-          // { $or: [ { store_id: { $in: requestData.storeId } }, { store_id: { $eq: '' }, userEmail: { $in: requestData.userEmailes } } ] },
-          { $or: [ { store_id: { $in: requestData.storeId } }, { store_id: { $eq: '' }, userEmail: { $in: requestData.userEmailes } }, { aiStoreList: { $in: requestData.storeId } } ] },
-      );
-    } else {
-      findAndQuery.push(
-          { $or: [ { store_id: { $in: requestData.storeId } }, { store_id: { $eq: '' }, userEmail: { $in: requestData.userEmailes } }, { aiStoreList: { $in: requestData.storeId } } ] },
-      );
-    }
+    // if ( requestData.clientId == '11' ) {
+    //   findAndQuery.push(
+    //       // { $or: [ { store_id: { $in: requestData.storeId } }, { store_id: { $eq: '' }, userEmail: { $in: requestData.userEmailes } } ] },
+    //       { $or: [ { store_id: { $in: requestData.storeId } }, { store_id: { $eq: '' }, userEmail: { $in: requestData.userEmailes } }, { aiStoreList: { $in: requestData.storeId } } ] },
+    //   );
+    // } else {
+    // findAndQuery.push(
+    //     { $or: [ { store_id: { $in: requestData.storeId } }, { store_id: { $eq: '' }, userEmail: { $in: requestData.userEmailes } }, { aiStoreList: { $in: requestData.storeId } } ] },
+    // );
+    // }
 
     if ( requestData?.filter === 'all' ) {
       findAndQuery.push( { $or: [ { checkListType: { $in: [ 'custom', 'customerunattended', 'mobileusagedetection', 'staffleftinthemiddle', 'storeopenandclose', 'uniformdetection', 'cleaning', 'scrum', 'outsidebusinesshoursqueuetracking', 'halfshutter', 'tvcompliance', 'cameratampering', 'queuealert', 'staffgrouping', 'boxalert', 'employeeCount', 'storehygienemonitoring', 'unattendeddetection', 'vehicle_check_in', 'employeemonitoring', 'activitymonitoring' ] } } ] } );
@@ -2137,7 +2127,7 @@ export const flagTablesV2 = async ( req, res ) => {
       findAndQuery.push( { checkListType: 'custom' } );
       findAndQuery.push( { timeFlag: { $gte: 1 } } );
     } else if ( requestData?.filter === 'detection' ) {
-      findAndQuery.push( { checkListType: { $in: [ 'customerunattended', 'mobileusagedetection', 'staffleftinthemiddle', 'storeopenandclose', 'uniformdetection', 'cleaning', 'scrum', 'outsidebusinesshoursqueuetracking', 'halfshutter', 'tvcompliance', 'cameratampering', 'queuealert', 'staffgrouping', 'boxalert', 'employeeCount', 'storehygienemonitoring', 'unattendeddetection', 'vehicle_check_in', 'employeemonitoring', 'activitymonitoring' ] } } );
+      findAndQuery.push( { checkListType: { $ne: 'custom' } } );
     } else if ( requestData?.filter === 'runAI' ) {
       if ( req.body.runAIChecklistName ) {
         findAndQuery.push( { checkListName: { $in: req.body.runAIChecklistName } } );
@@ -2280,10 +2270,10 @@ export const flagTablesV2 = async ( req, res ) => {
       },
     } );
 
-    let getTotalCount = await processedchecklistService.aggregate( findQuery );
-    if ( !getTotalCount.length ) {
-      return res.sendError( { error: 'No Data Found' }, 204 );
-    }
+    // let getTotalCount = await processedchecklistService.aggregate( findQuery );
+    // if ( !getTotalCount.length ) {
+    //   return res.sendError( { error: 'No Data Found' }, 204 );
+    // }
 
     if ( requestData.sortColumnName && requestData.sortColumnName != '' && requestData.sortBy && requestData.sortBy !='' ) {
       findQuery.push( { $sort: { [requestData.sortColumnName]: requestData.sortBy } } );
@@ -2291,28 +2281,48 @@ export const flagTablesV2 = async ( req, res ) => {
       findQuery.push( { $sort: { ['submittedChecklist']: -1 } } );
     }
 
-    if ( !requestData.export ) {
-      let limit = parseInt( requestData?.limit ) || 10;
-      let skip = limit * ( requestData?.offset ) || 0;
-      findQuery.push( { $skip: skip }, { $limit: limit } );
-    }
+    findQuery.push( {
+      $facet: {
+        total: [
+          { $count: 'count' },
+        ],
 
+        data: [
+          { $skip: skip }, { $limit: limit },
+        ],
+      },
+    } );
 
-    let getChecklistPerformanceData = await processedchecklistService.aggregate( findQuery );
+    // The detection Lambda only needs request params (not the aggregation result),
+    // so fire it concurrently with the Mongo aggregation instead of after it.
+    // 'question'/'time' filters are custom-only, so the Lambda is never needed there.
+    const mayNeedLambda = ![ 'question', 'time' ].includes( requestData?.filter );
+    const detectionPayload = {
+      'fromDate': requestData.fromDate,
+      'toDate': requestData.toDate,
+      'storeId': requestData.storeId,
+      'clientId': requestData.clientId,
+    };
+    // const LamdaURL = 'https://f65azvtljclaxp6l7rnx65cdmm0lcgvp.lambda-url.ap-south-1.on.aws/';
 
+    let LamdaURL = lamdaUrl.flagTablesV2;
+
+    let [ getChecklistPerformanceData, lambdaResultData ] = await Promise.all( [
+      processedchecklistService.aggregate( findQuery ),
+      mayNeedLambda ? LamdaServiceCall( LamdaURL, detectionPayload ) : Promise.resolve( null ),
+    ] );
+
+    if ( !getChecklistPerformanceData?.[0]?.total?.[0]?.count ) {
+      return res.sendError( 'No data found', 204 );
+    }
+
+    let getTotalCount = getChecklistPerformanceData?.[0]?.total?.[0]?.count;
+    getChecklistPerformanceData = getChecklistPerformanceData?.[0]?.data;
     if ( getChecklistPerformanceData.length ) {
       const detectionChecklists = getChecklistPerformanceData?.filter( ( val ) => val?.checkListType !== 'custom' );
 
       if ( detectionChecklists?.length || [ 'runAI', 'all' ].includes( requestData?.filter ) ) {
-        const detectionPayload = {
-          'fromDate': requestData.fromDate,
-          'toDate': requestData.toDate,
-          'storeId': requestData.storeId,
-          'clientId': requestData.clientId,
-        };
-
-        let LamdaURL = lamdaUrl.flagTablesV2;
-        let resultData = await LamdaServiceCall( LamdaURL, detectionPayload );
+        let resultData = lambdaResultData;
         if ( resultData ) {
           if ( resultData.status_code == '200' ) {
             for ( let index = 0; index < getChecklistPerformanceData.length; index++ ) {
@@ -2414,7 +2424,7 @@ export const flagTablesV2 = async ( req, res ) => {
       return await download( exportdata, res );
     }
 
-    result.totalCount = getTotalCount.length;
+    result.totalCount = getTotalCount;
     result.checklistPerformance = getChecklistPerformanceData;
     return res.sendSuccess( result );
   } catch ( error ) {

package/src/controllers/trax.controller.js

@@ -12,6 +12,7 @@ import * as processedchecklistConfig from '../services/processedchecklistconfig.
 import * as processedchecklist from '../services/processedchecklist.services.js';
 // import * as checklistLogs from '../services/checklistlog.service.js';
 import * as tagService from '../services/tagging.service.js';
+import * as cameraService from '../services/camera.service.js';
 import * as alertsServices from '../services/clientRequest.service.js';
 import * as traxApprover from '../services/approver.service.js';
 const ObjectId = mongoose.Types.ObjectId;
@@ -651,11 +652,50 @@ export const zoneList = async ( req, res ) => {
       ];
       let zoneList = await tagService.aggregate( query );
 
-      if ( !zoneList.length ) {
+
+      let cameraQuery = [
+        {
+          $match: {
+            'clientId': inputBody.clientId,
+            'taggedChecklist.checkListName': inputBody.checkListName,
+          },
+        },
+        // taggedChecklist is an array of objects → unwind to one element per doc
+        { $unwind: '$taggedChecklist' },
+        // keep only the elements matching the requested checklist
+        {
+          $match: {
+            'taggedChecklist.checkListName': inputBody.checkListName,
+          },
+        },
+        {
+          $project: {
+            _id: 0,
+            zone: '$taggedChecklist.checkListName', // expose checkListName under the same `zone` key
+          },
+        },
+        {
+          $group: {
+            _id: '',
+            zone: { $addToSet: '$zone' },
+          },
+        },
+        {
+          $project: {
+            _id: 0,
+            zone: 1,
+          },
+        },
+      ];
+      let cameraList = await cameraService.aggregate( cameraQuery );
+
+      let mergedData = [ ...zoneList, ...cameraList ];
+
+      if ( !mergedData.length ) {
         return res.sendError( 'no data found', 204 );
       }
 
-      return res.sendSuccess( zoneList );
+      return res.sendSuccess( mergedData );
     } else if ( inputBody.checkListName && allowedChecklistsStreams.includes( inputBody.checkListName ) ) {
       return res.sendSuccess( [ { zone: 'Camera Angle Change Compliance' } ] );
     } else {
@@ -686,7 +726,7 @@ export const zoneList = async ( req, res ) => {
   }
 };
 
-async function createUser( data ) {
+export async function createUser( data ) {
   try {
     let params = {
       userName: data.userName,

package/src/controllers/traxDashboard.controllers.js

@@ -428,11 +428,16 @@ export const checklistPerformance = async ( req, res ) => {
               $cond: [
                 { $gt: [ '$$divisor', 0 ] },
                 {
-                  $round: [
+                  $max: [
                     {
-                      $multiply: [
-                        { $divide: [ '$userComplianceCountTotal', '$$divisor' ] },
-                        100,
+                      $round: [
+                        {
+                          $multiply: [
+                            { $divide: [ '$userComplianceCountTotal', '$$divisor' ] },
+                            100,
+                          ],
+                        },
+                        0,
                       ],
                     },
                     0,