tango-app-api-trax 3.9.57 → 3.9.59

package/package.json

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

package/src/controllers/mobileTrax.controller.js

@@ -2141,6 +2141,22 @@ export async function sopMobilechecklistMultiSectionFormatterv2( req, res, next
 
     if ( requestData.submittype == 'submit' ) {
       requestData.userComplianceCount = 0;
+
+      // Pull every "Matched/Not Matched" verdict out of a runAIData array, tolerating both shapes:
+      //   1) [ { answerImage, results: [ { featureName, value } ] } ]  (verdict nested under results)
+      //   2) [ { featureName, value } ]                                (flat verdict)
+      const extractMatchValues = ( runAIData ) => {
+        if ( !Array.isArray( runAIData ) ) return [];
+        const values = [];
+        runAIData.forEach( ( entry ) => {
+          const results = Array.isArray( entry?.results ) ? entry.results : [ entry ];
+          results.forEach( ( r ) => {
+            if ( r?.featureName === 'Matched/Not Matched' ) values.push( r?.value );
+          } );
+        } );
+        return values;
+      };
+
       for ( let section of sectionFormat ) {
         for ( let question of section.questions ) {
           let mustValidate = !question.linkType || ( question.linkType && question.linkquestionenabled );
@@ -2148,8 +2164,32 @@ export async function sopMobilechecklistMultiSectionFormatterv2( req, res, next
             return res.sendError( 'Please Fill All Fields', 400 );
           }
           if ( question.compliance ) {
-            const scores = ( question.userAnswer || [] ).map( ( ua ) => ua?.complianceScore ?? 0 );
-            let score = scores.length ? Math.max( ...scores ) : 0;
+            let score = 0;
+
+            // image / image/video: when runAI verdicts are already present on the userAnswer,
+            // derive compliance from them (every "Matched/Not Matched" must be True to count as
+            // matched, else not matched), mirroring countUpdateRunAI.
+            const aiAnswers = question.answerType === 'image/video' ?
+              ( question.userAnswer || [] ).filter( ( ua ) => ua?.answerType === 'image' ) :
+              ( question.userAnswer || [] );
+            const hasRunAIData = [ 'image', 'image/video' ].includes( question.answerType ) &&
+              aiAnswers.some( ( ua ) => Array.isArray( ua?.runAIData ) && ua.runAIData.length );
+
+            if ( hasRunAIData ) {
+              const matchValues = aiAnswers.flatMap( ( ua ) => extractMatchValues( ua?.runAIData ) );
+              const allMatched = matchValues.length > 0 && matchValues.every( ( v ) => v === 'True' || v === true );
+              score = allMatched ?
+                ( question.answers?.[0]?.matchedCount ?? 0 ) :
+                ( question.answers?.[0]?.notMatchedCount ?? 0 );
+              // Persist the derived score onto each userAnswer so PDF/dashboard reads stay consistent.
+              ( question.userAnswer || [] ).forEach( ( ua ) => {
+                ua.complianceScore = score;
+              } );
+            } else {
+              const scores = ( question.userAnswer || [] ).map( ( ua ) => ua?.complianceScore ?? 0 );
+              score = scores.length ? Math.max( ...scores ) : 0;
+            }
+
             // Single-choice questions answered 'NA' / 'N/A' (case-insensitive) contribute 0;
             // don't count the selected answer's compliance score for that question.
             if ( question.answerType === 'multiplechoicesingle' ) {

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,20 +2007,22 @@ 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;
@@ -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 ) {