tango-app-api-trax 3.8.26 → 3.8.28

package/package.json

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

package/src/controllers/internalTrax.controller.js

@@ -4389,6 +4389,20 @@ export async function recurringFlagAlert( req, res ) {
 
       if ( !recipients.length ) return;
 
+      // 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( {
@@ -4413,7 +4427,12 @@ export async function recurringFlagAlert( req, res ) {
         // 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 ) {
+
+        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,
@@ -4437,14 +4456,19 @@ export async function recurringFlagAlert( req, res ) {
             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,
-          lastRunAIFlaggedDate: t.lastRunAIFlaggedDate,
-          sopFired,
-          runAIFired,
-        } );
       }
     } ) );
 
@@ -4648,10 +4672,12 @@ function getLastWeekRange( ref = dayjs() ) {
   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' );
-  const weekStart = thisMonday.subtract( 7, 'day' );
-  const weekEnd = thisMonday.subtract( 1, 'day' );
-  const prevWeekStart = weekStart.subtract( 7, 'day' );
-  const prevWeekEnd = weekStart.subtract( 1, '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' ),
@@ -4713,26 +4739,33 @@ async function aggregateWeeklyFlagsByStore( weekStart, weekEnd ) {
 }
 
 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,
-      firedInWeek: {
-        $size: {
-          $filter: {
-            input: { $ifNull: [ '$emailHistory', [] ] },
-            as: 'd',
-            cond: { $and: [ { $gte: [ '$$d', weekStart ] }, { $lte: [ '$$d', weekEnd ] } ] },
-          },
+      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' },
-      count: { $sum: '$firedInWeek' },
+      uniqueDates: { $addToSet: '$datesInWeek' },
+    } },
+    { $project: {
+      _id: 1,
+      storeName: 1,
+      count: { $size: '$uniqueDates' },
     } },
   ] );
   const map = new Map();
@@ -4747,180 +4780,382 @@ async function aggregateWeeklyRecurringByStore( weekStart, weekEnd ) {
   return map;
 }
 
-function buildWeeklyWrapExcel( header, perStoreRows ) {
+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 ID', key: 'storeId', width: 18 },
     { 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', key: 'timeFlag', width: 16 },
-    { header: 'Run AI Flags', key: 'runAIFlag', 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 },
-    { header: 'Total Flags', key: 'totalFlags', width: 14 },
-    { header: 'Last Week Total', key: 'prevTotal', width: 18 },
-    { header: 'WoW %', key: 'wow', width: 12 },
   ];
   sheet.getRow( 3 ).font = { bold: true };
   sheet.getRow( 3 ).fill = { type: 'pattern', pattern: 'solid', fgColor: { argb: 'FFF1F5F9' } };
-  for ( const r of perStoreRows ) sheet.addRow( r );
+  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' );
 
-    // TEMP: static recipient for dev. Replace with client-config lookup later.
-    const STATIC_RECIPIENT = 'gopisjkg@gmail.com';
+    // 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.
-    const [ flagsThis, flagsPrev, recurThis, recurPrev ] = await Promise.all( [
+    // 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 ),
     ] );
 
-    // Compute per-client highest flagged store and highest recurring flagged store (this week).
-    const topByClient = new Map(); // clientId -> { topFlag, topRecurring }
-    const upsertTop = ( client, key, candidate ) => {
-      if ( !topByClient.has( client ) ) topByClient.set( client, { topFlag: null, topRecurring: null } );
-      const entry = topByClient.get( client );
-      if ( !entry[key] || candidate.value > entry[key].value ) entry[key] = candidate;
-    };
-    for ( const v of flagsThis.values() ) {
-      upsertTop( v.client_id, 'topFlag', { storeId: v.store_id, storeName: v.storeName, value: v.totalFlags } );
-    }
-    for ( const v of recurThis.values() ) {
-      upsertTop( v.client_id, 'topRecurring', { storeId: v.store_id, storeName: v.storeName, value: v.count } );
-    }
-
     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 and email the static recipient.
+    // 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() ) clientIds.add( v.client_id );
-    for ( const v of recurThis.values() ) clientIds.add( v.client_id );
+    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 {
-        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 = [];
-
-        // Iterate only stores belonging to this client (key prefix match).
-        const clientPrefix = `${clientId}::`;
-        const clientStoreKeys = new Set();
-        for ( const k of flagsThis.keys() ) if ( k.startsWith( clientPrefix ) ) clientStoreKeys.add( k );
-        for ( const k of flagsPrev.keys() ) if ( k.startsWith( clientPrefix ) ) clientStoreKeys.add( k );
-        for ( const k of recurThis.keys() ) if ( k.startsWith( clientPrefix ) ) clientStoreKeys.add( k );
-
-        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 ( storeTotal > 0 || prevStoreTotal > 0 ) {
-            const w = computeWow( storeTotal, prevStoreTotal );
-            excelRows.push( {
-              storeId: ( cur?.store_id || prev?.store_id || k.slice( clientPrefix.length ) ),
-              storeName: cur?.storeName || prev?.storeName || '',
-              questionFlag: cur?.questionFlag || 0,
-              timeFlag: cur?.timeFlag || 0,
-              runAIFlag: cur?.runAIFlag || 0,
-              recurringFlag: storeRecurring,
-              totalFlags: storeTotal,
-              prevTotal: prevStoreTotal,
-              wow: w.value ? `${w.direction === 'up' ? '+' : '-'}${w.value}` : '0%',
-            } );
-          }
+        // 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 ), email: { $in: [ 'gopisjkg@gmail.com', 'sh9628hs@gmail.com' ] }, 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;
         }
 
-        if ( totalFlags === 0 && prevTotalFlags === 0 ) return; // skip silent clients
+        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;
+            }
 
-        const top = topByClient.get( clientId ) || { topFlag: null, topRecurring: null };
-        let highestFlaggedStoreWow = { value: '', direction: 'up' };
-        if ( top.topFlag ) {
-          const prev = flagsPrev.get( `${clientId}::${top.topFlag.storeId}` );
-          highestFlaggedStoreWow = computeWow( top.topFlag.value, prev?.totalFlags || 0 );
-        }
-        let highestRecurringStoreWow = { value: '', direction: 'up' };
-        if ( top.topRecurring ) {
-          const prev = recurPrev.get( `${clientId}::${top.topRecurring.storeId}` );
-          highestRecurringStoreWow = computeWow( top.topRecurring.value, prev?.count || 0 );
-        }
+            // 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 );
+            }
 
-        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: top.topFlag?.storeName || top.topFlag?.storeId || '--',
-          highestFlaggedStoreWow,
-          highestRecurringStore: top.topRecurring?.storeName || top.topRecurring?.storeId || '--',
-          highestRecurringStoreWow,
-          attachmentName: `${excelHeader}.xlsx`,
-          attachmentSize: `${sizeKb} KB`,
-          domain: flagDomain,
-        };
+            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 };
+              }
+            }
 
-        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})`;
+            if ( totalFlags === 0 && prevTotalFlags === 0 ) {
+              continue; // user has nothing to report this week
+            }
 
-        sendEmailWithSES( STATIC_RECIPIENT, subject, html, attachment, sourceEmail );
-        sentSummary.push( { recipient: STATIC_RECIPIENT, clientId, totalFlags } );
+            // 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 } );
       }

package/src/controllers/mobileTrax.controller.js

@@ -467,7 +467,7 @@ export async function startTask( req, res ) {
     } );
     const getUpdatedTask = await processedTask.aggregate( findQuery );
 
-
+    let cdnurl = JSON.parse( process.env.CDNURL );
     if ( !( task.checkListFrom && task.checkListFrom == 'api' ) ) {
       // const bucket = JSON.parse( process.env.BUCKET );
       await Promise.all(