bulltrackers-module 1.0.554 → 1.0.555

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

@@ -18,7 +18,7 @@ async function processAlertForPI(db, logger, piCid, alertType, computationMetada
     
     // 2. Find all users subscribed to this PI and alert type
     // Use computationName (e.g., 'RiskScoreIncrease') to map to alertConfig keys
-    const subscriptions = await findSubscriptionsForPI(db, logger, piCid, alertType.computationName);
+    const subscriptions = await findSubscriptionsForPI(db, logger, piCid, alertType.computationName, computationDate, dependencies);
     
     if (subscriptions.length === 0) {
       logger.log('INFO', `[processAlertForPI] No subscriptions found for PI ${piCid}, alert type ${alertType.id}`);
@@ -65,7 +65,6 @@ async function processAlertForPI(db, logger, piCid, alertType, computationMetada
       };
       
       // Use writeWithMigration to write to new path (with legacy fallback)
-      // notifications is a subcollection, so we need isCollection: true and documentId
       const writePromise = writeWithMigration(
         db,
         'signedInUsers',
@@ -92,10 +91,18 @@ async function processAlertForPI(db, logger, piCid, alertType, computationMetada
     // Wait for all notifications to be written
     await Promise.all(notificationPromises);
     
-    // 7. Update global rootdata collection for computation system
-    const { updateAlertHistoryRootData } = require('../../generic-api/user-api/helpers/rootdata/rootdata_aggregation_helpers');
-    const triggeredUserCids = subscriptions.map(s => s.userCid);
-    await updateAlertHistoryRootData(db, logger, piCid, alertType, computationMetadata, computationDate, triggeredUserCids);
+    // 5. Notify the PI themselves if they are a signed-in user (Optional feature)
+    await notifyPIIfSignedIn(db, logger, piCid, alertType, subscriptions.length);
+
+    // 6. Update global rootdata collection for computation system
+    // (Wrap in try-catch to prevent crashing the alert if metrics fail)
+    try {
+        const { updateAlertHistoryRootData } = require('../../generic-api/user-api/helpers/rootdata/rootdata_aggregation_helpers');
+        const triggeredUserCids = subscriptions.map(s => s.userCid);
+        await updateAlertHistoryRootData(db, logger, piCid, alertType, computationMetadata, computationDate, triggeredUserCids);
+    } catch (e) {
+        logger.log('WARN', `[processAlertForPI] Failed to update history rootdata: ${e.message}`);
+    }
     
     logger.log('SUCCESS', `[processAlertForPI] Created ${notificationPromises.length} notifications for PI ${piCid}, alert type ${alertType.id}`);
     
@@ -107,20 +114,19 @@ async function processAlertForPI(db, logger, piCid, alertType, computationMetada
 
 /**
  * Find all users who should receive alerts for a PI and alert type
- * Reads from actual watchlist structure: watchlists/{userCid}/lists/{watchlistId}
+ * Uses WatchlistMembershipData/{date} to find users, then reads watchlists from SignedInUsers/{cid}/watchlists
  */
-async function findSubscriptionsForPI(db, logger, piCid, alertTypeId) {
+async function findSubscriptionsForPI(db, logger, piCid, alertTypeId, computationDate, dependencies = {}) {
   const subscriptions = [];
   
   // Map computation names to watchlist alertConfig keys
-  // The alertTypeId is actually the computation name (e.g., 'RiskScoreIncrease')
   const computationToConfigKey = {
     'RiskScoreIncrease': 'increasedRisk',
     'SignificantVolatility': 'volatilityChanges',
     'NewSectorExposure': 'newSector',
     'PositionInvestedIncrease': 'increasedPositionSize',
     'NewSocialPost': 'newSocialPost',
-    'TestSystemProbe': 'increasedRisk' // Hack: Map to 'increasedRisk' so you receive it if you have Risk alerts on
+    'TestSystemProbe': 'increasedRisk' // Hack: Map to 'increasedRisk' key
   };
   
   const configKey = computationToConfigKey[alertTypeId];
@@ -129,7 +135,121 @@ async function findSubscriptionsForPI(db, logger, piCid, alertTypeId) {
     return subscriptions;
   }
   
-  // Get all watchlists
+  // Step 1: Load WatchlistMembershipData/{date} to find which users have this PI in their watchlist
+  const piCidStr = String(piCid);
+  let userCids = [];
+  
+  try {
+    const membershipRef = db.collection('WatchlistMembershipData').doc(computationDate);
+    const membershipDoc = await membershipRef.get();
+    
+    if (membershipDoc.exists) {
+      const membershipData = membershipDoc.data();
+      const piMembership = membershipData[piCidStr];
+      
+      if (piMembership && piMembership.users && Array.isArray(piMembership.users)) {
+        userCids = piMembership.users.map(cid => String(cid));
+        logger.log('INFO', `[findSubscriptionsForPI] Found ${userCids.length} users with PI ${piCid} in watchlist from WatchlistMembershipData/${computationDate}`);
+      } else {
+        logger.log('INFO', `[findSubscriptionsForPI] No users found for PI ${piCid} in WatchlistMembershipData/${computationDate}`);
+        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);
+    }
+  } 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);
+  }
+  
+  // Step 2: For each user, read their watchlists from SignedInUsers/{cid}/watchlists
+  const { readWithMigration } = require('../../generic-api/user-api/helpers/core/path_resolution_helpers');
+  const { collectionRegistry } = dependencies;
+  const config = dependencies.config || {};
+  
+  for (const userCidStr of userCids) {
+    try {
+      const userCid = Number(userCidStr);
+      
+      // Read all watchlists for this user from new path
+      const watchlistsResult = await readWithMigration(
+        db,
+        'signedInUsers',
+        'watchlists',
+        { cid: userCid },
+        {
+          isCollection: true,
+          dataType: 'watchlists',
+          config,
+          logger,
+          collectionRegistry: collectionRegistry
+        }
+      );
+      
+      if (!watchlistsResult) {
+        continue;
+      }
+      
+      // Get watchlists from snapshot or data
+      let watchlists = [];
+      if (watchlistsResult.snapshot && !watchlistsResult.snapshot.empty) {
+        watchlists = watchlistsResult.snapshot.docs.map(doc => ({
+          id: doc.id,
+          ...doc.data()
+        }));
+      } else if (watchlistsResult.data) {
+        // If it's a single document, wrap it
+        watchlists = [watchlistsResult.data];
+      }
+      
+      // Step 3: Check each watchlist for the PI and alert config
+      for (const watchlistData of watchlists) {
+        if (watchlistData.type === 'static' && watchlistData.items && Array.isArray(watchlistData.items)) {
+          for (const item of watchlistData.items) {
+            if (Number(item.cid) === Number(piCid)) {
+              // Check if this alert type is enabled
+              const isTestProbe = alertTypeId === 'TestSystemProbe';
+              const isEnabled = item.alertConfig && item.alertConfig[configKey] === true;
+              
+              // If it's the probe OR the user explicitly enabled it
+              if (isTestProbe || isEnabled) {
+                subscriptions.push({
+                  userCid: userCid,
+                  piCid: piCid,
+                  piUsername: item.username || `PI-${piCid}`,
+                  watchlistId: watchlistData.id || watchlistData.watchlistId,
+                  watchlistName: watchlistData.name || 'Unnamed Watchlist',
+                  alertConfig: item.alertConfig
+                });
+                break; // Found in this watchlist, no need to check other items
+              }
+            }
+          }
+        }
+      }
+    } catch (error) {
+      logger.log('WARN', `[findSubscriptionsForPI] Error reading watchlists for user ${userCidStr}: ${error.message}`);
+      // Continue with next user
+      continue;
+    }
+  }
+  
+  logger.log('INFO', `[findSubscriptionsForPI] Found ${subscriptions.length} subscriptions for PI ${piCid}, alert type ${alertTypeId}`);
+  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();
   
@@ -144,8 +264,10 @@ async function findSubscriptionsForPI(db, logger, piCid, alertTypeId) {
       if (listData.type === 'static' && listData.items && Array.isArray(listData.items)) {
         for (const item of listData.items) {
           if (Number(item.cid) === Number(piCid)) {
-            // Check if this alert type is enabled for this PI in this watchlist
-            if (item.alertConfig && item.alertConfig[configKey] === true) {
+            const isTestProbe = alertTypeId === 'TestSystemProbe';
+            const isEnabled = item.alertConfig && item.alertConfig[configKey] === true;
+            
+            if (isTestProbe || isEnabled) {
               subscriptions.push({
                 userCid: userCid,
                 piCid: piCid,
@@ -154,19 +276,14 @@ async function findSubscriptionsForPI(db, logger, piCid, alertTypeId) {
                 watchlistName: listData.name || 'Unnamed Watchlist',
                 alertConfig: item.alertConfig
               });
-              break; // Found in this watchlist, no need to check other items
+              break;
             }
           }
         }
       }
-      
-      // Check dynamic watchlists - if the PI matches the computation result, check alertConfig
-      // Note: Dynamic watchlists are handled separately as they're based on computation results
-      // For now, we only process static watchlists here
     }
   }
   
-  logger.log('INFO', `[findSubscriptionsForPI] Found ${subscriptions.length} subscriptions for PI ${piCid}, alert type ${alertTypeId}`);
   return subscriptions;
 }
 
@@ -178,10 +295,6 @@ function shouldTriggerAlert(subscription, alertTypeId) {
   if (!subscription.thresholds || Object.keys(subscription.thresholds).length === 0) {
     return true;
   }
-  
-  // Threshold checking logic would go here
-  // For now, we'll implement basic threshold checks in the trigger function
-  // This is a placeholder for future enhancement
   return true;
 }
 
@@ -195,9 +308,7 @@ async function getPIUsername(db, piCid) {
     const { getPIUsernameFromMasterList } = require('../../generic-api/user-api/helpers/core/user_status_helpers');
     const username = await getPIUsernameFromMasterList(db, piCid, null, null);
     
-    if (username) {
-      return username;
-    }
+    if (username) return username;
     
     // Fallback: try to get from any subscription
     const subscriptionsSnapshot = await db.collection('watchlist_subscriptions')
@@ -221,18 +332,14 @@ async function getPIUsername(db, piCid) {
  */
 async function notifyPIIfSignedIn(db, logger, piCid, alertType, alertCount) {
   try {
-    // Check if this PI is a signed-in user
-    const userRef = db.collection('signed_in_users').doc(String(piCid));
+    const userRef = db.collection('signedInUsers').doc(String(piCid));
     const userDoc = await userRef.get();
     
-    if (!userDoc.exists) {
-      return; // Not a signed-in user
-    }
-    
-    // Create a notification for the PI
-    const notificationRef = db.collection('user_alerts')
+    if (!userDoc.exists) return; 
+
+    const notificationRef = db.collection('signedInUsers')
       .doc(String(piCid))
-      .collection('triggered')
+      .collection('user_alerts_metrics') // Changed from user_alerts/triggered to avoid collision
       .doc(`trigger_${Date.now()}_${alertType.id}`);
     
     await notificationRef.set({
@@ -246,8 +353,8 @@ async function notifyPIIfSignedIn(db, logger, piCid, alertType, alertCount) {
     
     logger.log('INFO', `[notifyPIIfSignedIn] Notified PI ${piCid} that ${alertCount} users received ${alertType.id} alert`);
   } catch (error) {
-    logger.log('WARN', `[notifyPIIfSignedIn] Error notifying PI ${piCid}`, error);
-    // Don't throw - this is optional
+    // Silent fail - non-critical
+    logger.log('DEBUG', `[notifyPIIfSignedIn] Skipped for PI ${piCid}`);
   }
 }
 
@@ -290,25 +397,17 @@ function tryDecompress(data) {
 
 /**
  * Read and decompress computation results
- * Handles two result formats:
- * 1. { cids: [...], metadata: {...} } - Global metadata
- * 2. { cids: [...], userId1: {...}, userId2: {...} } - Per-user metadata
  */
 function readComputationResults(docData) {
   try {
-    // Try to decompress if needed
     const decompressed = tryDecompress(docData);
     
-    // If decompressed is an object with cids, return it
     if (decompressed && typeof decompressed === 'object') {
-      // Handle structure: { cids: [...], metadata: {...} }
       if (decompressed.cids && Array.isArray(decompressed.cids)) {
-        // Check if there's per-user data (keys that are numbers)
         const userDataKeys = Object.keys(decompressed)
           .filter(key => key !== 'cids' && key !== 'metadata' && /^\d+$/.test(key));
         
         if (userDataKeys.length > 0) {
-          // Format 2: Per-user metadata stored as { cids: [...], userId: {...} }
           return {
             cids: decompressed.cids,
             perUserData: userDataKeys.reduce((acc, key) => {
@@ -318,7 +417,6 @@ function readComputationResults(docData) {
             globalMetadata: decompressed.metadata || {}
           };
         } else {
-          // Format 1: Global metadata
           return {
             cids: decompressed.cids,
             metadata: decompressed.metadata || {}
@@ -326,7 +424,6 @@ function readComputationResults(docData) {
         }
       }
       
-      // If it's a flat object with CID keys but no cids array, extract them
       const cids = Object.keys(decompressed)
         .filter(key => /^\d+$/.test(key))
         .map(key => Number(key));
@@ -344,7 +441,6 @@ function readComputationResults(docData) {
         };
       }
     }
-    
     return { cids: [], metadata: {}, perUserData: {} };
   } catch (error) {
     console.error('[readComputationResults] Error reading results', error);
@@ -357,9 +453,7 @@ function readComputationResults(docData) {
  */
 async function readComputationResultsWithShards(db, docData, docRef) {
   try {
-    // Check if data is sharded
     if (docData._sharded === true && docData._shardCount) {
-      // Data is stored in shards - read all shards and merge
       const shardsCol = docRef.collection('_shards');
       const shardsSnapshot = await shardsCol.get();
       
@@ -373,8 +467,6 @@ async function readComputationResultsWithShards(db, docData, docRef) {
         return readComputationResults(mergedData);
       }
     }
-    
-    // Data is in the main document (compressed or not)
     return readComputationResults(docData);
   } catch (error) {
     console.error('[readComputationResultsWithShards] Error reading sharded results', error);
@@ -387,6 +479,6 @@ module.exports = {
   findSubscriptionsForPI,
   getPIUsername,
   readComputationResults,
-  readComputationResultsWithShards
-};
-
+  readComputationResultsWithShards,
+  notifyPIIfSignedIn // Exporting this as well since it's defined
+};

package/package.json

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