tango-app-api-trax 3.8.23 → 3.8.25

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-trax",
-    "version": "3.8.23",
+    "version": "3.8.25",
     "description": "Trax",
     "main": "index.js",
     "type": "module",
@@ -29,7 +29,7 @@
         "nodemon": "^3.1.4",
         "path": "^0.12.7",
         "puppeteer": "^24.39.1",
-        "tango-api-schema": "^2.5.87",
+        "tango-api-schema": "^2.5.88",
         "tango-app-api-middleware": "^3.5.2",
         "url": "^0.11.4",
         "winston": "^3.13.1",

package/src/controllers/internalTrax.controller.js

@@ -2697,6 +2697,113 @@ export async function countUpdateRunAI( req, res ) {
   }
 }
 
+// Called by the runAI processing team once per (subject, checklist, section, qno, date) when their cron
+// detects a runAI flag. Idempotent per day via lastRunAIFlaggedDate — replaying the same date is a no-op.
+export async function incrementRunAIRecurring( req, res ) {
+  try {
+    let body = { ...( req.body || {} ) };
+    if ( !body.section_id ) return res.sendError( 'section_id is required', 400 );
+    if ( body.qno === undefined || body.qno === null || body.qno === '' ) return res.sendError( 'qno is required', 400 );
+    if ( !body.id ) return res.sendError( 'Id is required', 400 );
+    if ( !body.qname ) return res.sendError( 'Question name is required', 400 );
+    if ( !body.sectionName ) return res.sendError( 'Section name is required', 400 );
+
+    const checklistDetails = await processedchecklist.findOne( { _id: body.id } );
+    if ( !checklistDetails ) {
+      return res.sendError( 'Checklist not found', 204 );
+    }
+
+    // sectionName/qname live inside questionAnswers; surface them so the first-insert tracker doc is complete.
+    // const section = ( checklistDetails.questionAnswers || [] ).find( ( s ) => String( s?.section_id ) === String( body.section_id ) );
+    // const question = section?.questions?.find( ( q ) => String( q?.qno ) === String( body.qno ) );
+
+    body = {
+      ...body,
+      date: checklistDetails.date_string,
+      sourceCheckList_id: checklistDetails.sourceCheckList_id,
+      client_id: checklistDetails.client_id,
+      coverage: checklistDetails.coverage,
+      store_id: checklistDetails.store_id,
+      storeName: checklistDetails.storeName,
+      user_id: checklistDetails.userId,
+      userEmail: checklistDetails.userEmail,
+      userName: checklistDetails.userName,
+      checkListName: checklistDetails.checkListName,
+      // sectionName: section?.sectionName || '',
+      // qname: question?.qname || '',
+      lastSubmittedBy: checklistDetails.userName || checklistDetails.userEmail || '--',
+      lastSubmissionDate: checklistDetails.submitTime_string,
+    };
+
+    // Skip checklists that don't have recurring flag configured — same gate that recurringFlagAlert uses
+    // when picking which checklists to email for. Avoids creating tracker docs that would never be acted on.
+    const checklistConfig = await CLconfig.findOne( { _id: body.sourceCheckList_id }, { recurringFlag: 1, publish: 1 } );
+    if ( !checklistConfig ) {
+      return res.sendError( 'Checklist not found', 404 );
+    }
+    const hasRecurring = ( Array.isArray( checklistConfig?.recurringFlag?.users ) && checklistConfig.recurringFlag.users.length > 0 ) ||
+      ( Array.isArray( checklistConfig?.recurringFlag?.notifyType ) && checklistConfig.recurringFlag.notifyType.length > 0 );
+    if ( !hasRecurring ) {
+      return res.sendSuccess( { message: 'Recurring flag not configured for this checklist', noop: true } );
+    }
+
+    const isUserBased = ( body.coverage === 'user' ) || ( !body.store_id && ( body.user_id || body.userEmail ) );
+    const storeId = isUserBased ? '' : ( body.store_id || '' );
+    const userId = isUserBased ? ( body.user_id ? String( body.user_id ) : ( body.userEmail || '' ) ) : '';
+    if ( !isUserBased && !storeId ) return res.sendError( 'store_id is required for store-based', 400 );
+    if ( isUserBased && !userId ) return res.sendError( 'user_id or userEmail is required for user-based', 400 );
+
+    const date = body.date;
+    const filter = {
+      client_id: body.client_id,
+      sourceCheckList_id: body.sourceCheckList_id,
+      section_id: body.section_id,
+      qno: String( body.qno ),
+      ...( isUserBased ? { user_id: userId } : { store_id: storeId } ),
+    };
+
+    const existing = await recurringFlagTracker.findOne( filter, { lastRunAIFlaggedDate: 1 } );
+    if ( existing && existing.lastRunAIFlaggedDate === date ) {
+      return res.sendSuccess( { message: 'Already counted for this date', noop: true } );
+    }
+
+    const setOnInsert = {
+      coverage: isUserBased ? 'user' : 'store',
+      checkListName: body.checkListName || '',
+      sectionName: body.sectionName || '',
+      qname: body.qname || '',
+      storeName: isUserBased ? '' : ( body.storeName || '' ),
+      userName: body.userName || '',
+      userEmail: body.userEmail || '',
+    };
+
+    console.log( setOnInsert );
+
+    await recurringFlagTracker.bulkWrite( [
+      {
+        updateOne: {
+          filter,
+          update: {
+            $setOnInsert: setOnInsert,
+            $set: {
+              lastRunAIFlaggedDate: date,
+              ...( body.lastSubmittedBy ? { lastSubmittedBy: body.lastSubmittedBy } : {} ),
+              ...( body.lastSubmissionDate ? { lastSubmissionDate: body.lastSubmissionDate } : {} ),
+            },
+            $inc: { runAICount: 1 },
+          },
+          upsert: true,
+        },
+      },
+    ] );
+
+    return res.sendSuccess( { message: 'runAI recurring count updated' } );
+  } catch ( e ) {
+    logger.error( { functionName: 'incrementRunAIRecurring', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+
 export async function getRunAIQuestions( req, res ) {
   try {
     let requestData = req.body;
@@ -3747,7 +3854,6 @@ export async function checklistAutoMailList( req, res ) {
   }
 }
 
-
 export const downloadInsertPdfOld = async ( req, res ) => {
   try {
     setImmediate( async () => {
@@ -4225,17 +4331,18 @@ export async function getEyetestStream( req, res ) {
   }
 }
 
-function buildRecurringFlagExcel( rows ) {
+function buildRecurringFlagExcel( rows, subjectLabel = 'Store' ) {
   const workbook = new ExcelJS.Workbook();
   const sheet = workbook.addWorksheet( 'Recurring Flags' );
   sheet.columns = [
-    { header: 'Store Name', key: 'storeName', width: 25 },
+    { header: `${subjectLabel} Name`, key: 'storeName', width: 25 },
     { header: 'Checklist Name', key: 'checklistName', width: 30 },
     { header: 'Section', key: 'sectionName', width: 25 },
     { header: 'Question', key: 'questionName', width: 40 },
     { header: 'Last Submitted By', key: 'lastSubmittedBy', width: 25 },
     { header: 'Last Submission Date', key: 'lastSubmissionDate', width: 22 },
     { header: 'Recurring Days', key: 'days', width: 16 },
+    { header: 'Run AI Flags', key: 'runAICount', width: 14 },
   ];
   sheet.getRow( 1 ).font = { bold: true };
   rows.forEach( ( r ) => sheet.addRow( r ) );
@@ -4253,7 +4360,7 @@ export async function recurringFlagAlert( req, res ) {
         ],
       },
     }, { _id: 1, checkListName: 1, recurringFlag: 1, notifyFlags: 1, approver: 1, client_id: 1 } );
-
+    console.log( JSON.stringify( checklistDetails ) );
     if ( !checklistDetails.length ) {
       return res.sendSuccess( 'No checklists configured for recurring flag' );
     }
@@ -4266,7 +4373,6 @@ export async function recurringFlagAlert( req, res ) {
       const threshold = cl?.recurringFlag?.threshold || 3;
       const notifyType = cl?.recurringFlag?.notifyType || [];
       const users = cl?.recurringFlag?.users || [];
-
       let recipients = [];
       if ( notifyType.includes( 'sameAsNotify' ) ) {
         const nfType = cl?.notifyFlags?.notifyType || [];
@@ -4275,42 +4381,71 @@ export async function recurringFlagAlert( req, res ) {
           recipients = cl.approver.map( ( a ) => a?.value ).filter( Boolean );
         }
         recipients = [ ...recipients, ...nfUsers.map( ( u ) => u?.value ).filter( Boolean ) ];
-      } else {
-        if ( notifyType.includes( 'approver' ) && Array.isArray( cl.approver ) ) {
-          recipients = cl.approver.map( ( a ) => a?.value ).filter( Boolean );
-        }
-        recipients = [ ...recipients, ...users.map( ( u ) => u?.value ).filter( Boolean ) ];
       }
+      if ( notifyType.includes( 'approver' ) && Array.isArray( cl.approver ) ) {
+        recipients = [ ...recipients, ...cl.approver.map( ( a ) => a?.value ).filter( Boolean ) ];
+      }
+      recipients = [ ...recipients, ...users.map( ( u ) => u?.value ).filter( Boolean ) ];
       recipients = [ ...new Set( recipients ) ];
 
       if ( !recipients.length ) return;
 
-      // Read tracker rows that have hit threshold and have not yet been emailed for the current streak.
-      // Submit-time updates already maintained consecutiveCount + lastFlaggedDate per (store, section, qno).
+      // Read tracker rows where EITHER the sop streak or the runAI count has hit threshold and the
+      // current trigger hasn't been emailed yet (lastEmailDate vs the relevant flagged date).
       const trackerRows = await recurringFlagTracker.find( {
         sourceCheckList_id: cl._id,
-        consecutiveCount: { $gte: threshold },
-        $expr: { $ne: [ { $ifNull: [ '$lastEmailDate', '' ] }, { $ifNull: [ '$lastFlaggedDate', '' ] } ] },
+        $or: [
+          {
+            consecutiveCount: { $gte: threshold },
+            $expr: { $ne: [ { $ifNull: [ '$lastEmailDate', '' ] }, { $ifNull: [ '$lastFlaggedDate', '' ] } ] },
+          },
+          {
+            runAICount: { $gte: threshold },
+            $expr: { $ne: [ { $ifNull: [ '$lastEmailDate', '' ] }, { $ifNull: [ '$lastRunAIFlaggedDate', '' ] } ] },
+          },
+        ],
       } );
 
       for ( const t of trackerRows ) {
+        const isUserBased = t.coverage === 'user' || ( !t.store_id && ( t.user_id || t.userEmail ) );
+        // For user-based checklists, group/identify by userEmail; for store-based, by store_id.
+        const subjectId = isUserBased ? ( t.userEmail || t.user_id || '' ) : ( t.store_id || '' );
+        const subjectName = isUserBased ? ( t.userName || t.userEmail || '--' ) : ( t.storeName || '--' );
+        // Determine which streak crossed threshold for this row — drives reset granularity below.
+        const sopFired = ( t.consecutiveCount || 0 ) >= threshold && t.lastEmailDate !== t.lastFlaggedDate;
+        const runAIFired = ( t.runAICount || 0 ) >= threshold && t.lastEmailDate !== t.lastRunAIFlaggedDate;
         for ( const recipient of recipients ) {
           triggers.push( {
             recipient,
             clientId: t.client_id,
-            storeId: t.store_id,
-            storeName: t.storeName,
+            coverage: isUserBased ? 'user' : 'store',
+            subjectId,
+            subjectName,
+            storeId: t.store_id || '',
+            storeName: t.storeName || '',
+            userId: t.user_id || '',
+            userName: t.userName || '',
+            userEmail: t.userEmail || '',
             checklistId: cl._id.toString(),
             checklistName: cl.checkListName?.trim() || t.checkListName || '',
             sectionName: t.sectionName,
             qno: t.qno,
             qname: t.qname,
             days: t.consecutiveCount,
+            runAICount: t.runAICount || 0,
+            sopFired,
+            runAIFired,
             lastSubmittedBy: t.lastSubmittedBy || '--',
             lastSubmissionDate: t.lastSubmissionDate || t.lastFlaggedDate || '',
           } );
         }
-        trackerIdsToReset.push( { _id: t._id, lastFlaggedDate: t.lastFlaggedDate } );
+        trackerIdsToReset.push( {
+          _id: t._id,
+          lastFlaggedDate: t.lastFlaggedDate,
+          lastRunAIFlaggedDate: t.lastRunAIFlaggedDate,
+          sopFired,
+          runAIFired,
+        } );
       }
     } ) );
 
@@ -4318,6 +4453,7 @@ export async function recurringFlagAlert( req, res ) {
       return res.sendSuccess( 'No recurring flags reached threshold' );
     }
 
+
     // Group triggers by recipient.
     const byRecipient = new Map();
     for ( const t of triggers ) {
@@ -4332,21 +4468,74 @@ export async function recurringFlagAlert( req, res ) {
     const sentSummary = [];
 
     await Promise.all( [ ...byRecipient.entries() ].map( async ( [ recipient, items ] ) => {
-      const stores = new Set( items.map( ( i ) => i.storeId ) );
+      const subjects = new Set( items.map( ( i ) => i.subjectId ) );
       const checklists = new Set( items.map( ( i ) => i.checklistId ) );
-      const isMultiStore = stores.size > 1;
+      console.log( checklists );
+      const isMultiStore = subjects.size > 1; // "isMultiStore" name retained for template back-compat
       const isMultiChecklist = !isMultiStore && checklists.size > 1;
-      // Threshold for the message line — when grouping spans multiple checklists/stores, take min threshold seen.
+      // Threshold for the message line — when grouping spans multiple checklists/subjects, take min threshold seen.
       const thresholdShown = items.reduce( ( acc, it ) => Math.min( acc, it.days ), items[0].days );
 
-      const rows = items.map( ( i ) => ( {
-        storeName: i.storeName,
+      // If every trigger for this recipient is user-based, label as User. Mixed sets fall back to Store.
+      const coverages = new Set( items.map( ( i ) => i.coverage ) );
+      const isAllUser = coverages.size === 1 && coverages.has( 'user' );
+      const subjectLabel = isAllUser ? 'User' : 'Store';
+      const subjectLabelPlural = isAllUser ? 'Users' : 'Stores';
+      const subjectLabelLower = isAllUser ? 'user' : 'store';
+      const subjectLabelPluralLower = isAllUser ? 'users' : 'stores';
+
+      // Aggregate triggers per (subject, checklist) — each table row counts how many distinct questions
+      // hit the recurring threshold for that pair. The streak length on each question is no longer surfaced
+      // in the email body; it remains in the per-question Excel breakdown below.
+      const parseSubmissionDate = ( s ) => {
+        if ( !s ) return 0;
+        const d = dayjs( s, 'hh:mm A, DD MMM YYYY' );
+        return d.isValid() ? d.valueOf() : 0;
+      };
+      const groupMap = new Map();
+      for ( const i of items ) {
+        const k = `${i.subjectId}::${i.checklistId}`;
+        if ( !groupMap.has( k ) ) {
+          groupMap.set( k, {
+            subjectId: i.subjectId,
+            subjectName: i.subjectName,
+            checklistId: i.checklistId,
+            checklistName: i.checklistName,
+            questionCount: 0,
+            runAICount: 0,
+            lastSubmittedBy: i.lastSubmittedBy,
+            lastSubmissionDate: i.lastSubmissionDate,
+          } );
+        }
+        const g = groupMap.get( k );
+        g.questionCount += 1;
+        g.runAICount += ( i.runAICount || 0 );
+        if ( parseSubmissionDate( i.lastSubmissionDate ) > parseSubmissionDate( g.lastSubmissionDate ) ) {
+          g.lastSubmissionDate = i.lastSubmissionDate;
+          g.lastSubmittedBy = i.lastSubmittedBy;
+        }
+      }
+      const rows = [ ...groupMap.values() ].map( ( g ) => ( {
+        subjectName: g.subjectName,
+        storeName: g.subjectName, // legacy field name still consumed by template fallbacks
+        checklistName: g.checklistName,
+        lastSubmittedBy: g.lastSubmittedBy,
+        lastSubmissionDate: g.lastSubmissionDate,
+        days: g.questionCount, // template column "Total Recurring Flags" reads `days`
+        flagCount: g.questionCount,
+        runAICount: g.runAICount,
+      } ) );
+
+      // Excel attachment keeps per-question detail (one row per flagged question).
+      const excelRows = items.map( ( i ) => ( {
+        storeName: i.subjectName,
         checklistName: i.checklistName,
         sectionName: i.sectionName,
         questionName: i.qname,
         lastSubmittedBy: i.lastSubmittedBy,
         lastSubmissionDate: i.lastSubmissionDate,
         days: i.days,
+        runAICount: i.runAICount || 0,
       } ) );
 
       const ATTACHMENT_THRESHOLD = 10;
@@ -4361,27 +4550,34 @@ export async function recurringFlagAlert( req, res ) {
         hasAttachment,
         domain: flagDomain,
         rows: displayRows,
+        subjectLabel,
+        subjectLabelPlural,
+        subjectLabelLower,
+        subjectLabelPluralLower,
       };
 
       if ( isMultiStore ) {
         data.highlights = {
-          totalStores: stores.size,
+          totalSubjects: subjects.size,
+          totalStores: subjects.size, // legacy alias
           totalChecklists: checklists.size,
           totalFlags: items.length,
         };
       } else if ( isMultiChecklist ) {
-        data.storeName = items[0].storeName;
+        data.subjectName = items[0].subjectName;
+        data.storeName = items[0].subjectName;
       } else {
-        const single = items[0];
-        data.storeName = single.storeName;
+        // Single mode: one (subject, checklist) — flagCount is the number of questions that hit threshold.
+        const single = rows[0];
+        data.subjectName = single.subjectName;
+        data.storeName = single.subjectName;
         data.checklistName = single.checklistName;
-        data.questionName = single.qname;
         data.lastSubmittedBy = single.lastSubmittedBy;
         data.lastSubmissionDate = single.lastSubmissionDate;
-        data.days = single.days;
-        data.daysPlural = single.days > 1;
-        data.flagCount = 1;
-        data.flagCountPlural = false;
+        data.flagCount = single.flagCount;
+        data.flagCountPlural = single.flagCount > 1;
+        data.runAICount = single.runAICount;
+        data.runAICountPlural = single.runAICount > 1;
       }
 
       const html = compiled( { data } );
@@ -4396,7 +4592,7 @@ export async function recurringFlagAlert( req, res ) {
 
       if ( hasAttachment ) {
         try {
-          const buf = await buildRecurringFlagExcel( rows );
+          const buf = await buildRecurringFlagExcel( excelRows, subjectLabel );
           params.attachment = {
             filename: 'Recurring-Flags-Summary.xlsx',
             content: Buffer.from( buf ),
@@ -4406,22 +4602,32 @@ export async function recurringFlagAlert( req, res ) {
           logger.error( { functionName: 'recurringFlagAlert.buildExcel', error: e } );
         }
       }
-
+      console.log( params.toEmail );
       sendEmailWithSES( params.toEmail, params.mailSubject, params.htmlBody, params.attachment, params.sourceEmail );
       sentSummary.push( { recipient, count: items.length, mode: isMultiStore ? 'multi-store' : ( isMultiChecklist ? 'multi-checklist' : 'single' ) } );
     } ) );
 
-    // Reset counters, stamp lastEmailDate, and append the fire date to emailHistory (capped at last 60).
+    // Reset only the streak(s) that crossed threshold. Stamp lastEmailDate to the most recent triggering
+    // flag date so dedup remains correct. Append that date to emailHistory (rolling last 60).
     if ( trackerIdsToReset.length ) {
-      const resetOps = trackerIdsToReset.map( ( { _id, lastFlaggedDate } ) => ( {
-        updateOne: {
-          filter: { _id },
-          update: {
-            $set: { consecutiveCount: 0, lastEmailDate: lastFlaggedDate },
-            $push: { emailHistory: { $each: [ lastFlaggedDate ], $slice: -60 } },
+      const resetOps = trackerIdsToReset.map( ( r ) => {
+        const set = {};
+        if ( r.sopFired ) set.consecutiveCount = 0;
+        if ( r.runAIFired ) set.runAICount = 0;
+        const stampDate = r.runAIFired ?
+          ( r.lastRunAIFlaggedDate || r.lastFlaggedDate || '' ) :
+          ( r.lastFlaggedDate || r.lastRunAIFlaggedDate || '' );
+        set.lastEmailDate = stampDate;
+        return {
+          updateOne: {
+            filter: { _id: r._id },
+            update: {
+              $set: set,
+              $push: { emailHistory: { $each: [ stampDate ], $slice: -60 } },
+            },
           },
-        },
-      } ) );
+        };
+      } );
       await recurringFlagTracker.bulkWrite( resetOps );
     }
 
@@ -4566,7 +4772,7 @@ export async function weeklyWrapAlert( req, res ) {
     const endDateLabel = dayjs( range.weekEnd ).format( 'DD/MM/YY' );
 
     // TEMP: static recipient for dev. Replace with client-config lookup later.
-    const STATIC_RECIPIENT = 'sh9628hs@gmail.com';
+    const STATIC_RECIPIENT = 'gopisjkg@gmail.com';
 
     // Aggregate flag data for both weeks across all stores in one shot.
     const [ flagsThis, flagsPrev, recurThis, recurPrev ] = await Promise.all( [
@@ -4774,3 +4980,4 @@ export async function updateStoreLatLong( req, res ) {
     return res.sendError( e, 500 );
   }
 }
+

package/src/controllers/mobileTrax.controller.js

@@ -1438,7 +1438,7 @@ export async function sopMobilechecklistMultiSectionFormatterv1( req, res, next
                 let des = [];
                 if ( requestSection[i].answer != 'null' && requestSection[i].answer != '' && requestSection[i].answer != null ) {
                   let validationAnswer = '';
-                  if ( requestSection[i].answer.split( '?' ).length > 1 ) {
+                  if ( requestSection[i].answer.split( '?' ).length > 1 || requestSection[i].answer.includes( 'https://' ) ) {
                     validationAnswer = decodeURIComponent( requestSection[i].answer.split( '?' )[0] );
                   }
                   if ( validationAnswer.length ) {
@@ -1932,7 +1932,7 @@ export async function sopMobileTaskMultiSectionFormatter( req, res, next ) {
                 let des = [];
                 if ( requestSection[i].answer != 'null' && requestSection[i].answer != '' && requestSection[i].answer != null ) {
                   let validationAnswer = '';
-                  if ( requestSection[i].answer.split( '?' ).length > 1 ) {
+                  if ( requestSection[i].answer.split( '?' ).length > 1 || requestSection[i].answer.includes( 'https://' ) ) {
                     validationAnswer = decodeURIComponent( requestSection[i].answer.split( '?' )[0] );
                   }
                   if ( validationAnswer.length ) {
@@ -2031,7 +2031,13 @@ function QuestionFlag( req, res ) {
 
 async function updateRecurringFlagTracker( processedChecklist, questionAnswers, currentDateTime ) {
   try {
-    if ( !processedChecklist?.store_id || !processedChecklist?.sourceCheckList_id ) return;
+    if ( !processedChecklist?.sourceCheckList_id ) return;
+
+    const isUserBased = processedChecklist?.coverage === 'user';
+    const storeId = isUserBased ? '' : ( processedChecklist?.store_id || '' );
+    const userId = isUserBased ? ( processedChecklist?.userId ? String( processedChecklist.userId ) : ( processedChecklist?.userEmail || '' ) ) : '';
+    if ( !isUserBased && !storeId ) return;
+    if ( isUserBased && !userId ) return;
 
     const today = currentDateTime ? currentDateTime.format( 'YYYY-MM-DD' ) : dayjs().format( 'YYYY-MM-DD' );
     const yesterday = dayjs( today, 'YYYY-MM-DD' ).subtract( 1, 'day' ).format( 'YYYY-MM-DD' );
@@ -2039,7 +2045,7 @@ async function updateRecurringFlagTracker( processedChecklist, questionAnswers,
     const trackerKeyBase = {
       client_id: processedChecklist.client_id,
       sourceCheckList_id: processedChecklist.sourceCheckList_id,
-      store_id: processedChecklist.store_id,
+      ...( isUserBased ) ? { user_id: userId } : { store_id: storeId },
     };
 
     const existingRows = await recurringFlagTracker.find( trackerKeyBase, { section_id: 1, qno: 1, consecutiveCount: 1, lastFlaggedDate: 1 } );
@@ -2059,7 +2065,7 @@ async function updateRecurringFlagTracker( processedChecklist, questionAnswers,
         const flaggedNow = Array.isArray( question?.userAnswer ) && question.userAnswer.some( ( a ) => a?.sopFlag === true );
         const key = `${sectionId}::${qno}`;
         const existing = existingMap.get( key );
-
+        console.log( flaggedNow, 'test' );
         if ( flaggedNow ) {
           let newCount;
           if ( !existing ) {
@@ -2079,8 +2085,11 @@ async function updateRecurringFlagTracker( processedChecklist, questionAnswers,
               filter: { ...trackerKeyBase, section_id: sectionId, qno },
               update: {
                 $set: {
+                  coverage: isUserBased ? 'user' : 'store',
                   checkListName: processedChecklist.checkListName,
-                  storeName: processedChecklist.storeName,
+                  storeName: isUserBased ? '' : ( processedChecklist.storeName || '' ),
+                  userName: processedChecklist.userName || '',
+                  userEmail: processedChecklist.userEmail || '',
                   sectionName: section?.sectionName || '',
                   qname: question?.qname || '',
                   consecutiveCount: newCount,
@@ -2103,9 +2112,9 @@ async function updateRecurringFlagTracker( processedChecklist, questionAnswers,
         }
       } );
     } );
-
     if ( ops.length ) {
-      await recurringFlagTracker.bulkWrite( ops );
+      let data = await recurringFlagTracker.bulkWrite( ops );
+      console.log( data );
     }
   } catch ( error ) {
     logger.error( { function: 'updateRecurringFlagTracker', error } );
@@ -2247,6 +2256,7 @@ export async function submitChecklist( req, res ) {
         // };
         // await detectionService.create( detectionData );
         if ( requestData.submittype == 'submit' ) {
+          console.log( checklistDetails?.recurringFlag?.notifyType?.length );
           if ( checklistDetails?.recurringFlag?.notifyType?.length ) {
             updateRecurringFlagTracker( getchecklist[0], requestData.questionAnswers, currentDateTime );
           }

package/src/hbs/recurringFlag.hbs

@@ -68,11 +68,11 @@
                                 <span style="font-weight: 400;color: #121A26;line-height: 140%;">
                                     Hi,<br/>
                                     {{#if data.isMultiStore}}
-                                        Recurring flags has been detected across multiple stores and across multiple checklists on recent submissions, exceeding the configured threshold of {{data.threshold}} occurrences.
+                                        Recurring flags has been detected across multiple {{data.subjectLabelPluralLower}} and across multiple checklists on recent submissions, exceeding the configured threshold of {{data.threshold}} occurrences.
                                     {{else if data.isMultiChecklist}}
-                                        A Recurring flags has been identified for store <b>{{data.storeName}}</b> across multiple checklists on recent submissions, exceeding the configured threshold of {{data.threshold}} occurrences.
+                                        A Recurring flags has been identified for {{data.subjectLabelLower}} <b>{{data.subjectName}}</b> across multiple checklists on recent submissions, exceeding the configured threshold of {{data.threshold}} occurrences.
                                     {{else}}
-                                        A recurring flag has been identified for store <b>{{data.storeName}}</b>.where a question has been flagged multiple times in recent {{data.checklistName}} submissions, exceeding the configured threshold of {{data.threshold}} occurrences.
+                                        A recurring flag has been identified for {{data.subjectLabelLower}} <b>{{data.subjectName}}</b>.where a question has been flagged multiple times in recent {{data.checklistName}} submissions, exceeding the configured threshold of {{data.threshold}} occurrences.
                                     {{/if}}
                                 </span>
                             </div>
@@ -86,7 +86,7 @@
                             <div class="highlight">
                                 <b>Key Highlights:</b>
                                 <ul style="margin:8px 0 0 0;padding-left:18px;">
-                                    <li>Total Stores with Recurring Flags: {{data.highlights.totalStores}}</li>
+                                    <li>Total {{data.subjectLabelPlural}} with Recurring Flags: {{data.highlights.totalSubjects}}</li>
                                     <li>Total Checklists with Recurring Flags: {{data.highlights.totalChecklists}}</li>
                                     <li>Total Recurring Flags: {{data.highlights.totalFlags}}</li>
                                 </ul>
@@ -102,7 +102,7 @@
                                 {{#if data.isMultiStore}}
                                     Details of the Recurring Flags are as follows:
                                 {{else if data.isMultiChecklist}}
-                                    Details of the Recurring Flags from Store {{data.storeName}} (last {{data.threshold}} days):
+                                    Details of the Recurring Flags from {{data.subjectLabel}} {{data.subjectName}} are as follows:
                                 {{else}}
                                     Details of the Recurring Flags from checklist are as follows:
                                 {{/if}}
@@ -119,9 +119,9 @@
             <td align="center" bgcolor="#dbe5ea" style="padding:0 10px 0 10px">
                 <table align="center" bgcolor="#ffffff" border="0" cellpadding="0" cellspacing="0" width="100%" style="max-width: 680px;">
                     <tr bgcolor="#ffffff">
-                        <td class="flagText" style="padding-left:30px;line-height: 24px;color:#000000">Store Name :</td>
+                        <td class="flagText" style="padding-left:30px;line-height: 24px;color:#000000">{{data.subjectLabel}} Name :</td>
                         <td></td><td></td>
-                        <td class="flagText">{{data.storeName}}</td>
+                        <td class="flagText">{{data.subjectName}}</td>
                     </tr>
                     <tr bgcolor="#ffffff">
                         <td class="flagText" style="padding-left:30px;line-height: 24px;">Checklist Name :</td>
@@ -141,7 +141,12 @@
                     <tr bgcolor="#ffffff">
                         <td class="flagText" style="padding-left:30px;line-height: 24px;">No of Flags :</td>
                         <td></td><td></td>
-                        <td class="flagText">{{data.flagCount}} Question Flag{{#if data.flagCountPlural}}s{{/if}} - "{{data.questionName}}" has flagged for {{data.days}} day{{#if data.daysPlural}}s{{/if}} in a Row</td>
+                        <td class="flagText">{{data.flagCount}} Question Flag{{#if data.flagCountPlural}}s{{/if}}</td>
+                    </tr>
+                    <tr bgcolor="#ffffff">
+                        <td class="flagText" style="padding-left:30px;line-height: 24px;">Run AI Flags :</td>
+                        <td></td><td></td>
+                        <td class="flagText">{{data.runAICount}} Run AI Flag{{#if data.runAICountPlural}}s{{/if}}</td>
                     </tr>
                 </table>
             </td>
@@ -158,23 +163,23 @@
                             <table class="rfTable">
                                 <thead>
                                     <tr>
-                                        {{#if data.isMultiStore}}<th>Store Name</th>{{/if}}
+                                        {{#if data.isMultiStore}}<th>{{data.subjectLabel}} Name</th>{{/if}}
                                         <th>Checklist Name</th>
-                                        <th>Question</th>
                                         <th>Last Submitted By</th>
                                         <th>Last Submission Date</th>
                                         <th>Total Recurring Flags</th>
+                                        <th>Run AI Flags</th>
                                     </tr>
                                 </thead>
                                 <tbody>
                                     {{#each data.rows}}
                                     <tr>
-                                        {{#if ../data.isMultiStore}}<td>{{this.storeName}}</td>{{/if}}
+                                        {{#if ../data.isMultiStore}}<td>{{this.subjectName}}</td>{{/if}}
                                         <td>{{this.checklistName}}</td>
-                                        <td>{{this.questionName}}</td>
                                         <td>{{this.lastSubmittedBy}}</td>
                                         <td>{{this.lastSubmissionDate}}</td>
                                         <td>{{this.days}}</td>
+                                        <td>{{this.runAICount}}</td>
                                     </tr>
                                     {{/each}}
                                 </tbody>

package/src/hbs/template.hbs

@@ -197,9 +197,12 @@
             {{#each data.questionAnswers}}
             <div class="pdfcontent">
                 <div style="padding-bottom:20px;">
-                    <span class="sectionname">{{sectionName}} </span>&nbsp;<div class="horizondal-line">
-                        <hr />
-                    </div>
+                    <table style="width:100%;border-collapse:collapse;">
+                        <tr>
+                            <td class="sectionname" style="white-space:nowrap;padding-right:8px;width:1%;">{{sectionName}}</td>
+                            <td style="width:99%;"><hr class="horizondal-line" style="margin:0;border:none;border-top:1px solid #98A2B3;"/></td>
+                        </tr>
+                    </table>
                 </div>
                 {{#each questions}}
                 <div style="padding-bottom:20px">

package/src/routes/internalTraxApi.router.js

@@ -37,6 +37,7 @@ internalTraxRouter
     .post( '/getSubmissionDetails', isAllowedInternalAPIHandler, internalController.checklistTaskSubmissionDetails )
     .post( '/posblock', isAllowedInternalAPIHandler, internalController.getStoreTaskDetails )
     .post( '/runAIFlag', isAllowedInternalAPIHandler, internalController.runAIFlag )
+    .post( '/incrementRunAIRecurring', isAllowedInternalAPIHandler, internalController.incrementRunAIRecurring )
     .post( '/recurringFlag', isAllowedInternalAPIHandler, internalController.recurringFlagAlert )
     .post( '/weeklyWrap', isAllowedInternalAPIHandler, internalController.weeklyWrapAlert )
     .post( '/downloadInsertPdf', isAllowedInternalAPIHandler, internalController.downloadInsertPdf )

package/src/services/recurringFlagTracker.service.js

@@ -1,33 +1,33 @@
-import model from 'tango-api-schema';
-
-export const findOne = async ( query={}, field={} ) => {
-  return model.recurringFlagTrackerModel.findOne( query, field );
-};
-
-export const find = async ( query={}, field={} ) => {
-  return model.recurringFlagTrackerModel.find( query, field );
-};
-
-export const create = async ( document = {} ) => {
-  return model.recurringFlagTrackerModel.create( document );
-};
-
-export const updateOne = async ( query = {}, record={} ) => {
-  return model.recurringFlagTrackerModel.updateOne( query, { $set: record }, { upsert: true } );
-};
-
-export const updateMany = async ( query = {}, record={} ) => {
-  return model.recurringFlagTrackerModel.updateMany( query, { $set: record } );
-};
-
-export const deleteOne = async ( query = {} ) => {
-  return model.recurringFlagTrackerModel.deleteOne( query );
-};
-
-export const aggregate = async ( query = [] ) => {
-  return model.recurringFlagTrackerModel.aggregate( query );
-};
-
-export const bulkWrite = async ( ops = [] ) => {
-  return model.recurringFlagTrackerModel.bulkWrite( ops );
-};
+import model from 'tango-api-schema';
+
+export const findOne = async ( query={}, field={} ) => {
+  return model.recurringFlagTrackerModel.findOne( query, field );
+};
+
+export const find = async ( query={}, field={} ) => {
+  return model.recurringFlagTrackerModel.find( query, field );
+};
+
+export const create = async ( document = {} ) => {
+  return model.recurringFlagTrackerModel.create( document );
+};
+
+export const updateOne = async ( query = {}, record={} ) => {
+  return model.recurringFlagTrackerModel.updateOne( query, { $set: record }, { upsert: true } );
+};
+
+export const updateMany = async ( query = {}, record={} ) => {
+  return model.recurringFlagTrackerModel.updateMany( query, { $set: record } );
+};
+
+export const deleteOne = async ( query = {} ) => {
+  return model.recurringFlagTrackerModel.deleteOne( query );
+};
+
+export const aggregate = async ( query = [] ) => {
+  return model.recurringFlagTrackerModel.aggregate( query );
+};
+
+export const bulkWrite = async ( ops = [] ) => {
+  return model.recurringFlagTrackerModel.bulkWrite( ops );
+};