bulltrackers-module 1.0.572 → 1.0.574

package/functions/alert-system/helpers/alert_helpers.js

@@ -212,14 +212,14 @@ async function findSubscriptionsForPI(db, logger, piCid, alertTypeId, computatio
         return subscriptions;
       }
     } else {
-      logger.log('WARN', `[findSubscriptionsForPI] WatchlistMembershipData/${computationDate} not found, falling back to scanning all watchlists`);
-      // Fallback to legacy method if membership data doesn't exist
-      return await findSubscriptionsForPILegacy(db, logger, piCid, alertTypeId, configKey);
+      logger.log('WARN', `[findSubscriptionsForPI] WatchlistMembershipData/${computationDate} not found, returning existing subscriptions (dev overrides only)`);
+      // Return subscriptions array which may contain dev overrides
+      return subscriptions;
     }
   } catch (error) {
     logger.log('ERROR', `[findSubscriptionsForPI] Error loading WatchlistMembershipData: ${error.message}`);
-    // Fallback to legacy method on error
-    return await findSubscriptionsForPILegacy(db, logger, piCid, alertTypeId, configKey);
+    // Return subscriptions array which may contain dev overrides
+    return subscriptions;
   }
   
   // Step 2: For each user, read their watchlists from SignedInUsers/{cid}/watchlists
@@ -298,51 +298,6 @@ async function findSubscriptionsForPI(db, logger, piCid, alertTypeId, computatio
   return subscriptions;
 }
 
-/**
- * Legacy fallback method - scans all watchlists (used if WatchlistMembershipData is not available)
- */
-async function findSubscriptionsForPILegacy(db, logger, piCid, alertTypeId, configKey) {
-  const subscriptions = [];
-  
-  logger.log('INFO', `[findSubscriptionsForPILegacy] Using legacy method to find subscriptions for PI ${piCid}`);
-  
-  // Get all watchlists from legacy path
-  const watchlistsCollection = db.collection('watchlists');
-  const watchlistsSnapshot = await watchlistsCollection.get();
-  
-  for (const userDoc of watchlistsSnapshot.docs) {
-    const userCid = Number(userDoc.id);
-    const userListsSnapshot = await userDoc.ref.collection('lists').get();
-    
-    for (const listDoc of userListsSnapshot.docs) {
-      const listData = listDoc.data();
-      
-      // Check static watchlists
-      if (listData.type === 'static' && listData.items && Array.isArray(listData.items)) {
-        for (const item of listData.items) {
-          if (Number(item.cid) === Number(piCid)) {
-            const isTestProbe = alertTypeId === 'TestSystemProbe';
-            const isEnabled = item.alertConfig && item.alertConfig[configKey] === true;
-            
-            if (isTestProbe || isEnabled) {
-              subscriptions.push({
-                userCid: userCid,
-                piCid: piCid,
-                piUsername: item.username || `PI-${piCid}`,
-                watchlistId: listDoc.id,
-                watchlistName: listData.name || 'Unnamed Watchlist',
-                alertConfig: item.alertConfig
-              });
-              break;
-            }
-          }
-        }
-      }
-    }
-  }
-  
-  return subscriptions;
-}
 
 /**
  * Check if alert should trigger based on thresholds

package/functions/generic-api/user-api/helpers/data/computation_helpers.js

@@ -162,25 +162,63 @@ async function getUserComputations(req, res, dependencies, config) {
         let datesToCheck = [today];
         
         if (mode === 'latest') {
+            // Use same logic as data-status: search backwards and verify user exists
+            // This ensures we find the same date that data-status found
             const firstCompName = computationNames[0];
-            const latestDate = await findLatestComputationDate(
-                db, 
-                insightsCollection,
-                resultsSub,
-                compsSub,
-                category, 
-                firstCompName, 
-                effectiveCid, 
-                7
-            );
+            const maxDaysBack = 30; // Match data-status search window
+            let foundDate = null;
             
-            if (latestDate) {
-                datesToCheck = [latestDate];
-                if (latestDate !== today) {
-                    logger.log('INFO', `[getUserComputations] Using fallback date ${latestDate} for effective CID ${effectiveCid} (today: ${today})`);
+            for (let daysBack = 0; daysBack < maxDaysBack; daysBack++) {
+                const checkDate = new Date();
+                checkDate.setDate(checkDate.getDate() - daysBack);
+                const dateStr = checkDate.toISOString().split('T')[0];
+                
+                try {
+                    // Check if computation document exists for this date
+                    const computationRef = db.collection(insightsCollection)
+                        .doc(dateStr)
+                        .collection(resultsSub)
+                        .doc(category)
+                        .collection(compsSub)
+                        .doc(firstCompName);
+                    
+                    const computationDoc = await computationRef.get();
+                    
+                    if (computationDoc.exists) {
+                        // Computation exists, verify user is in it (same as data-status)
+                        const { found } = await checkPiInComputationDate(
+                            db,
+                            insightsCollection,
+                            resultsSub,
+                            compsSub,
+                            category,
+                            firstCompName,
+                            dateStr,
+                            String(effectiveCid),
+                            logger
+                        );
+                        
+                        if (found) {
+                            foundDate = dateStr;
+                            if (dateStr !== today) {
+                                logger.log('INFO', `[getUserComputations] Using fallback date ${foundDate} for effective CID ${effectiveCid} (today: ${today})`);
+                            } else {
+                                logger.log('INFO', `[getUserComputations] Found computation for effective CID ${effectiveCid} on today's date`);
+                            }
+                            break; // Found user, stop searching
+                        }
+                    }
+                } catch (error) {
+                    // Continue to next date if error
+                    logger.log('DEBUG', `[getUserComputations] Error checking date ${dateStr}:`, error.message);
+                    continue;
                 }
+            }
+            
+            if (foundDate) {
+                datesToCheck = [foundDate];
             } else {
-                logger.log('WARN', `[getUserComputations] No computation data found for CID ${effectiveCid} in last 7 days. Frontend will use fallback.`);
+                logger.log('WARN', `[getUserComputations] No computation data found for CID ${effectiveCid} in last ${maxDaysBack} days. Frontend will use fallback.`);
                 return res.status(200).json({
                     status: 'success',
                     userCid: String(effectiveCid),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bulltrackers-module",
-  "version": "1.0.572",
+  "version": "1.0.574",
   "description": "Helper Functions for Bulltrackers.",
   "main": "index.js",
   "files": [