tango-app-api-trax 3.9.54 → 3.9.55

package/package.json

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

package/src/controllers/mobileTrax.controller.js

@@ -2141,6 +2141,7 @@ export async function sopMobilechecklistMultiSectionFormatterv2( req, res, next
 
     if ( requestData.submittype == 'submit' ) {
       requestData.userComplianceCount = 0;
+      requestData.complianceCount = 0;
       for ( let section of sectionFormat ) {
         for ( let question of section.questions ) {
           let mustValidate = !question.linkType || ( question.linkType && question.linkquestionenabled );
@@ -2148,17 +2149,27 @@ export async function sopMobilechecklistMultiSectionFormatterv2( req, res, next
             return res.sendError( 'Please Fill All Fields', 400 );
           }
           if ( question.compliance ) {
+            // score = user's achieved value; max = best possible for the question
+            // (same max formula as config-time complianceCount in trax.controller).
             const scores = ( question.userAnswer || [] ).map( ( ua ) => ua?.complianceScore ?? 0 );
             let score = scores.length ? Math.max( ...scores ) : 0;
-            // Single-choice questions answered 'NA' / 'N/A' (case-insensitive) score 0,
-            // matching the visit-checklist PDF and dashboard compliance calculation.
+
+            const answerScores = ( question.answers || [] ).map( ( o ) => o?.complianceScore ?? Math.max( o?.matchedCount ?? 0, o?.notMatchedCount ?? 0 ) );
+            let max = answerScores.length ? Math.max( ...answerScores ) : 0;
+
+            // Single-choice questions answered 'NA' / 'N/A' (case-insensitive) are
+            // excluded from compliance entirely (score AND max = 0), matching the
+            // visit-checklist PDF and dashboard compliance calculation.
             if ( question.answerType === 'multiplechoicesingle' ) {
               const naAnswer = ( question.userAnswer?.[0]?.answer || '' ).toString().trim().toLowerCase();
               if ( naAnswer === 'na' || naAnswer === 'n/a' ) {
                 score = 0;
+                max = 0;
               }
             }
+
             requestData.userComplianceCount += score;
+            requestData.complianceCount += max;
           }
         }
       }
@@ -2804,6 +2815,8 @@ export async function submitChecklist( req, res ) {
         updateData.updatedAt = dayjs.utc( currentDateTime.format( 'hh:mm:ss A, DD MMM YYYY' ), 'hh:mm:ss A, DD MMM YYYY' ).format();
         updateData.submitMobileTime = requestData?.currentTime;
         updateData.userComplianceCount = requestData?.userComplianceCount;
+        // NA-aware max (denominator) recomputed at submit, alongside the score above.
+        updateData.complianceCount = requestData?.complianceCount;
         updateData.userSignature = requestData?.userSignature;
         if ( requestData?.userImage ) {
           let splitImgUrl = requestData?.userImage.split( '/' );

package/src/controllers/traxDashboard.controllers.js

@@ -297,15 +297,21 @@ export const checklistPerformance = async ( req, res ) => {
 
     findQuery.push( { $match: { $and: findAndQuery } } );
 
+    // Same search expressed as a plain find condition, so the parallel compliance
+    // query (below) stays scoped to the same checklists without depending on the
+    // aggregation's result.
+    let complianceSearch = null;
     if ( requestData.searchValue && requestData.searchValue != '' ) {
       let checkListSearch = requestData.searchValue.split( ',' ).map( ( item ) => item.trim().toLowerCase() );
       let query;
       if ( checkListSearch.length > 1 ) {
         findQuery.push( { $addFields: { cheklistlowercase: { $toLower: '$checkListName' } } } );
         query = { cheklistlowercase: { $in: checkListSearch } };
+        complianceSearch = { $expr: { $in: [ { $toLower: '$checkListName' }, checkListSearch ] } };
       } else {
         const safeSearch = escapeRegex( req.body?.searchValue );
         query = { checkListName: { $regex: safeSearch, $options: 'i' } };
+        complianceSearch = { checkListName: { $regex: safeSearch, $options: 'i' } };
       }
       findQuery.push( { $match: { $or: [ query ] } } );
     }
@@ -326,83 +332,6 @@ export const checklistPerformance = async ( req, res ) => {
     //   },
     // } );
 
-    // Recompute compliance per submission straight from questionAnswers so the
-    // dashboard % matches the visit-checklist PDF: a 'multiplechoicesingle'
-    // question answered 'NA'/'N/A' (case-insensitive) is excluded from BOTH the
-    // score (numerator) and the max (denominator). Non-compliance questions and
-    // non-NA questions keep the existing max/score formula.
-    findQuery.push( {
-      $addFields: {
-        naAwareCompliance: {
-          $reduce: {
-            input: { $ifNull: [ '$questionAnswers', [] ] },
-            initialValue: { score: 0, max: 0 },
-            in: {
-              $reduce: {
-                input: { $ifNull: [ '$$this.questions', [] ] },
-                initialValue: '$$value',
-                in: {
-                  $let: {
-                    vars: {
-                      // Count this question's score/max unless it is a single-choice
-                      // question answered NA/N/A, or a non-compliance question.
-                      countIt: {
-                        $and: [
-                          { $toBool: { $ifNull: [ '$$this.compliance', false ] } },
-                          { $not: [ {
-                            $and: [
-                              { $eq: [ '$$this.answerType', 'multiplechoicesingle' ] },
-                              { $in: [
-                                { $toLower: { $trim: { input: { $convert: {
-                                  input: { $arrayElemAt: [ { $ifNull: [ '$$this.userAnswer.answer', [] ] }, 0 ] },
-                                  to: 'string', onError: '', onNull: '',
-                                } } } } },
-                                [ 'na', 'n/a' ],
-                              ] },
-                            ],
-                          } ] },
-                        ],
-                      },
-                    },
-                    in: {
-                      score: {
-                        $add: [
-                          '$$value.score',
-                          { $cond: [
-                            '$$countIt',
-                            { $ifNull: [ { $max: { $map: {
-                              input: { $ifNull: [ '$$this.userAnswer', [] ] },
-                              as: 'u',
-                              in: { $ifNull: [ '$$u.complianceScore', 0 ] },
-                            } } }, 0 ] },
-                            0,
-                          ] },
-                        ],
-                      },
-                      max: {
-                        $add: [
-                          '$$value.max',
-                          { $cond: [
-                            '$$countIt',
-                            { $ifNull: [ { $max: { $map: {
-                              input: { $ifNull: [ '$$this.answers', [] ] },
-                              as: 'o',
-                              in: { $ifNull: [ '$$o.complianceScore', { $max: [ { $ifNull: [ '$$o.matchedCount', 0 ] }, { $ifNull: [ '$$o.notMatchedCount', 0 ] } ] } ] },
-                            } } }, 0 ] },
-                            0,
-                          ] },
-                        ],
-                      },
-                    },
-                  },
-                },
-              },
-            },
-          },
-        },
-      },
-    } );
-
     findQuery.push( {
       $group: {
         _id: '$sourceCheckList_id',
@@ -421,24 +350,6 @@ export const checklistPerformance = async ( req, res ) => {
         timeFlag: { $sum: '$timeFlag' },
         questionFlagCount: { $sum: '$questionFlag' },
         runAIFlagCount: { $sum: '$runAIFlag' },
-        userComplianceScoreTotal: {
-          $sum: {
-            $cond: [
-              { $eq: [ '$checklistStatus', 'submit' ] },
-              { $ifNull: [ '$naAwareCompliance.score', 0 ] },
-              0,
-            ],
-          },
-        },
-        complianceMaxTotal: {
-          $sum: {
-            $cond: [
-              { $eq: [ '$checklistStatus', 'submit' ] },
-              { $ifNull: [ '$naAwareCompliance.max', 0 ] },
-              0,
-            ],
-          },
-        },
         checkListType: { $last: '$checkListType' },
         redo: { $sum: { $cond: [ { $eq: [ '$redoStatus', true ] }, 1, 0 ] } },
         task: {
@@ -498,71 +409,104 @@ export const checklistPerformance = async ( req, res ) => {
         checkListType: 1,
         redo: 1,
         task: 1,
-        questionCompliance: {
-          $cond: [
-            { $gt: [ '$complianceMaxTotal', 0 ] },
-            {
-              $max: [
-                0,
-                {
-                  $round: [
-                    {
-                      $multiply: [
-                        { $divide: [ '$userComplianceScoreTotal', '$complianceMaxTotal' ] },
-                        100,
-                      ],
-                    },
-                    0,
-                  ],
-                },
-              ],
-            },
-            0,
-          ],
-        },
       },
     } );
 
-    if ( requestData.sortColumnName && requestData.sortColumnName != '' && requestData.sortBy && requestData.sortBy !='' ) {
-      findQuery.push( { $sort: { [requestData.sortColumnName]: requestData.sortBy } } );
-    } else {
-      findQuery.push( { $sort: { ['submittedChecklist']: -1 } } );
-    }
+    // Compliance % is computed in JS (not in the pipeline). The grouped aggregation
+    // and the compliance fetch are independent (the compliance query is scoped by the
+    // same base filter + search, NOT by the aggregation's result), so we run them in
+    // parallel. We then reduce the compliance docs per checklist in JS (NA-aware,
+    // matching the visit-checklist PDF) and sort + paginate in JS — because the table
+    // can sort by the compliance column, which no longer exists in the pipeline.
+    const complianceFilter = {
+      $and: [
+        ...findAndQuery,
+        { checklistStatus: 'submit' },
+        ...( complianceSearch ? [ complianceSearch ] : [] ),
+      ],
+    };
 
-    findQuery.push( {
-      $facet: {
-        data: [
-          { $skip: skip }, { $limit: limit },
-        ],
-        count: [
-          { $count: 'total' },
-        ],
-      },
-    } );
-    let getChecklistPerformanceData = await processedchecklistService.aggregate( findQuery );
-    if ( !getChecklistPerformanceData?.[0]?.data?.length ) {
+    const [ getChecklistPerformanceData, complianceDocs ] = await Promise.all( [
+      processedchecklistService.aggregate( findQuery ),
+      // Only the compliance-relevant subfields, so we transfer far less than the
+      // full questionAnswers blob.
+      processedchecklistService.find( complianceFilter, {
+        'sourceCheckList_id': 1,
+        'questionAnswers.questions.compliance': 1,
+        'questionAnswers.questions.answerType': 1,
+        'questionAnswers.questions.answers.complianceScore': 1,
+        'questionAnswers.questions.answers.matchedCount': 1,
+        'questionAnswers.questions.answers.notMatchedCount': 1,
+        'questionAnswers.questions.userAnswer.complianceScore': 1,
+        'questionAnswers.questions.userAnswer.answer': 1,
+      } ).lean(),
+    ] );
+
+    if ( !getChecklistPerformanceData.length ) {
       return res.sendError( 'no data found', 204 );
     }
 
+    // Sum NA-aware { score, max } per checklist.
+    const complianceByChecklist = {};
+    for ( const doc of complianceDocs ) {
+      const id = doc.sourceCheckList_id?.toString();
+      if ( !id ) continue;
+      if ( !complianceByChecklist[id] ) complianceByChecklist[id] = { score: 0, max: 0 };
+
+      for ( const section of ( doc.questionAnswers || [] ) ) {
+        for ( const q of ( section.questions || [] ) ) {
+          if ( !q?.compliance ) continue;
+
+          // Single-choice answered NA/N/A (case-insensitive) is excluded from both.
+          if ( q.answerType === 'multiplechoicesingle' ) {
+            const ans = ( q.userAnswer?.[0]?.answer || '' ).toString().trim().toLowerCase();
+            if ( ans === 'na' || ans === 'n/a' ) continue;
+          }
+
+          const max = Math.max( 0, ...( q.answers || [] ).map( ( o ) => o?.complianceScore ?? Math.max( o?.matchedCount ?? 0, o?.notMatchedCount ?? 0 ) ) );
+          const score = Math.max( 0, ...( q.userAnswer || [] ).map( ( o ) => o?.complianceScore ?? 0 ) );
+
+          complianceByChecklist[id].score += score;
+          complianceByChecklist[id].max += max;
+        }
+      }
+    }
+
+    getChecklistPerformanceData.forEach( ( row ) => {
+      const c = complianceByChecklist[row.sourceCheckList_id?.toString()] || { score: 0, max: 0 };
+      row.questionCompliance = c.max > 0 ? Math.max( 0, Math.round( ( c.score / c.max ) * 100 ) ) : 0;
+    } );
+
+    // Sort in JS (column may be the JS-computed questionCompliance), then paginate.
+    const sortColumn = ( requestData.sortColumnName && requestData.sortColumnName != '' ) ? requestData.sortColumnName : 'submittedChecklist';
+    const sortDir = Number( requestData.sortBy ) === 1 ? 1 : -1;
+    getChecklistPerformanceData.sort( ( a, b ) => {
+      const av = a[sortColumn];
+      const bv = b[sortColumn];
+      if ( typeof av === 'string' || typeof bv === 'string' ) {
+        return ( av ?? '' ).toString().localeCompare( ( bv ?? '' ).toString() ) * sortDir;
+      }
+      return ( ( av ?? 0 ) - ( bv ?? 0 ) ) * sortDir;
+    } );
+
+    const pageRows = getChecklistPerformanceData.slice( skip, skip + limit );
+
     if ( requestData.export ) {
-      const exportdata = [];
-      getChecklistPerformanceData[0].data.forEach( ( element ) => {
-        exportdata.push( {
-          'Checklist Name': element.checkListName || '--',
-          'Coverage': element.coverage || '--',
-          'Scheduled': element.scheduleRepeatedType || '--',
-          'Assigned To': element.storeCount || '--',
-          'Submitted': element.submittedChecklist || '--',
-          'Flags': element.flaggedChecklist || '--',
-          'Tasks': element.task || '--',
-          'ReDo': element.redo || '--',
-        } );
-      } );
+      const exportdata = pageRows.map( ( element ) => ( {
+        'Checklist Name': element.checkListName || '--',
+        'Coverage': element.coverage || '--',
+        'Scheduled': element.scheduleRepeatedType || '--',
+        'Assigned To': element.storeCount || '--',
+        'Submitted': element.submittedChecklist || '--',
+        'Flags': element.flaggedChecklist || '--',
+        'Tasks': element.task || '--',
+        'ReDo': element.redo || '--',
+      } ) );
       return await download( exportdata, res );
     }
 
-    result.totalCount = getChecklistPerformanceData[0].count[0].total;
-    result.checklistPerformance = getChecklistPerformanceData[0].data;
+    result.totalCount = getChecklistPerformanceData.length;
+    result.checklistPerformance = pageRows;
     return res.sendSuccess( result );
   } catch ( error ) {
     console.log( 'error =>', error );