bulltrackers-module 1.0.466 → 1.0.468

package/functions/alert-system/index.js

@@ -112,6 +112,13 @@ async function handleAlertTrigger(message, context, config, dependencies) {
     
     logger.log('SUCCESS', `[AlertTrigger] Completed processing ${computationName}: ${processedCount} successful, ${errorCount} errors`);
     
+    // After processing alerts, check for "all clear" notifications for static watchlists
+    // This runs after all alert computations are processed
+    if (processedCount > 0 || results.cids.length > 0) {
+      // Check if any PIs were processed but didn't trigger alerts
+      await checkAndSendAllClearNotifications(db, logger, results.cids, date, config);
+    }
+    
   } catch (error) {
     logger.log('ERROR', '[AlertTrigger] Fatal error processing alert trigger', error);
     throw error; // Re-throw for Pub/Sub retry
@@ -134,12 +141,23 @@ async function handleComputationResultWrite(change, context, config, dependencie
   }
   
   try {
-    // 1. Check if this is an alert computation
-    if (!isAlertComputation(computationName)) {
-      logger.log('DEBUG', `[AlertTrigger] Not an alert computation: ${computationName}`);
+    // 1. Check if this is an alert computation OR PopularInvestorProfileMetrics
+    const isProfileMetrics = computationName === 'PopularInvestorProfileMetrics';
+    if (!isAlertComputation(computationName) && !isProfileMetrics) {
+      logger.log('DEBUG', `[AlertTrigger] Not an alert computation or profile metrics: ${computationName}`);
       return;
     }
     
+    // If it's PopularInvestorProfileMetrics, check for all-clear notifications only
+    if (isProfileMetrics) {
+      const docData = change.after.data();
+      const results = readComputationResults(docData);
+      if (results.cids && results.cids.length > 0) {
+        await checkAndSendAllClearNotifications(db, logger, results.cids, date, config);
+      }
+      return; // Don't process as alert computation
+    }
+    
     const alertType = getAlertTypeByComputation(computationName);
     if (!alertType) {
       logger.log('WARN', `[AlertTrigger] Alert type not found for computation: ${computationName}`);
@@ -188,17 +206,189 @@ async function handleComputationResultWrite(change, context, config, dependencie
     
     logger.log('SUCCESS', `[AlertTrigger] Completed processing ${computationName}: ${processedCount} successful, ${errorCount} errors`);
     
+    // After processing alerts, check for "all clear" notifications for static watchlists
+    if (processedCount > 0 || results.cids.length > 0) {
+      // Check if any PIs were processed but didn't trigger alerts
+      await checkAndSendAllClearNotifications(db, logger, results.cids, date, config);
+    }
+    
   } catch (error) {
     logger.log('ERROR', `[AlertTrigger] Fatal error processing ${computationName}`, error);
     // Don't throw - we don't want to retry the entire computation write
   }
 }
 
+/**
+ * Check for PIs in static watchlists that were processed but didn't trigger alerts
+ * Send "all clear" notifications to users who have these PIs in their static watchlists
+ * This should be called after PopularInvestorProfileMetrics is computed (not just alert computations)
+ */
+async function checkAndSendAllClearNotifications(db, logger, processedPICids, computationDate, config) {
+  try {
+    const today = computationDate || new Date().toISOString().split('T')[0];
+    
+    if (!processedPICids || processedPICids.length === 0) {
+      return; // No PIs to check
+    }
+    
+    // Get all static watchlists that contain any of the processed PIs
+    const watchlistsCollection = config.watchlistsCollection || 'watchlists';
+    const watchlistsSnapshot = await db.collection(watchlistsCollection).get();
+    
+    const usersToNotify = new Map(); // userCid -> Map of piCid -> {username, ...}
+    
+    for (const userDoc of watchlistsSnapshot.docs) {
+      const userCid = userDoc.id;
+      const userListsSnapshot = await userDoc.ref.collection('lists').get();
+      
+      for (const listDoc of userListsSnapshot.docs) {
+        const listData = listDoc.data();
+        
+        // Only check static watchlists
+        if (listData.type !== 'static' || !listData.items || !Array.isArray(listData.items)) {
+          continue;
+        }
+        
+        // Check if any processed PI is in this watchlist
+        for (const item of listData.items) {
+          const piCid = Number(item.cid);
+          if (processedPICids.includes(piCid)) {
+            // Check if this PI triggered any alerts today
+            const hasAlerts = await checkIfPIHasAlertsToday(db, userCid, piCid, today);
+            
+            if (!hasAlerts) {
+              // No alerts triggered - send "all clear" notification
+              if (!usersToNotify.has(userCid)) {
+                usersToNotify.set(userCid, new Map());
+              }
+              usersToNotify.get(userCid).set(piCid, {
+                cid: piCid,
+                username: item.username || `PI-${piCid}`
+              });
+            }
+          }
+        }
+      }
+    }
+    
+    // Send notifications to all users
+    let totalNotifications = 0;
+    for (const [userCid, pisMap] of usersToNotify.entries()) {
+      for (const [piCid, pi] of pisMap.entries()) {
+        await sendAllClearNotification(db, logger, userCid, pi.cid, pi.username, today);
+        totalNotifications++;
+      }
+    }
+    
+    if (totalNotifications > 0) {
+      logger.log('INFO', `[checkAndSendAllClearNotifications] Sent ${totalNotifications} all-clear notifications to ${usersToNotify.size} users`);
+    }
+    
+  } catch (error) {
+    logger.log('ERROR', `[checkAndSendAllClearNotifications] Error checking all-clear notifications`, error);
+    // Don't throw - this is a non-critical feature
+  }
+}
+
+/**
+ * Check if a PI has any alerts for a user today
+ */
+async function checkIfPIHasAlertsToday(db, userCid, piCid, date) {
+  try {
+    const alertsRef = db.collection('user_alerts')
+      .doc(String(userCid))
+      .collection('alerts');
+    
+    // Check if there are any alerts for this PI today
+    const todayStart = new Date(date);
+    todayStart.setHours(0, 0, 0, 0);
+    const todayEnd = new Date(date);
+    todayEnd.setHours(23, 59, 59, 999);
+    
+    const snapshot = await alertsRef
+      .where('piCid', '==', Number(piCid))
+      .where('computationDate', '==', date)
+      .limit(1)
+      .get();
+    
+    return !snapshot.empty;
+  } catch (error) {
+    // If we can't check, assume there are alerts (safer)
+    return true;
+  }
+}
+
+/**
+ * Send an "all clear" notification to a user
+ */
+async function sendAllClearNotification(db, logger, userCid, piCid, piUsername, date) {
+  try {
+    const { FieldValue } = require('@google-cloud/firestore');
+    
+    // Check if we already sent an all-clear notification for this PI today
+    const existingRef = db.collection('user_alerts')
+      .doc(String(userCid))
+      .collection('alerts')
+      .where('piCid', '==', Number(piCid))
+      .where('alertType', '==', 'all_clear')
+      .where('computationDate', '==', date)
+      .limit(1);
+    
+    const existingSnapshot = await existingRef.get();
+    if (!existingSnapshot.empty) {
+      // Already sent notification for this PI today
+      return;
+    }
+    
+    // Create the notification using the notification system
+    const notificationRef = db.collection('user_notifications')
+      .doc(String(userCid))
+      .collection('notifications')
+      .doc();
+    
+    await notificationRef.set({
+      id: notificationRef.id,
+      type: 'alert',
+      title: 'All Clear',
+      message: `${piUsername} was processed, all clear today!`,
+      piCid: Number(piCid),
+      piUsername: piUsername,
+      alertType: 'all_clear',
+      computationDate: date,
+      read: false,
+      createdAt: FieldValue.serverTimestamp(),
+      metadata: {
+        message: 'User was processed, all clear today!'
+      }
+    });
+    
+    // Update notification counter
+    const counterRef = db.collection('user_notifications')
+      .doc(String(userCid))
+      .collection('counters')
+      .doc(date);
+    
+    await counterRef.set({
+      date: date,
+      unreadCount: FieldValue.increment(1),
+      totalCount: FieldValue.increment(1),
+      lastUpdated: FieldValue.serverTimestamp()
+    }, { merge: true });
+    
+    logger.log('INFO', `[sendAllClearNotification] Sent all-clear notification to user ${userCid} for PI ${piCid}`);
+    
+  } catch (error) {
+    logger.log('ERROR', `[sendAllClearNotification] Error sending all-clear notification`, error);
+    // Don't throw - this is non-critical
+  }
+}
+
 /**
  * Export the trigger handlers
  */
 module.exports = {
   handleAlertTrigger,
-  handleComputationResultWrite
+  handleComputationResultWrite,
+  checkAndSendAllClearNotifications
 };
 

package/functions/generic-api/user-api/helpers/watchlist_helpers.js

@@ -592,15 +592,22 @@ async function publishWatchlistVersion(req, res, dependencies, config) {
             name: watchlistData.name,
             type: watchlistData.type,
             description: watchlistData.dynamicConfig?.description || '',
-            // Snapshot the current state
-            items: watchlistData.items ? JSON.parse(JSON.stringify(watchlistData.items)) : undefined,
-            dynamicConfig: watchlistData.dynamicConfig ? JSON.parse(JSON.stringify(watchlistData.dynamicConfig)) : undefined,
             snapshotAt: FieldValue.serverTimestamp(),
             copyCount: 0,
             createdAt: watchlistData.createdAt,
             isImmutable: true // Public versions are immutable
         };
         
+        // Only include items if it's a static watchlist
+        if (watchlistData.type === 'static' && watchlistData.items) {
+            versionData.items = JSON.parse(JSON.stringify(watchlistData.items));
+        }
+        
+        // Only include dynamicConfig if it's a dynamic watchlist
+        if (watchlistData.type === 'dynamic' && watchlistData.dynamicConfig) {
+            versionData.dynamicConfig = JSON.parse(JSON.stringify(watchlistData.dynamicConfig));
+        }
+        
         // Store version in versions subcollection
         const versionRef = db.collection('public_watchlists')
             .doc(id)

package/package.json

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