bulltrackers-module 1.0.609 → 1.0.611

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

@@ -64,24 +64,41 @@ async function processAlertForPI(db, logger, piCid, alertType, computationMetada
         }
       };
       
+      // Write to alerts collection (not notifications) - alerts are separate from system notifications
       // Use writeWithMigration to write to new path (with legacy fallback)
       const writePromise = writeWithMigration(
         db,
         'signedInUsers',
-        'notifications',
+        'alerts', // Write to alerts collection, not notifications
         { cid: String(userCid) },
-        notificationData,
+        {
+          // Alert-specific format (simplified from notification format)
+          alertId: notificationId,
+          piCid: Number(piCid),
+          piUsername: piUsername,
+          alertType: alertType.id,
+          alertTypeName: alertType.name,
+          message: alertMessage,
+          severity: alertType.severity,
+          watchlistId: subscription.watchlistId,
+          watchlistName: subscription.watchlistName,
+          read: false,
+          createdAt: FieldValue.serverTimestamp(),
+          computationDate: computationDate,
+          computationName: alertType.computationName,
+          ...(computationMetadata || {})
+        },
         {
           isCollection: true,
           merge: false,
-          dataType: 'notifications',
+          dataType: 'alerts',
           documentId: notificationId,
           dualWrite: false, // Disable dual write - we're fully migrated to new path
           config,
           collectionRegistry
         }
       ).catch(err => {
-        logger.log('ERROR', `[processAlertForPI] Failed to write notification for CID ${userCid}: ${err.message}`, err);
+        logger.log('ERROR', `[processAlertForPI] Failed to write alert for CID ${userCid}: ${err.message}`, err);
         throw err; // Re-throw so we know if writes are failing
       });
       

package/functions/alert-system/index.js

@@ -343,11 +343,22 @@ async function checkIfPIHasAlertsToday(db, logger, userCid, piCid, date, depende
     
     const notificationsRef = db.collection(notificationsPath);
     
-    // Check if there are any alert notifications for this PI today
-    const snapshot = await notificationsRef
-      .where('type', '==', 'watchlistAlerts')
-      .where('metadata.piCid', '==', Number(piCid))
-      .where('metadata.computationDate', '==', date)
+    // Check alerts collection instead of notifications
+    // Use collection registry to get alerts path
+    let alertsPath;
+    if (collectionRegistry && collectionRegistry.getCollectionPath) {
+      alertsPath = collectionRegistry.getCollectionPath('signedInUsers', 'alerts', { cid: String(userCid) });
+    } else {
+      // Fallback to legacy path
+      alertsPath = `user_alerts/${userCid}/alerts`;
+    }
+    
+    const alertsRef = db.collection(alertsPath);
+    
+    // Check if there are any alerts for this PI today
+    const snapshot = await alertsRef
+      .where('piCid', '==', Number(piCid))
+      .where('computationDate', '==', date)
       .limit(1)
       .get();
     
@@ -415,19 +426,30 @@ async function sendAllClearNotification(db, logger, userCid, piCid, piUsername,
       }
     };
     
-    // Use writeWithMigration to write to new path (with legacy fallback)
-    // notifications is a subcollection, so we need isCollection: true and documentId
+    // Write to alerts collection (not notifications) - alerts are separate from system notifications
     const { writeWithMigration } = require('../old-generic-api/user-api/helpers/core/path_resolution_helpers');
     await writeWithMigration(
       db,
       'signedInUsers',
-      'notifications',
+      'alerts', // Write to alerts collection, not notifications
       { cid: String(userCid) },
-      notificationData,
+      {
+        // Alert-specific format
+        alertId: notificationId,
+        piCid: Number(piCid),
+        piUsername: piUsername,
+        alertType: 'all_clear',
+        alertTypeName: 'All Clear',
+        message: `${piUsername} was processed, all clear today!`,
+        severity: 'info',
+        read: false,
+        createdAt: FieldValue.serverTimestamp(),
+        computationDate: date
+      },
       {
         isCollection: true,
         merge: false,
-        dataType: 'notifications',
+        dataType: 'alerts',
         documentId: notificationId,
         dualWrite: false, // Disable dual write - we're fully migrated to new path
         config,

package/functions/api-v2/helpers/data-fetchers/firestore.js

@@ -1112,13 +1112,26 @@ const getComputationResults = async (db, computationName, dateStr, userId = null
 
 // 11. Fetch User Notifications
 const fetchNotifications = async (firestore, userId, options = {}) => {
-    const { limit = 20, unreadOnly = false } = options;
+    const { limit = 20, unreadOnly = false, excludeTypes = ['watchlistAlerts'] } = options;
     try {
         let query = firestore.collection('SignedInUsers').doc(userId).collection('notifications');
         if (unreadOnly) query = query.where('read', '==', false);
         
-        const snapshot = await query.orderBy('createdAt', 'desc').limit(limit).get();
-        return snapshot.docs.map(doc => ({ id: doc.id, ...doc.data() }));
+        const snapshot = await query.orderBy('createdAt', 'desc').limit(limit * 2).get(); // Fetch more to filter
+        
+        // Filter out excluded types (like watchlistAlerts which go to alerts bell)
+        let notifications = snapshot.docs.map(doc => ({ id: doc.id, ...doc.data() }));
+        
+        if (excludeTypes && excludeTypes.length > 0) {
+            notifications = notifications.filter(notif => {
+                // Exclude by type field or metadata.notificationType
+                const notifType = notif.type || notif.metadata?.notificationType;
+                return !excludeTypes.includes(notifType);
+            });
+        }
+        
+        // Limit after filtering
+        return notifications.slice(0, limit);
     } catch (error) {
         console.error(`Error fetching notifications: ${error}`);
         throw error;
@@ -1225,14 +1238,29 @@ const trackPopularInvestorView = async (db, piId, viewerId = null, viewerType =
 // ==========================================
 
 const fetchUserAlerts = async (db, userId, options = {}) => {
-    const { limit = 50, unreadOnly = false, type } = options;
-    let query = db.collection('user_alerts').doc(userId).collection('alerts').orderBy('createdAt', 'desc');
+    const { limit = 50, unreadOnly = false, type, piCid } = options;
+    // Use new path: SignedInUsers/{cid}/alerts
+    let query = db.collection('SignedInUsers').doc(String(userId)).collection('alerts').orderBy('createdAt', 'desc');
 
     if (unreadOnly) query = query.where('read', '==', false);
     if (type) query = query.where('alertType', '==', type);
+    if (piCid) query = query.where('piCid', '==', Number(piCid));
 
     const snapshot = await query.limit(limit).get();
-    return snapshot.docs.map(doc => ({ id: doc.id, ...doc.data() }));
+    // Convert Firestore timestamps to ISO strings for frontend
+    return snapshot.docs.map(doc => {
+        const data = doc.data();
+        // Convert Firestore timestamps to ISO strings
+        if (data.createdAt) {
+            data.createdAt = data.createdAt.toDate ? data.createdAt.toDate().toISOString() : 
+                           (data.createdAt.toISOString ? data.createdAt.toISOString() : data.createdAt);
+        }
+        if (data.readAt) {
+            data.readAt = data.readAt.toDate ? data.readAt.toDate().toISOString() : 
+                         (data.readAt.toISOString ? data.readAt.toISOString() : data.readAt);
+        }
+        return { id: doc.id, ...data };
+    });
 };
 
 const subscribeToWatchlistAlerts = async (db, userId, watchlistId, piId, alertConfig) => {
@@ -2184,6 +2212,50 @@ const checkDataStatus = async (db, userId) => {
     };
 };
 
+/**
+ * Check Popular Investor data status - finds the latest computation date for a PI
+ * Similar to checkDataStatus but specifically for PopularInvestorProfileMetrics
+ */
+const checkPopularInvestorDataStatus = async (db, piId) => {
+    const lookbackDays = 7;
+    const today = new Date();
+    let computationDate = null;
+    
+    const computationName = 'PopularInvestorProfileMetrics';
+    
+    // Check for computation results in the last 7 days
+    for (let i = 0; i < lookbackDays; i++) {
+        const checkDate = new Date(today);
+        checkDate.setDate(checkDate.getDate() - i);
+        const dateStr = checkDate.toISOString().split('T')[0];
+        
+        try {
+            const pageRef = db.collection('unified_insights')
+                .doc(dateStr)
+                .collection('results')
+                .doc('popular-investor')
+                .collection('computations')
+                .doc(computationName)
+                .collection('pages')
+                .doc(String(piId));
+            
+            const pageSnap = await pageRef.get();
+            if (pageSnap.exists) {
+                computationDate = dateStr;
+                break;
+            }
+        } catch (error) {
+            // Continue checking other dates
+            console.error(`Error checking computation ${computationName} for ${dateStr}:`, error);
+        }
+    }
+    
+    return {
+        computationDate: computationDate,
+        available: computationDate !== null
+    };
+};
+
 const sendTestAlert = async (db, userId, payload) => {
     // Create a fake notification
     const id = `test_${Date.now()}`;
@@ -2511,6 +2583,7 @@ module.exports = {
     getSyncStatus,
     autoGenerateWatchlist,
     checkDataStatus,
+    checkPopularInvestorDataStatus,
     sendTestAlert,
     isSignedInUser,
     getUserUsername,

package/functions/api-v2/routes/alerts.js

@@ -14,11 +14,12 @@ const router = express.Router();
 router.get('/history', async (req, res) => {
     try {
         const { db } = req.dependencies;
-        const { limit, unreadOnly, type } = req.query;
+        const { limit, unreadOnly, type, piCid } = req.query;
         const alerts = await fetchUserAlerts(db, req.targetUserId, { 
             limit: parseInt(limit || 50), 
             unreadOnly: unreadOnly === 'true',
-            type
+            type: type || undefined,
+            piCid: piCid ? Number(piCid) : undefined
         });
         res.json({ success: true, count: alerts.length, data: alerts });
     } catch (error) {
@@ -41,7 +42,7 @@ router.get('/count', async (req, res) => {
 router.put('/:id/read', async (req, res) => {
     try {
         const { db } = req.dependencies;
-        await db.collection('user_alerts').doc(req.targetUserId).collection('alerts').doc(req.params.id)
+        await db.collection('SignedInUsers').doc(String(req.targetUserId)).collection('alerts').doc(req.params.id)
             .update({ read: true, readAt: new Date() });
         res.json({ success: true });
     } catch (e) { res.status(500).json({ error: e.message }); }
@@ -52,7 +53,7 @@ router.put('/read-all', async (req, res) => {
     try {
         const { db } = req.dependencies;
         const batch = db.batch();
-        const snaps = await db.collection('user_alerts').doc(req.targetUserId).collection('alerts').where('read', '==', false).get();
+        const snaps = await db.collection('SignedInUsers').doc(String(req.targetUserId)).collection('alerts').where('read', '==', false).get();
         snaps.docs.forEach(doc => batch.update(doc.ref, { read: true, readAt: new Date() }));
         await batch.commit();
         res.json({ success: true, updated: snaps.size });
@@ -63,7 +64,7 @@ router.put('/read-all', async (req, res) => {
 router.delete('/:id', async (req, res) => {
     try {
         const { db } = req.dependencies;
-        await db.collection('user_alerts').doc(req.targetUserId).collection('alerts').doc(req.params.id).delete();
+        await db.collection('SignedInUsers').doc(String(req.targetUserId)).collection('alerts').doc(req.params.id).delete();
         res.json({ success: true });
     } catch (e) { res.status(500).json({ error: e.message }); }
 });

package/functions/api-v2/routes/popular_investors.js

@@ -147,11 +147,16 @@ router.get('/:piId/profile', async (req, res) => {
         const computationName = 'PopularInvestorProfileMetrics';
         const profileData = await pageCollection(db, targetDate, computationName, piId, parseInt(lookback));
         
+        // Extract computationDate from the latest data entry (first item in array, sorted by date descending)
+        // The profileData array contains { date, data } objects, sorted with latest first
+        const computationDate = profileData && profileData.length > 0 ? profileData[0].date : null;
+        
         res.json({ 
             success: true, 
             computation: computationName,
             piId: piId,
             data: profileData,
+            computationDate: computationDate, // Latest computation date for up-to-date validation
             profileType: 'public' // Indicates this is a public PI profile
         });
     } catch (error) {

package/functions/api-v2/routes/sync.js

@@ -6,7 +6,9 @@ const {
     isDeveloper,
     isSignedInUser,
     fetchPopularInvestorMasterList,
-    getUserUsername
+    getUserUsername,
+    checkDataStatus,
+    checkPopularInvestorDataStatus
 } = require('../helpers/data-fetchers/firestore.js');
 
 const router = express.Router();
@@ -25,20 +27,56 @@ const handleSyncRequest = async (req, res) => {
         const limit = await checkSyncRateLimits(db, targetId, req.targetUserId, isDev);
         if (!limit.allowed) return res.status(429).json({ error: limit.message });
 
-        // 2. Detect User Types
+        // 2. Detect User Types (needed for validation)
         const [isSignedIn, isPI] = await Promise.all([
             isSignedInUser(db, targetId),
             fetchPopularInvestorMasterList(db, String(targetId)).then(() => true).catch(() => false)
         ]);
 
+        // 3. Check if data is already up-to-date (prevent unnecessary syncs)
+        // Developers can bypass this check
+        if (!isDev) {
+            try {
+                let computationDate = null;
+                
+                // Check Popular Investor data status if target is a PI (anyone can sync a PI, so always check)
+                if (isPI) {
+                    const piDataStatus = await checkPopularInvestorDataStatus(db, String(targetId));
+                    computationDate = piDataStatus.computationDate;
+                }
+                
+                // Check signed-in user data status if target is a signed-in user syncing themselves
+                // (Only check if not already found from PI check, and only if syncing themselves)
+                if (isSignedIn && targetId === req.targetUserId && !computationDate) {
+                    const userDataStatus = await checkDataStatus(db, String(targetId));
+                    computationDate = userDataStatus.computationDate;
+                }
+                
+                // If we found a computation date and it's today, block the sync
+                if (computationDate) {
+                    const today = new Date().toISOString().split('T')[0]; // YYYY-MM-DD format
+                    if (computationDate === today) {
+                        return res.status(400).json({ 
+                            error: "Data is already up-to-date for today. Sync is not needed.",
+                            code: "DATA_UP_TO_DATE",
+                            computationDate: computationDate
+                        });
+                    }
+                }
+            } catch (error) {
+                // If data status check fails, log but don't block sync (fail open for reliability)
+                console.warn(`[handleSyncRequest] Failed to check data status for ${targetId}:`, error.message);
+            }
+        }
+
         if (!isSignedIn && !isPI) {
             return res.status(404).json({ error: "User not found in SignedInUsers or Popular Investor master list" });
         }
 
-        // 3. Get username
+        // 4. Get username
         const username = await getUserUsername(db, targetId) || String(targetId);
 
-        // 4. Create request IDs and dispatch tasks
+        // 5. Create request IDs and dispatch tasks
         const requestIds = [];
         const tasks = [];
 

package/package.json

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