tango-app-api-trax 3.8.21 → 3.8.22-nike

package/src/controllers/internalTrax.controller.js

@@ -325,7 +325,7 @@ export async function PCLconfigCreation( req, res ) {
                 },
               } );
               let getSections = await CLquestions.aggregate( sectionQuery );
-              if ( getSections.length || [ 'storeopenandclose', 'mobileusagedetection', 'uniformdetection', 'customerunattended', 'staffleftinthemiddle', 'eyetest', 'remoteoptometrist', 'storehygienemonitoring', 'cleaning', 'scrum', 'suspiciousactivity', 'boxalert', 'suspiciousfootfall', 'drinking', 'bagdetection', 'inventorycount', 'carsattended', 'numberplateinfo', 'vehicle_check_in', 'outsidebusinesshoursqueuetracking', 'halfshutter', 'tvcompliance', 'cameratampering', 'queuealert', 'storehygienemonitoring' ].includes( getCLconfig.checkListType ) ) {
+              if ( getSections.length || [ 'storeopenandclose', 'mobileusagedetection', 'uniformdetection', 'customerunattended', 'staffleftinthemiddle', 'eyetest', 'remoteoptometrist', 'storehygienemonitoring', 'cleaning', 'scrum', 'suspiciousactivity', 'suspiciousfootfall', 'drinking', 'bagdetection', 'inventorycount', 'carsattended', 'numberplateinfo', 'vehicle_check_in', 'outsidebusinesshoursqueuetracking', 'halfshutter', 'tvcompliance', 'cameratampering', 'queuealert', 'storehygienemonitoring', 'staffgrouping', 'boxalert', 'employeeCount' ].includes( getCLconfig.checkListType ) ) {
                 if ( getSections.length ) {
                   for ( let element3 of getSections ) {
                     let collectQuestions = {};
@@ -650,11 +650,11 @@ export async function PCLconfigCreation( req, res ) {
                       // }
                       }
                     } else {
-                      if ( [ 'storeopenandclose', 'mobileusagedetection', 'uniformdetection', 'customerunattended', 'staffleftinthemiddle', 'eyetest', 'remoteoptometrist', 'storehygienemonitoring', 'cleaning', 'scrum', 'suspiciousactivity', 'boxalert', 'suspiciousfootfall', 'drinking', 'bagdetection', 'inventorycount', 'carsattended', 'numberplateinfo', 'vehicle_check_in', 'outsidebusinesshoursqueuetracking', 'halfshutter', 'tvcompliance', 'cameratampering', 'queuealert' ].includes( getCLconfig.checkListType ) ) {
+                      if ( [ 'storeopenandclose', 'mobileusagedetection', 'uniformdetection', 'customerunattended', 'staffleftinthemiddle', 'eyetest', 'remoteoptometrist', 'storehygienemonitoring', 'cleaning', 'scrum', 'suspiciousactivity', 'suspiciousfootfall', 'drinking', 'bagdetection', 'inventorycount', 'carsattended', 'numberplateinfo', 'vehicle_check_in', 'outsidebusinesshoursqueuetracking', 'halfshutter', 'tvcompliance', 'cameratampering', 'queuealert', 'staffgrouping', 'boxalert' ].includes( getCLconfig.checkListType ) ) {
                         let storeNameList = allQuestion.map( ( item ) => item.store_id );
-                        let storeDetails = await storeService.find( { clientId: getCLconfig.client_id, status: 'active', ...( [ 'storeopenandclose', 'mobileusagedetection', 'uniformdetection', 'customerunattended', 'staffleftinthemiddle', 'scrum', 'cleaning', 'outsidebusinesshoursqueuetracking', 'halfshutter', 'tvcompliance', 'cameratampering', 'queuealert' ].includes( getCLconfig.checkListType ) ) ? { storeId: { $in: storeNameList } } : {} }, { storeId: 1 } );
+                        let storeDetails = await storeService.find( { clientId: getCLconfig.client_id, status: 'active', ...( [ 'storeopenandclose', 'mobileusagedetection', 'uniformdetection', 'customerunattended', 'staffleftinthemiddle', 'scrum', 'cleaning', 'outsidebusinesshoursqueuetracking', 'halfshutter', 'tvcompliance', 'cameratampering', 'queuealert', 'staffgrouping', 'boxalert', 'employeeCount' ].includes( getCLconfig.checkListType ) ) ? { storeId: { $in: storeNameList } } : {} }, { storeId: 1 } );
                         let storeList = storeDetails.map( ( store ) => store.storeId );
-                        if ( [ 'storeopenandclose', 'mobileusagedetection', 'uniformdetection', 'customerunattended', 'staffleftinthemiddle', 'scrum', 'cleaning', 'outsidebusinesshoursqueuetracking', 'halfshutter', 'tvcompliance', 'cameratampering', 'queuealert' ].includes( getCLconfig.checkListType ) ) {
+                        if ( [ 'storeopenandclose', 'mobileusagedetection', 'uniformdetection', 'customerunattended', 'staffleftinthemiddle', 'scrum', 'cleaning', 'outsidebusinesshoursqueuetracking', 'halfshutter', 'tvcompliance', 'cameratampering', 'queuealert', 'staffgrouping', 'boxalert', 'employeeCount' ].includes( getCLconfig.checkListType ) ) {
                           allQuestion = allQuestion.filter( ( ele ) => storeList.includes( ele?.store_id ) );
                         } else {
                           allQuestion = storeDetails.map( ( item ) => {
@@ -688,7 +688,7 @@ export async function PCLconfigCreation( req, res ) {
                           client_id: getCLconfig.client_id,
                           aiStoreList: allQuestion.length ? allQuestion.map( ( store ) => store.store_id ) : [],
                         };
-                        if ( [ 'storeopenandclose', 'mobileusagedetection', 'uniformdetection', 'customerunattended', 'staffleftinthemiddle', 'scrum', 'cleaning', 'outsidebusinesshoursqueuetracking', 'halfshutter', 'tvcompliance', 'cameratampering', 'queuealert' ].includes( getCLconfig.checkListType ) ) {
+                        if ( [ 'storeopenandclose', 'mobileusagedetection', 'uniformdetection', 'customerunattended', 'staffleftinthemiddle', 'scrum', 'cleaning', 'outsidebusinesshoursqueuetracking', 'halfshutter', 'tvcompliance', 'cameratampering', 'queuealert', 'staffgrouping', 'boxalert', 'employeeCount' ].includes( getCLconfig.checkListType ) ) {
                           let processData = {
                             aiStoreList: allQuestion.length ? allQuestion.map( ( store ) => {
                               return { storeName: store.storeName, storeId: store.store_id, events: store.events };
@@ -929,7 +929,7 @@ async function insertData( requestData ) {
                 },
               } );
               let getSections = await CLquestions.aggregate( sectionQuery );
-              if ( getSections.length || [ 'storeopenandclose', 'mobileusagedetection', 'uniformdetection', 'customerunattended', 'staffleftinthemiddle', 'eyetest', 'remoteoptometrist', 'storehygienemonitoring', 'cleaning', 'scrum', 'suspiciousactivity', 'boxalert', 'suspiciousfootfall', 'drinking', 'bagdetection', 'inventorycount', 'carsattended', 'numberplateinfo', 'vehicle_check_in', 'outsidebusinesshoursqueuetracking', 'halfshutter', 'tvcompliance', 'cameratampering', 'queuealert' ].includes( getCLconfig.checkListType ) ) {
+              if ( getSections.length || [ 'storeopenandclose', 'mobileusagedetection', 'uniformdetection', 'customerunattended', 'staffleftinthemiddle', 'eyetest', 'remoteoptometrist', 'storehygienemonitoring', 'cleaning', 'scrum', 'suspiciousactivity', 'suspiciousfootfall', 'drinking', 'bagdetection', 'inventorycount', 'carsattended', 'numberplateinfo', 'vehicle_check_in', 'outsidebusinesshoursqueuetracking', 'halfshutter', 'tvcompliance', 'cameratampering', 'queuealert', 'staffgrouping', 'boxalert', 'employeeCount' ].includes( getCLconfig.checkListType ) ) {
                 if ( getSections.length ) {
                   for ( let element3 of getSections ) {
                     let collectQuestions = {};
@@ -1224,11 +1224,11 @@ async function insertData( requestData ) {
                         // }
                       }
                     } else {
-                      if ( [ 'storeopenandclose', 'mobileusagedetection', 'uniformdetection', 'customerunattended', 'staffleftinthemiddle', 'eyetest', 'remoteoptometrist', 'storehygienemonitoring', 'cleaning', 'scrum', 'suspiciousactivity', 'boxalert', 'suspiciousfootfall', 'drinking', 'bagdetection', 'inventorycount', 'carsattended', 'numberplateinfo', 'vehicle_check_in', 'outsidebusinesshoursqueuetracking', 'halfshutter', 'tvcompliance', 'cameratampering', 'queuealert' ].includes( getCLconfig.checkListType ) ) {
+                      if ( [ 'storeopenandclose', 'mobileusagedetection', 'uniformdetection', 'customerunattended', 'staffleftinthemiddle', 'eyetest', 'remoteoptometrist', 'storehygienemonitoring', 'cleaning', 'scrum', 'suspiciousactivity', 'suspiciousfootfall', 'drinking', 'bagdetection', 'inventorycount', 'carsattended', 'numberplateinfo', 'vehicle_check_in', 'outsidebusinesshoursqueuetracking', 'halfshutter', 'tvcompliance', 'cameratampering', 'queuealert', 'staffgrouping', 'boxalert', 'employeeCount' ].includes( getCLconfig.checkListType ) ) {
                         let storeNameList = allQuestion.map( ( item ) => item.store_id );
-                        let storeDetails = await storeService.find( { clientId: getCLconfig.client_id, status: 'active', ...( [ 'storeopenandclose', 'mobileusagedetection', 'uniformdetection', 'customerunattended', 'staffleftinthemiddle', 'scrum', 'cleaning', 'outsidebusinesshoursqueuetracking', 'halfshutter', 'tvcompliance', 'cameratampering', 'queuealert' ].includes( getCLconfig.checkListType ) ) ? { storeId: { $in: storeNameList } } : {} }, { storeId: 1 } );
+                        let storeDetails = await storeService.find( { clientId: getCLconfig.client_id, status: 'active', ...( [ 'storeopenandclose', 'mobileusagedetection', 'uniformdetection', 'customerunattended', 'staffleftinthemiddle', 'scrum', 'cleaning', 'outsidebusinesshoursqueuetracking', 'halfshutter', 'tvcompliance', 'cameratampering', 'queuealert', 'staffgrouping', 'boxalert', 'employeeCount' ].includes( getCLconfig.checkListType ) ) ? { storeId: { $in: storeNameList } } : {} }, { storeId: 1 } );
                         let storeList = storeDetails.map( ( store ) => store.storeId );
-                        if ( [ 'storeopenandclose', 'mobileusagedetection', 'uniformdetection', 'customerunattended', 'staffleftinthemiddle', 'scrum', 'cleaning', 'outsidebusinesshoursqueuetracking', 'halfshutter', 'tvcompliance', 'cameratampering', 'queuealert' ].includes( getCLconfig.checkListType ) ) {
+                        if ( [ 'storeopenandclose', 'mobileusagedetection', 'uniformdetection', 'customerunattended', 'staffleftinthemiddle', 'scrum', 'cleaning', 'outsidebusinesshoursqueuetracking', 'halfshutter', 'tvcompliance', 'cameratampering', 'queuealert', 'staffgrouping', 'boxalert', 'employeeCount' ].includes( getCLconfig.checkListType ) ) {
                           allQuestion = allQuestion.filter( ( ele ) => storeList.includes( ele?.store_id ) );
                         } else {
                           allQuestion = storeDetails.map( ( item ) => {
@@ -1262,7 +1262,7 @@ async function insertData( requestData ) {
                           client_id: getCLconfig.client_id,
                           aiStoreList: allQuestion.length ? allQuestion.map( ( store ) => store.store_id ) : [],
                         };
-                        if ( [ 'storeopenandclose', 'mobileusagedetection', 'uniformdetection', 'customerunattended', 'staffleftinthemiddle', 'scrum', 'cleaning', 'outsidebusinesshoursqueuetracking', 'halfshutter', 'tvcompliance', 'cameratampering', 'queuealert' ].includes( getCLconfig.checkListType ) ) {
+                        if ( [ 'storeopenandclose', 'mobileusagedetection', 'uniformdetection', 'customerunattended', 'staffleftinthemiddle', 'scrum', 'cleaning', 'outsidebusinesshoursqueuetracking', 'halfshutter', 'tvcompliance', 'cameratampering', 'queuealert', 'staffgrouping', 'boxalert', 'employeeCount' ].includes( getCLconfig.checkListType ) ) {
                           let processData = {
                             aiStoreList: allQuestion.length ? allQuestion.map( ( store ) => {
                               return { storeName: store.storeName, storeId: store.store_id, events: store.events };
@@ -2119,7 +2119,6 @@ export async function getPDFCSVChecklistDetails( req, res ) {
   }
 }
 
-
 export async function AiPushNotificationAlert( req, res ) {
   try {
     // console.log( req.body );
@@ -2176,7 +2175,6 @@ export async function liveAiPushNotificationAlert( req, res ) {
   }
 }
 
-
 export async function taskPushNotification( req, res ) {
   try {
     let query = [ {
@@ -2645,6 +2643,9 @@ export async function updateRunAI( req, res ) {
     if ( !req.body.qName ) {
       return res.sendError( 'Question name is required', 400 );
     }
+    if ( !req.body.userAnswer ) {
+      return res.sendError( 'answer is required', 400 );
+    }
     let getDetails = await processedchecklist.findOne( { _id: req.body.id } );
     if ( !getDetails ) {
       return res.sendError( 'No data found', 204 );
@@ -2653,7 +2654,7 @@ export async function updateRunAI( req, res ) {
     let updateData = {};
 
     for ( let k of Object.keys( req.body.data ) ) {
-      let keyPath = `questionAnswers.$[section].questions.$[question].userAnswer.0.${k}`;
+      let keyPath = `questionAnswers.$[section].questions.$[question].userAnswer.$[userAnswer].${k}`;
       updateData[keyPath] = req.body.data[k];
     }
 
@@ -2664,7 +2665,9 @@ export async function updateRunAI( req, res ) {
           arrayFilters: [
             { 'section.section_id': new ObjectId( req.body.sectionId ) },
             { 'question.qname': req.body.qName },
+            { 'userAnswer.answer': req.body.userAnswer },
           ],
+          strict: false,
         },
     );
     return res.sendSuccess( 'RunAI details updated successfully' );
@@ -2699,6 +2702,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;
@@ -3749,7 +3859,6 @@ export async function checklistAutoMailList( req, res ) {
   }
 }
 
-
 export const downloadInsertPdfOld = async ( req, res ) => {
   try {
     setImmediate( async () => {
@@ -4227,17 +4336,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 ) );
@@ -4249,13 +4359,12 @@ export async function recurringFlagAlert( req, res ) {
     const checklistDetails = await CLconfig.find( {
       publish: true,
       $expr: {
-        $gt: [
-          { $size: { $cond: [ { $isArray: '$recurringFlag.users' }, '$recurringFlag.users', [] ] } },
-          0,
+        $or: [
+          { $gt: [ { $size: { $cond: [ { $isArray: '$recurringFlag.users' }, '$recurringFlag.users', [] ] } }, 0 ] },
+          { $gt: [ { $size: { $cond: [ { $isArray: '$recurringFlag.notifyType' }, '$recurringFlag.notifyType', [] ] } }, 0 ] },
         ],
       },
-    }, { _id: 1, checkListName: 1, recurringFlag: 1, approver: 1, client_id: 1 } );
-
+    }, { _id: 1, checkListName: 1, recurringFlag: 1, notifyFlags: 1, approver: 1, client_id: 1 } );
     if ( !checklistDetails.length ) {
       return res.sendSuccess( 'No checklists configured for recurring flag' );
     }
@@ -4268,42 +4377,103 @@ 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 || [];
+        const nfUsers = cl?.notifyFlags?.users || [];
+        if ( nfType.includes( 'approver' ) && Array.isArray( cl.approver ) ) {
+          recipients = cl.approver.map( ( a ) => a?.value ).filter( Boolean );
+        }
+        recipients = [ ...recipients, ...nfUsers.map( ( u ) => u?.value ).filter( Boolean ) ];
+      }
       if ( notifyType.includes( 'approver' ) && Array.isArray( cl.approver ) ) {
-        recipients = cl.approver.map( ( a ) => a?.value ).filter( Boolean );
+        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).
+      // Resolve each recipient's allowed-store scope once per checklist:
+      //   allowed === null  → full access (superadmin / non-client userType / external recipient not in users collection)
+      //   allowed === Set   → restrict store-based rows to these storeIds
+      // User-based tracker rows pass through regardless (no store binding).
+      const recipientFilters = await Promise.all( recipients.map( async ( recipient ) => {
+        const userDetails = await userService.findOne(
+            { email: recipient },
+            { email: 1, assignedStores: 1, userType: 1, role: 1, clientId: 1 },
+        );
+        // Unknown recipients (external approvers etc.) keep full access — preserves existing behavior.
+        const allowed = userDetails ? await resolveUserAssignedStores( userDetails ) : null;
+        return { recipient, allowed };
+      } ) );
+
+      // 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 ) {
-        for ( const recipient of recipients ) {
+        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;
+
+        let rowEmitted = false;
+        for ( const { recipient, allowed } of recipientFilters ) {
+          // Skip store-based rows outside the recipient's reachable stores. Full-access (null) and
+          // user-based rows always pass through.
+          if ( allowed !== null && !isUserBased && !allowed.has( t.store_id ) ) continue;
           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 || '',
           } );
+          rowEmitted = true;
+        }
+        // Only reset rows that actually went into at least one recipient's email — otherwise a row
+        // visible to nobody would silently zero its streak without an email being sent.
+        if ( rowEmitted ) {
+          trackerIdsToReset.push( {
+            _id: t._id,
+            lastFlaggedDate: t.lastFlaggedDate,
+            lastRunAIFlaggedDate: t.lastRunAIFlaggedDate,
+            sopFired,
+            runAIFired,
+          } );
         }
-        trackerIdsToReset.push( { _id: t._id, lastFlaggedDate: t.lastFlaggedDate } );
       }
     } ) );
 
@@ -4311,6 +4481,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 ) {
@@ -4325,21 +4496,77 @@ 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;
+      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.
+      // Sub-mode of multi-store when the recipient's flagged subjects all share a single checklist.
+      // Drives a tighter email layout (no Checklist column, no "Total Checklists" line, checklist name in intro).
+      const isMultiStoreSingleChecklist = isMultiStore && checklists.size === 1;
+      // 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 );
+        if ( i.sopFired ) g.questionCount += 1;
+        if ( i.runAIFired ) g.runAICount += 1;
+        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, // legacy alias kept for back-compat with older template builds
+        flagCount: g.questionCount,
+        runAICount: g.runAICount,
+        totalFlags: g.questionCount + 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;
@@ -4350,31 +4577,43 @@ export async function recurringFlagAlert( req, res ) {
         threshold: thresholdShown,
         isMultiStore,
         isMultiChecklist,
+        isMultiStoreSingleChecklist,
+        isUserCoverage: isAllUser,
         showTable: isMultiStore || isMultiChecklist,
         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,
         };
+        if ( isMultiStoreSingleChecklist ) {
+          // Show the single checklist name in the intro line for this sub-mode.
+          data.checklistName = items[0].checklistName;
+        }
       } 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) — totalFlags = sop question flags + runAI flags.
+        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.runAICount = single.runAICount;
+        data.totalFlags = single.totalFlags;
       }
 
       const html = compiled( { data } );
@@ -4389,7 +4628,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 ),
@@ -4399,19 +4638,31 @@ export async function recurringFlagAlert( req, res ) {
           logger.error( { functionName: 'recurringFlagAlert.buildExcel', error: e } );
         }
       }
-
       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 and stamp lastEmailDate for all triggered tracker rows so the next streak starts fresh.
+    // 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 } },
-        },
-      } ) );
+      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 );
     }
 
@@ -4422,41 +4673,510 @@ export async function recurringFlagAlert( req, res ) {
   }
 }
 
+function getLastWeekRange( ref = dayjs() ) {
+  const today = ref.startOf( 'day' );
+  const dow = today.day(); // 0 Sun ... 6 Sat
+  const daysToThisMonday = ( dow + 6 ) % 7; // Mon=0, Tue=1, ..., Sun=6
+  const thisMonday = today.subtract( daysToThisMonday, 'day' );
+  // Current week (Mon..Sun) — primary range surfaced in the email.
+  const weekStart = thisMonday;
+  const weekEnd = thisMonday.add( 6, 'day' );
+  // Previous full week (Mon..Sun) — used for WoW comparisons.
+  const prevWeekStart = thisMonday.subtract( 7, 'day' );
+  const prevWeekEnd = thisMonday.subtract( 1, 'day' );
+  return {
+    weekStart: weekStart.format( 'YYYY-MM-DD' ),
+    weekEnd: weekEnd.format( 'YYYY-MM-DD' ),
+    prevWeekStart: prevWeekStart.format( 'YYYY-MM-DD' ),
+    prevWeekEnd: prevWeekEnd.format( 'YYYY-MM-DD' ),
+  };
+}
+
+function computeWow( current, previous ) {
+  if ( !previous ) {
+    if ( current ) return { value: '100%', direction: 'up' };
+    return { value: '', direction: 'up' };
+  }
+  const delta = current - previous;
+  if ( delta === 0 ) return { value: '0%', direction: 'up' };
+  const pct = Math.min( 100, Math.round( ( Math.abs( delta ) / previous ) * 100 ) );
+  return { value: `${pct}%`, direction: delta > 0 ? 'up' : 'down' };
+}
+
+async function aggregateWeeklyFlagsByStore( weekStart, weekEnd ) {
+  const rows = await processedchecklist.aggregate( [
+    { $match: { date_string: { $gte: weekStart, $lte: weekEnd }, checkListType: 'custom' } },
+    { $group: {
+      _id: { client_id: '$client_id', store_id: '$store_id' },
+      storeName: { $last: '$storeName' },
+      questionFlag: { $sum: { $ifNull: [ '$questionFlag', 0 ] } },
+      timeFlag: { $sum: { $ifNull: [ '$timeFlag', 0 ] } },
+      runAIFlag: { $sum: { $ifNull: [ '$runAIFlag', 0 ] } },
+      flaggedChecklistIds: { $addToSet: {
+        $cond: [
+          { $or: [
+            { $gt: [ { $ifNull: [ '$questionFlag', 0 ] }, 0 ] },
+            { $gt: [ { $ifNull: [ '$timeFlag', 0 ] }, 0 ] },
+            { $gt: [ { $ifNull: [ '$runAIFlag', 0 ] }, 0 ] },
+          ] },
+          '$sourceCheckList_id',
+          null,
+        ],
+      } },
+    } },
+  ] );
+  const map = new Map();
+  for ( const r of rows ) {
+    const key = `${r._id.client_id}::${r._id.store_id}`;
+    const flaggedChecklists = ( r.flaggedChecklistIds || [] ).filter( ( id ) => id ).map( ( id ) => String( id ) );
+    const totalFlags = ( r.questionFlag || 0 ) + ( r.timeFlag || 0 ) + ( r.runAIFlag || 0 );
+    map.set( key, {
+      client_id: r._id.client_id,
+      store_id: r._id.store_id,
+      storeName: r.storeName,
+      questionFlag: r.questionFlag || 0,
+      timeFlag: r.timeFlag || 0,
+      runAIFlag: r.runAIFlag || 0,
+      flaggedChecklists,
+      totalFlags,
+    } );
+  }
+  return map;
+}
+
+async function aggregateWeeklyRecurringByStore( weekStart, weekEnd ) {
+  // Counts how many distinct days within the week the store received a recurring-flag email.
+  // Each tracker doc is per-question, so a single email covering N flagged questions adds the same date
+  // to N tracker docs — we de-dupe by date per store via $addToSet.
+  const rows = await recurringFlagTracker.aggregate( [
+    { $match: { emailHistory: { $elemMatch: { $gte: weekStart, $lte: weekEnd } } } },
+    { $project: {
+      client_id: 1,
+      store_id: 1,
+      storeName: 1,
+      datesInWeek: {
+        $filter: {
+          input: { $ifNull: [ '$emailHistory', [] ] },
+          as: 'd',
+          cond: { $and: [ { $gte: [ '$$d', weekStart ] }, { $lte: [ '$$d', weekEnd ] } ] },
+        },
+      },
+    } },
+    { $unwind: '$datesInWeek' },
+    { $group: {
+      _id: { client_id: '$client_id', store_id: '$store_id' },
+      storeName: { $last: '$storeName' },
+      uniqueDates: { $addToSet: '$datesInWeek' },
+    } },
+    { $project: {
+      _id: 1,
+      storeName: 1,
+      count: { $size: '$uniqueDates' },
+    } },
+  ] );
+  const map = new Map();
+  for ( const r of rows ) {
+    map.set( `${r._id.client_id}::${r._id.store_id}`, {
+      client_id: r._id.client_id,
+      store_id: r._id.store_id,
+      storeName: r.storeName,
+      count: r.count,
+    } );
+  }
+  return map;
+}
+
+function buildWeeklyWrapExcel( header, perStoreChecklistRows ) {
+  const workbook = new ExcelJS.Workbook();
+  const sheet = workbook.addWorksheet( 'Weekly Summary' );
+  sheet.addRow( [ header ] );
+  sheet.getRow( 1 ).font = { bold: true, size: 14 };
+  sheet.addRow( [] );
+  sheet.columns = [
+    { header: 'Store Name', key: 'storeName', width: 28 },
+    { header: 'Checklist Name', key: 'checkListName', width: 32 },
+    { header: 'Flags', key: 'flags', width: 12 },
+    { header: 'Question Flags', key: 'questionFlag', width: 16 },
+    { header: 'Not Submitted Flags', key: 'timeFlag', width: 20 },
+    { header: 'Run AI Flags', key: 'runAIFlag', width: 14 },
+    { header: 'Recurring Flags', key: 'recurringFlag', width: 18 },
+  ];
+  sheet.getRow( 3 ).font = { bold: true };
+  sheet.getRow( 3 ).fill = { type: 'pattern', pattern: 'solid', fgColor: { argb: 'FFF1F5F9' } };
+  for ( const r of perStoreChecklistRows ) sheet.addRow( r );
+  return workbook.xlsx.writeBuffer();
+}
+
+// Per-(store, checklist) flag aggregation for the weekly Excel attachment. Same source as
+// aggregateWeeklyFlagsByStore but additionally grouped by sourceCheckList_id so each row in the export
+// corresponds to one store × one checklist.
+async function aggregateWeeklyFlagsByStoreChecklist( weekStart, weekEnd ) {
+  const rows = await processedchecklist.aggregate( [
+    { $match: { date_string: { $gte: weekStart, $lte: weekEnd }, isdeleted: { $ne: true } } },
+    { $group: {
+      _id: { client_id: '$client_id', store_id: '$store_id', sourceCheckList_id: '$sourceCheckList_id' },
+      storeName: { $last: '$storeName' },
+      checkListName: { $last: '$checkListName' },
+      questionFlag: { $sum: { $ifNull: [ '$questionFlag', 0 ] } },
+      timeFlag: { $sum: { $ifNull: [ '$timeFlag', 0 ] } },
+      runAIFlag: { $sum: { $ifNull: [ '$runAIFlag', 0 ] } },
+    } },
+  ] );
+  const map = new Map();
+  for ( const r of rows ) {
+    const key = `${r._id.client_id}::${r._id.store_id}::${r._id.sourceCheckList_id}`;
+    map.set( key, {
+      client_id: r._id.client_id,
+      store_id: r._id.store_id,
+      sourceCheckList_id: String( r._id.sourceCheckList_id || '' ),
+      storeName: r.storeName,
+      checkListName: r.checkListName,
+      questionFlag: r.questionFlag || 0,
+      timeFlag: r.timeFlag || 0,
+      runAIFlag: r.runAIFlag || 0,
+    } );
+  }
+  return map;
+}
+
+// Per-(store, checklist) recurring count = distinct days the (store, checklist) was emailed in the week.
+async function aggregateWeeklyRecurringByStoreChecklist( weekStart, weekEnd ) {
+  const rows = await recurringFlagTracker.aggregate( [
+    { $match: { emailHistory: { $elemMatch: { $gte: weekStart, $lte: weekEnd } } } },
+    { $project: {
+      client_id: 1,
+      store_id: 1,
+      storeName: 1,
+      sourceCheckList_id: 1,
+      checkListName: 1,
+      datesInWeek: {
+        $filter: {
+          input: { $ifNull: [ '$emailHistory', [] ] },
+          as: 'd',
+          cond: { $and: [ { $gte: [ '$$d', weekStart ] }, { $lte: [ '$$d', weekEnd ] } ] },
+        },
+      },
+    } },
+    { $unwind: '$datesInWeek' },
+    { $group: {
+      _id: { client_id: '$client_id', store_id: '$store_id', sourceCheckList_id: '$sourceCheckList_id' },
+      storeName: { $last: '$storeName' },
+      checkListName: { $last: '$checkListName' },
+      uniqueDates: { $addToSet: '$datesInWeek' },
+    } },
+    { $project: {
+      _id: 1,
+      storeName: 1,
+      checkListName: 1,
+      count: { $size: '$uniqueDates' },
+    } },
+  ] );
+  const map = new Map();
+  for ( const r of rows ) {
+    const key = `${r._id.client_id}::${r._id.store_id}::${r._id.sourceCheckList_id}`;
+    map.set( key, {
+      client_id: r._id.client_id,
+      store_id: r._id.store_id,
+      sourceCheckList_id: String( r._id.sourceCheckList_id || '' ),
+      storeName: r.storeName,
+      checkListName: r.checkListName,
+      count: r.count,
+    } );
+  }
+  return map;
+}
+
+// Resolves the set of storeIds a user can see. Returns:
+//   null            — full access (superadmin or non-client userType); caller should not filter
+//   Set<storeId>    — restricted access; iterate this user's reachable stores
+// Mirrors the existing pattern at internalTrax.controller.js ~L4192 (assignedStores + clusters where the
+// user is a Teamlead + teams the user leads + teams the user is a member of, all expanded to storeIds).
+async function resolveUserAssignedStores( userDetails ) {
+  if ( !userDetails ) return new Set();
+  if ( userDetails.userType !== 'client' || userDetails.role === 'superadmin' ) {
+    return null;
+  }
+  const storeIds = new Set( ( userDetails.assignedStores || [] ).map( ( s ) => s?.storeId ).filter( Boolean ) );
+
+  const [ leadClusters, leadTeams ] = await Promise.all( [
+    clusterServices.findcluster( { clientId: userDetails.clientId, Teamlead: { $elemMatch: { email: userDetails.email } } } ),
+    teamsServices.findteams( { clientId: userDetails.clientId, Teamlead: { $elemMatch: { email: userDetails.email } } } ),
+  ] );
+
+  for ( const cluster of leadClusters || [] ) {
+    ( cluster.stores || [] ).forEach( ( s ) => s?.storeId && storeIds.add( s.storeId ) );
+  }
+
+  // Teams the user leads — pull each member's assignedStores + clusters where THAT member is Teamlead.
+  for ( const team of leadTeams || [] ) {
+    for ( const member of team.users || [] ) {
+      const memberDetails = await userService.findOne( { _id: member.userId } );
+      if ( memberDetails?.assignedStores?.length ) {
+        memberDetails.assignedStores.forEach( ( s ) => s?.storeId && storeIds.add( s.storeId ) );
+      }
+      if ( memberDetails?.email ) {
+        const memberClusters = await clusterServices.findcluster( { clientId: userDetails.clientId, Teamlead: { $elemMatch: { email: memberDetails.email } } } );
+        for ( const cluster of memberClusters || [] ) {
+          ( cluster.stores || [] ).forEach( ( s ) => s?.storeId && storeIds.add( s.storeId ) );
+        }
+      }
+    }
+  }
+
+  // Teams the user is a member of — pull clusters that reference those teams.
+  const memberTeams = await teamsServices.findteams( { clientId: userDetails.clientId, users: { $elemMatch: { email: userDetails.email } } } );
+  for ( const team of memberTeams || [] ) {
+    const clusters = await clusterServices.findcluster( { clientId: userDetails.clientId, teams: { $elemMatch: { name: team.teamName } } } );
+    for ( const cluster of clusters || [] ) {
+      ( cluster.stores || [] ).forEach( ( s ) => s?.storeId && storeIds.add( s.storeId ) );
+    }
+  }
+
+  // Teams the user leads — also pull clusters that reference those teams.
+  for ( const team of leadTeams || [] ) {
+    const clusters = await clusterServices.findcluster( { clientId: userDetails.clientId, teams: { $elemMatch: { name: team.teamName } } } );
+    for ( const cluster of clusters || [] ) {
+      ( cluster.stores || [] ).forEach( ( s ) => s?.storeId && storeIds.add( s.storeId ) );
+    }
+  }
+
+  return storeIds;
+}
+
+export async function weeklyWrapAlert( req, res ) {
+  try {
+    const range = getLastWeekRange();
+    const startDateLabel = dayjs( range.weekStart ).format( 'DD/MM/YY' );
+    const endDateLabel = dayjs( range.weekEnd ).format( 'DD/MM/YY' );
+
+    // Only send to clients that opted in via weeklyFlagEmail. Build the allow-list once.
+    const enabledClients = await clientService.find( { weeklyFlagEmail: true }, { clientId: 1 } );
+    console.log( enabledClients );
+    if ( !enabledClients.length ) {
+      return res.sendSuccess( { message: 'No clients configured for weeklyFlagEmail', sent: [] } );
+    }
+    const enabledClientIds = new Set( enabledClients.map( ( c ) => String( c.clientId ) ) );
+
+    // Aggregate flag data for both weeks across all stores in one shot. The per-(store, checklist)
+    // maps drive the Excel attachment rows; the per-store maps drive the email body's totals + top picks.
+    const [ flagsThis, flagsPrev, recurThis, recurPrev, flagsThisCL, recurThisCL ] = await Promise.all( [
+      aggregateWeeklyFlagsByStore( range.weekStart, range.weekEnd ),
+      aggregateWeeklyFlagsByStore( range.prevWeekStart, range.prevWeekEnd ),
+      aggregateWeeklyRecurringByStore( range.weekStart, range.weekEnd ),
+      aggregateWeeklyRecurringByStore( range.prevWeekStart, range.prevWeekEnd ),
+      aggregateWeeklyFlagsByStoreChecklist( range.weekStart, range.weekEnd ),
+      aggregateWeeklyRecurringByStoreChecklist( range.weekStart, range.weekEnd ),
+    ] );
+
+    const fileContent = fs.readFileSync( path.resolve( path.dirname( '' ) ) + '/src/hbs/weeklyWrap.hbs', 'utf8' );
+    const compiled = handlebars.compile( fileContent );
+    const flagDomain = `${JSON.parse( process.env.URL ).domain}/manage/trax/dashboard`;
+    const sentSummary = [];
+
+    // Build one digest per client present in the data, restricted to clients that opted in.
+    const clientIds = new Set();
+    for ( const v of flagsThis.values() ) {
+      if ( enabledClientIds.has( String( v.client_id ) ) ) clientIds.add( v.client_id );
+    }
+    for ( const v of recurThis.values() ) {
+      if ( enabledClientIds.has( String( v.client_id ) ) ) clientIds.add( v.client_id );
+    }
+
+    await Promise.all( [ ...clientIds ].map( async ( clientId ) => {
+      try {
+        // Recipients = admin + superadmin users for this client. Each user's digest is scoped via
+        // resolveUserAssignedStores — superadmin / tango users see everything, regular admins see only
+        // stores they own (assignedStores + clusters they lead + teams they're in/lead).
+        const adminUsers = await userService.find(
+            { clientId: String( clientId ), role: { $in: [ 'admin', 'superadmin' ] } },
+            { email: 1, assignedStores: 1, userName: 1, userType: 1, role: 1, clientId: 1 },
+        );
+        console.log( adminUsers );
+        if ( !adminUsers.length ) {
+          logger.info( `[weeklyWrapAlert] no admin/superadmin users for client ${clientId}, skipping` );
+          return;
+        }
+
+        for ( const user of adminUsers ) {
+          try {
+            if ( !user?.email ) continue;
+            const allowed = await resolveUserAssignedStores( user );
+            // null = full access (superadmin / tango). Empty set = no reachable stores → skip.
+            if ( allowed && allowed.size === 0 ) {
+              logger.info( `[weeklyWrapAlert] user ${user.email} has no reachable stores, skipping` );
+              continue;
+            }
+
+            // Iterate stores belonging to this client; intersect with the user's allowed set when present.
+            const clientPrefix = `${clientId}::`;
+            const isAllowed = ( storeId ) => allowed === null || allowed.has( storeId );
+            const clientStoreKeys = new Set();
+            for ( const k of flagsThis.keys() ) {
+              if ( k.startsWith( clientPrefix ) && isAllowed( k.slice( clientPrefix.length ) ) ) clientStoreKeys.add( k );
+            }
+            for ( const k of flagsPrev.keys() ) {
+              if ( k.startsWith( clientPrefix ) && isAllowed( k.slice( clientPrefix.length ) ) ) clientStoreKeys.add( k );
+            }
+            for ( const k of recurThis.keys() ) {
+              if ( k.startsWith( clientPrefix ) && isAllowed( k.slice( clientPrefix.length ) ) ) clientStoreKeys.add( k );
+            }
+
+            let storesFlagged = 0;
+            let totalFlags = 0;
+            let prevTotalFlags = 0;
+            let prevStoresFlagged = 0;
+            const flaggedChecklistsThis = new Set();
+            const flaggedChecklistsPrev = new Set();
+            let questionFlags = 0;
+            let notSubmittedFlags = 0;
+            let runAIFlags = 0;
+            let recurringFlags = 0;
+            const excelRows = [];
+            // Track top flagged + top recurring within this user's assigned stores only.
+            let topFlag = null;
+            let topRecurring = null;
+
+            for ( const k of clientStoreKeys ) {
+              const cur = flagsThis.get( k );
+              const prev = flagsPrev.get( k );
+              const recCur = recurThis.get( k );
+              const recPrev = recurPrev.get( k );
+              const storeRecurring = recCur?.count || 0;
+              const storeTotal = ( cur?.totalFlags || 0 ) + storeRecurring;
+              const prevStoreTotal = ( prev?.totalFlags || 0 ) + ( recPrev?.count || 0 );
+
+              if ( storeTotal > 0 ) storesFlagged += 1;
+              if ( prevStoreTotal > 0 ) prevStoresFlagged += 1;
+              totalFlags += storeTotal;
+              prevTotalFlags += prevStoreTotal;
+              questionFlags += cur?.questionFlag || 0;
+              notSubmittedFlags += cur?.timeFlag || 0;
+              runAIFlags += cur?.runAIFlag || 0;
+              recurringFlags += storeRecurring;
+
+              ( cur?.flaggedChecklists || [] ).forEach( ( id ) => flaggedChecklistsThis.add( id ) );
+              ( prev?.flaggedChecklists || [] ).forEach( ( id ) => flaggedChecklistsPrev.add( id ) );
+
+              if ( cur && ( !topFlag || ( cur.totalFlags || 0 ) > topFlag.value ) ) {
+                topFlag = { storeId: cur.store_id, storeName: cur.storeName, value: cur.totalFlags || 0 };
+              }
+              if ( recCur && ( !topRecurring || ( recCur.count || 0 ) > topRecurring.value ) ) {
+                topRecurring = { storeId: recCur.store_id, storeName: recCur.storeName, value: recCur.count || 0 };
+              }
+            }
+
+            if ( totalFlags === 0 && prevTotalFlags === 0 ) {
+              continue; // user has nothing to report this week
+            }
+
+            // Build the Excel attachment as one row per (store, checklist) the user can see.
+            // Pulls from the per-checklist flag aggregation + per-checklist recurring email count.
+            const seenStoreChecklist = new Set();
+            for ( const k of flagsThisCL.keys() ) {
+              if ( !k.startsWith( clientPrefix ) ) continue;
+              const cur = flagsThisCL.get( k );
+              if ( !isAllowed( cur.store_id ) ) continue;
+              const recCur = recurThisCL.get( k );
+              const recurringCount = recCur?.count || 0;
+              const flags = ( cur.questionFlag || 0 ) + ( cur.timeFlag || 0 ) + ( cur.runAIFlag || 0 ) + recurringCount;
+              if ( flags === 0 ) continue;
+              excelRows.push( {
+                storeName: cur.storeName || '',
+                checkListName: cur.checkListName || '',
+                flags,
+                questionFlag: cur.questionFlag || 0,
+                timeFlag: cur.timeFlag || 0,
+                runAIFlag: cur.runAIFlag || 0,
+                recurringFlag: recurringCount,
+              } );
+              seenStoreChecklist.add( k );
+            }
+            // (store, checklist) pairs that hit recurring threshold but had no flag aggregation entry.
+            for ( const k of recurThisCL.keys() ) {
+              if ( !k.startsWith( clientPrefix ) ) continue;
+              if ( seenStoreChecklist.has( k ) ) continue;
+              const recCur = recurThisCL.get( k );
+              if ( !isAllowed( recCur.store_id ) ) continue;
+              if ( !recCur.count ) continue;
+              excelRows.push( {
+                storeName: recCur.storeName || '',
+                checkListName: recCur.checkListName || '',
+                flags: recCur.count,
+                questionFlag: 0,
+                timeFlag: 0,
+                runAIFlag: 0,
+                recurringFlag: recCur.count,
+              } );
+            }
+
+            let highestFlaggedStoreWow = { value: '', direction: 'up' };
+            if ( topFlag ) {
+              const prev = flagsPrev.get( `${clientId}::${topFlag.storeId}` );
+              highestFlaggedStoreWow = computeWow( topFlag.value, prev?.totalFlags || 0 );
+            }
+            let highestRecurringStoreWow = { value: '', direction: 'up' };
+            if ( topRecurring ) {
+              const prev = recurPrev.get( `${clientId}::${topRecurring.storeId}` );
+              highestRecurringStoreWow = computeWow( topRecurring.value, prev?.count || 0 );
+            }
+
+            const excelHeader = `Weekly Summary ${startDateLabel} - ${endDateLabel}`;
+            const buf = await buildWeeklyWrapExcel( excelHeader, excelRows );
+            const attachmentBuffer = Buffer.from( buf );
+            const sizeKb = Math.max( 1, Math.round( attachmentBuffer.length / 1024 ) );
+
+            const data = {
+              startDate: startDateLabel,
+              endDate: endDateLabel,
+              storesFlagged,
+              storesFlaggedWow: computeWow( storesFlagged, prevStoresFlagged ),
+              totalFlags,
+              totalFlagsWow: computeWow( totalFlags, prevTotalFlags ),
+              checklistFlags: flaggedChecklistsThis.size,
+              checklistFlagsWow: computeWow( flaggedChecklistsThis.size, flaggedChecklistsPrev.size ),
+              questionFlags,
+              notSubmittedFlags,
+              runAIFlags,
+              recurringFlags,
+              highestFlaggedStore: topFlag?.storeName || topFlag?.storeId || '--',
+              highestFlaggedStoreWow,
+              highestRecurringStore: topRecurring?.storeName || topRecurring?.storeId || '--',
+              highestRecurringStoreWow,
+              attachmentName: `${excelHeader}.xlsx`,
+              attachmentSize: `${sizeKb} KB`,
+              domain: flagDomain,
+            };
+
+            const html = compiled( { data } );
+            const attachment = {
+              filename: `${excelHeader}.xlsx`,
+              content: attachmentBuffer,
+              contentType: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+            };
+            const sourceEmail = JSON.parse( process.env.SES ).adminEmail;
+            const subject = `TangoEye | Weekly Wrap (${startDateLabel} - ${endDateLabel})`;
+
+            sendEmailWithSES( user.email, subject, html, attachment, sourceEmail );
+            sentSummary.push( { recipient: user.email, clientId, totalFlags } );
+          } catch ( e ) {
+            logger.error( { functionName: 'weeklyWrapAlert.user', clientId, email: user?.email, error: e } );
+          }
+        }
+      } catch ( e ) {
+        logger.error( { functionName: 'weeklyWrapAlert.client', clientId, error: e } );
+      }
+    } ) );
+
+    return res.sendSuccess( { message: 'Weekly wrap dispatched', range, sent: sentSummary } );
+  } catch ( e ) {
+    logger.error( { functionName: 'weeklyWrapAlert', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+
 export async function updateStoreLatLong( req, res ) {
   try {
-    const defaultStores = [
-      { 'storeName': 'OFLBTM', 'lat': 12.9059052, 'long': 77.6057203 },
-      { 'storeName': 'OFLRRN', 'lat': 12.9096852, 'long': 77.5135813 },
-      { 'storeName': 'OFLGUN', 'lat': 12.9286282, 'long': 77.738055 },
-      { 'storeName': 'OFLJPN', 'lat': 12.8915891, 'long': 77.5776564 },
-      { 'storeName': 'OFLAECS', 'lat': 12.9638564, 'long': 77.7125467 },
-      { 'storeName': 'Seegehalli', 'lat': 13.0083064, 'long': 77.7588426 },
-      { 'storeName': 'OFLJPNS', 'lat': 12.8695409, 'long': 77.5820004 },
-      { 'storeName': 'OFLHAR', 'lat': 12.9136122, 'long': 77.6649999 },
-      { 'storeName': 'OFLKSNR', 'lat': 13.0051196, 'long': 77.6601987 },
-      { 'storeName': 'Hosa Road', 'lat': 12.8792369, 'long': 77.6721843 },
-      { 'storeName': 'OFLDEV', 'lat': 12.8942057, 'long': 77.6019696 },
-      { 'storeName': 'OFLAYN', 'lat': 12.958161, 'long': 77.570055 },
-      { 'storeName': 'OFLKAG', 'lat': 12.9845196, 'long': 77.6758945 },
-      { 'storeName': 'OFLBVR', 'lat': 12.9858428, 'long': 77.5424725 },
-      { 'storeName': 'OFLMTK', 'lat': 13.0279313, 'long': 77.5587934 },
-      { 'storeName': 'OFLMAG', 'lat': 12.9837929, 'long': 77.5325324 },
-      { 'storeName': 'OFLBEL', 'lat': 13.0370029, 'long': 77.5622911 },
-      { 'storeName': 'OFLKDU', 'lat': 12.8835726, 'long': 77.517709 },
-      { 'storeName': 'OFLAMLI', 'lat': 13.0685032, 'long': 77.5972815 },
-      { 'storeName': 'OFLSAN', 'lat': 19.0603798, 'long': 73.0041633 },
-      { 'storeName': 'OFLLOK', 'lat': 19.1471544, 'long': 72.5405682 },
-      { 'storeName': 'OFLTSTG', 'lat': 19.2471119, 'long': 72.9769107 },
-      { 'storeName': 'OFLKHGRS', 'lat': 19.0583611, 'long': 73.0584353 },
-      { 'storeName': 'OFLMAL', 'lat': 12.9673877, 'long': 77.499519 },
-      { 'storeName': 'OFLBAG', 'lat': 13.1218427, 'long': 77.6234015 },
-      { 'storeName': 'OFLYEL', 'lat': 13.114551, 'long': 77.5401312 },
-      { 'storeName': 'OFLTCP', 'lat': 13.0240695, 'long': 77.6928401 },
-      { 'storeName': 'OFLECTN', 'lat': 12.8185795, 'long': 77.6520784 },
-      { 'storeName': 'OFLHBL', 'lat': 13.0559812, 'long': 77.593941 },
-      { 'storeName': 'OFLBWR', 'lat': 12.9691559, 'long': 77.739599 },
-      { 'storeName': 'OFLHSR', 'lat': 12.9183666, 'long': 77.5793797 },
-    ];
+    const defaultStores = [];
 
     const list = Array.isArray( req.body?.stores ) && req.body.stores.length ? req.body.stores : defaultStores;
 
@@ -4506,3 +5226,4 @@ export async function updateStoreLatLong( req, res ) {
     return res.sendError( e, 500 );
   }
 }
+