bulltrackers-module 1.0.678 → 1.0.679

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

@@ -16,12 +16,53 @@ const storage = new Storage(); // Singleton GCS Client
  */
 async function processAlertForPI(db, logger, piCid, alertType, computationMetadata, computationDate, dependencies = {}) {
   try {
+    // [FIX] Check if computation date is earlier than today (backfill protection)
+    const today = new Date().toISOString().split('T')[0]; // YYYY-MM-DD format
+    const isHistoricalData = computationDate < today;
+    
+    // If it's historical data, check if this alert already exists
+    if (isHistoricalData) {
+      // Check if we've already created alerts for this PI/date/alertType combination
+      const existingAlertsSnapshot = await db.collection('SignedInUsers')
+        .doc('_metadata') // Use metadata doc to track processed alerts
+        .collection('processed_alerts')
+        .where('piCid', '==', Number(piCid))
+        .where('computationDate', '==', computationDate)
+        .where('alertType', '==', alertType.id)
+        .limit(1)
+        .get();
+      
+      if (!existingAlertsSnapshot.empty) {
+        logger.log('INFO', `[processAlertForPI] Skipping duplicate alert for historical data: PI ${piCid}, date ${computationDate}, alert type ${alertType.id}`);
+        return;
+      }
+      
+      logger.log('WARN', `[processAlertForPI] Processing alert for historical data (backfill): PI ${piCid}, date ${computationDate}, alert type ${alertType.id}. This alert will only be sent to developers.`);
+    }
+    
     // 1. Get PI username from rankings or subscriptions
     const piUsername = await getPIUsername(db, piCid);
     
     // 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, computationDate, dependencies);
+    let subscriptions = await findSubscriptionsForPI(db, logger, piCid, alertType.computationName, computationDate, dependencies);
+    
+    // [FIX] If it's historical data, only send to developer accounts
+    if (isHistoricalData) {
+      const { isDeveloper } = require('../../api-v2/helpers/data-fetchers/firestore.js');
+      
+      // Filter subscriptions to only include developers
+      const devSubscriptions = [];
+      for (const subscription of subscriptions) {
+        const isDev = await isDeveloper(db, String(subscription.userCid));
+        if (isDev) {
+          devSubscriptions.push(subscription);
+        }
+      }
+      
+      subscriptions = devSubscriptions;
+      logger.log('INFO', `[processAlertForPI] Historical data: Filtered to ${subscriptions.length} developer subscriptions for PI ${piCid}, alert type ${alertType.id}`);
+    }
     
     if (subscriptions.length === 0) {
       logger.log('INFO', `[processAlertForPI] No subscriptions found for PI ${piCid}, alert type ${alertType.id}`);
@@ -38,8 +79,24 @@ async function processAlertForPI(db, logger, piCid, alertType, computationMetada
     const config = dependencies.config || {};
     const notificationPromises = [];
     
+    // Check watchlistAlerts preference for each user
+    const { manageNotificationPreferences } = require('../../api-v2/helpers/data-fetchers/firestore.js');
+    
     for (const subscription of subscriptions) {
       const userCid = subscription.userCid;
+      
+      // [FIX] Check user's watchlistAlerts preference before creating alert
+      try {
+        const prefs = await manageNotificationPreferences(db, userCid, 'get');
+        if (!prefs.watchlistAlerts) {
+          logger.log('DEBUG', `[processAlertForPI] User ${userCid} has watchlistAlerts disabled, skipping alert`);
+          continue; // Skip this user
+        }
+      } catch (prefError) {
+        logger.log('WARN', `[processAlertForPI] Error checking watchlistAlerts preference for user ${userCid}: ${prefError.message}`);
+        // Continue anyway - fail open for important alerts
+      }
+      
       const notificationId = `alert_${Date.now()}_${userCid}_${piCid}_${Math.random().toString(36).substring(2, 9)}`;
       
       const notificationData = {
@@ -129,6 +186,28 @@ async function processAlertForPI(db, logger, piCid, alertType, computationMetada
     
     logger.log('SUCCESS', `[processAlertForPI] Created ${notificationPromises.length} notifications for PI ${piCid}, alert type ${alertType.id}`);
     
+    // [FIX] Mark alert as processed to prevent duplicates on backfill
+    if (isHistoricalData) {
+      try {
+        await db.collection('SignedInUsers')
+          .doc('_metadata')
+          .collection('processed_alerts')
+          .doc(`${piCid}_${computationDate}_${alertType.id}`)
+          .set({
+            piCid: Number(piCid),
+            computationDate: computationDate,
+            alertType: alertType.id,
+            alertTypeName: alertType.name,
+            processedAt: FieldValue.serverTimestamp(),
+            notificationsSent: notificationPromises.length
+          });
+        logger.log('INFO', `[processAlertForPI] Marked historical alert as processed: PI ${piCid}, date ${computationDate}, alert type ${alertType.id}`);
+      } catch (markError) {
+        logger.log('WARN', `[processAlertForPI] Failed to mark alert as processed: ${markError.message}`);
+        // Don't throw - this is non-critical
+      }
+    }
+    
   } catch (error) {
     logger.log('ERROR', `[processAlertForPI] Error processing alert for PI ${piCid}`, error);
     throw error;
@@ -285,8 +364,29 @@ async function findSubscriptionsForPI(db, logger, piCid, alertTypeId, computatio
               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) {
+              // [FIX] For TestSystemProbe, check user's testAlerts preference
+              let shouldSendAlert = false;
+              if (isTestProbe) {
+                // Check if user has testAlerts enabled in their notification preferences
+                try {
+                  const { manageNotificationPreferences } = require('../../api-v2/helpers/data-fetchers/firestore.js');
+                  const prefs = await manageNotificationPreferences(db, userCid, 'get');
+                  shouldSendAlert = prefs.testAlerts === true;
+                  
+                  if (!shouldSendAlert) {
+                    logger.log('DEBUG', `[findSubscriptionsForPI] User ${userCid} has testAlerts disabled, skipping TestSystemProbe alert`);
+                  }
+                } catch (prefError) {
+                  logger.log('WARN', `[findSubscriptionsForPI] Error checking testAlerts preference for user ${userCid}: ${prefError.message}`);
+                  // Default to not sending test alerts if we can't check preferences
+                  shouldSendAlert = false;
+                }
+              } else {
+                // For non-test alerts, use normal alert config check
+                shouldSendAlert = isEnabled;
+              }
+              
+              if (shouldSendAlert) {
                 subscriptions.push({
                   userCid: userCid,
                   piCid: piCid,

package/functions/api-v2/helpers/notification_helpers.js

@@ -18,6 +18,15 @@ const { FieldValue } = require('@google-cloud/firestore');
  */
 async function notifyTaskEngineComplete(db, logger, userCid, requestId, username, success, errorMessage, options = {}) {
     try {
+        // [FIX] Check user's notification preferences before sending
+        const { manageNotificationPreferences } = require('./data-fetchers/firestore.js');
+        const prefs = await manageNotificationPreferences(db, userCid, 'get');
+        
+        if (!prefs.syncProcesses) {
+            logger?.log('DEBUG', `[notifyTaskEngineComplete] User ${userCid} has syncProcesses disabled, skipping notification`);
+            return;
+        }
+        
         const notificationData = {
             type: 'sync',
             subType: 'complete',
@@ -42,6 +51,29 @@ async function notifyTaskEngineComplete(db, logger, userCid, requestId, username
             .doc(requestId)
             .set(notificationData);
 
+        // [FIX] Clean up progress notifications for this sync to stop showing loading icons
+        try {
+            const progressNotificationsQuery = await db.collection('SignedInUsers')
+                .doc(String(userCid))
+                .collection('notifications')
+                .where('metadata.requestId', '==', requestId)
+                .where('subType', '==', 'progress')
+                .get();
+            
+            const batch = db.batch();
+            progressNotificationsQuery.docs.forEach(doc => {
+                batch.delete(doc.ref);
+            });
+            
+            if (progressNotificationsQuery.size > 0) {
+                await batch.commit();
+                logger?.log('INFO', `[notifyTaskEngineComplete] Cleaned up ${progressNotificationsQuery.size} progress notifications for request ${requestId}`);
+            }
+        } catch (cleanupError) {
+            logger?.log('WARN', `[notifyTaskEngineComplete] Failed to clean up progress notifications: ${cleanupError.message}`);
+            // Don't throw - cleanup is non-critical
+        }
+
         logger?.log('INFO', `[notifyTaskEngineComplete] Notification sent for user ${userCid}, request ${requestId}`);
     } catch (error) {
         logger?.log('WARN', `[notifyTaskEngineComplete] Failed to send notification: ${error.message}`);
@@ -61,6 +93,15 @@ async function notifyTaskEngineComplete(db, logger, userCid, requestId, username
  */
 async function notifyTaskEngineProgress(db, logger, userCid, requestId, username, stage, dataType, options = {}) {
     try {
+        // [FIX] Check user's notification preferences before sending
+        const { manageNotificationPreferences } = require('./data-fetchers/firestore.js');
+        const prefs = await manageNotificationPreferences(db, userCid, 'get');
+        
+        if (!prefs.syncProcesses) {
+            logger?.log('DEBUG', `[notifyTaskEngineProgress] User ${userCid} has syncProcesses disabled, skipping notification`);
+            return;
+        }
+        
         const stageMessages = {
             'started': 'Data sync started',
             'portfolio_complete': 'Portfolio data fetched',
@@ -130,6 +171,15 @@ async function notifyPIDataRefreshed(db, logger, collectionRegistry, piCid, user
  */
 async function notifyComputationComplete(db, logger, userCid, requestId, computation, displayName, success, errorMessage, options = {}) {
     try {
+        // [FIX] Check user's notification preferences before sending
+        const { manageNotificationPreferences } = require('./data-fetchers/firestore.js');
+        const prefs = await manageNotificationPreferences(db, userCid, 'get');
+        
+        if (!prefs.userActionCompletions) {
+            logger?.log('DEBUG', `[notifyComputationComplete] User ${userCid} has userActionCompletions disabled, skipping notification`);
+            return;
+        }
+        
         const notificationData = {
             type: 'computation',
             subType: 'complete',

package/package.json

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