bulltrackers-module 1.0.569 → 1.0.571

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

@@ -148,51 +148,70 @@ async function getUserDataStatus(req, res, dependencies, config) {
         const category = 'popular-investor';
         const computationName = 'SignedInUserProfileMetrics';
         
-        // Find latest computation date
-        const latestComputationDate = await findLatestComputationDate(
-            db,
-            insightsCollection,
-            resultsSub,
-            compsSub,
-            category,
-            computationName,
-            effectiveCid,
-            30
-        );
-        
         let computationAvailable = false;
         let computationDate = null;
         let isComputationFallback = false;
         
-        if (latestComputationDate) {
-            // Check if this specific user exists in the computation
-            const { found } = await checkPiInComputationDate(
-                db,
-                insightsCollection,
-                resultsSub,
-                compsSub,
-                category,
-                computationName,
-                latestComputationDate,
-                String(effectiveCid),
-                logger
-            );
+        // Search backwards from today to find the latest date where user exists in computation
+        // Priority: Today (T) -> Yesterday (T-1) -> Continue backwards up to 30 days
+        const maxDaysBack = 30;
+        let foundDate = null;
+        
+        for (let daysBack = 0; daysBack < maxDaysBack; daysBack++) {
+            const checkDate = new Date();
+            checkDate.setDate(checkDate.getDate() - daysBack);
+            const dateStr = checkDate.toISOString().split('T')[0];
             
-            if (found) {
-                computationAvailable = true;
-                computationDate = latestComputationDate;
-                isComputationFallback = latestComputationDate !== today;
+            try {
+                // Check if computation document exists for this date
+                const computationRef = db.collection(insightsCollection)
+                    .doc(dateStr)
+                    .collection(resultsSub)
+                    .doc(category)
+                    .collection(compsSub)
+                    .doc(computationName);
+                
+                const computationDoc = await computationRef.get();
                 
-                if (isComputationFallback) {
-                    logger.log('INFO', `[getUserDataStatus] Using fallback computation date ${computationDate} for user ${userCid} (today: ${today})`);
-                } else {
-                    logger.log('INFO', `[getUserDataStatus] Found computation for user ${userCid} on today's date`);
+                if (computationDoc.exists) {
+                    // Computation exists for this date, check if user is in it
+                    const { found } = await checkPiInComputationDate(
+                        db,
+                        insightsCollection,
+                        resultsSub,
+                        compsSub,
+                        category,
+                        computationName,
+                        dateStr,
+                        String(effectiveCid),
+                        logger
+                    );
+                    
+                    if (found) {
+                        foundDate = dateStr;
+                        computationAvailable = true;
+                        computationDate = dateStr;
+                        isComputationFallback = daysBack > 0;
+                        
+                        if (isComputationFallback) {
+                            logger.log('INFO', `[getUserDataStatus] Found computation for user ${userCid} on date ${computationDate} (${daysBack} days back from today: ${today})`);
+                        } else {
+                            logger.log('INFO', `[getUserDataStatus] Found computation for user ${userCid} on today's date`);
+                        }
+                        break; // Found user, stop searching
+                    } else {
+                        logger.log('DEBUG', `[getUserDataStatus] Computation exists for date ${dateStr} but user ${userCid} not found in it, continuing search...`);
+                    }
                 }
-            } else {
-                logger.log('INFO', `[getUserDataStatus] Computation exists for date ${latestComputationDate} but user ${userCid} not found in it`);
+            } catch (error) {
+                // Continue to next date if error
+                logger.log('DEBUG', `[getUserDataStatus] Error checking date ${dateStr}:`, error.message);
+                continue;
             }
-        } else {
-            logger.log('INFO', `[getUserDataStatus] No computation found for user ${userCid} in last 30 days`);
+        }
+        
+        if (!foundDate) {
+            logger.log('INFO', `[getUserDataStatus] No computation found for user ${userCid} in last ${maxDaysBack} days`);
         }
         
         // For backward compatibility, keep portfolioAvailable and historyAvailable
@@ -201,14 +220,22 @@ async function getUserDataStatus(req, res, dependencies, config) {
             portfolioAvailable: computationAvailable, // Profile page uses computation, not raw portfolio
             historyAvailable: computationAvailable,  // Profile page uses computation, not raw history
             computationAvailable: computationAvailable, // Explicit computation check
-            date: computationDate || today,
-            computationDate: computationDate,
-            isComputationFallback: isComputationFallback,
-            requestedDate: today,
+            date: computationDate || today, // Use found date or today as fallback
+            computationDate: computationDate, // The actual date where computation was found
+            isComputationFallback: isComputationFallback, // True if using T-1 or older date
+            requestedDate: today, // What date was requested (today)
             userCid: String(userCid),
             effectiveCid: String(effectiveCid)
         };
         
+        if (computationAvailable && isComputationFallback) {
+            logger.log('INFO', `[getUserDataStatus] Using fallback date ${computationDate} for CID ${userCid} (requested: ${today})`);
+        } else if (computationAvailable) {
+            logger.log('INFO', `[getUserDataStatus] Using today's date ${computationDate} for CID ${userCid}`);
+        } else {
+            logger.log('WARN', `[getUserDataStatus] No computation found for CID ${userCid} in last ${maxDaysBack} days`);
+        }
+        
         logger.log('INFO', `[getUserDataStatus] Result for CID ${userCid}:`, result);
         
         return res.status(200).json(result);

package/functions/generic-api/user-api/helpers/notifications/notification_helpers.js

@@ -446,11 +446,21 @@ async function updateNotificationPreferences(req, res, dependencies, config) {
 
 /**
  * GET /user/me/notifications
- * Get user notification history
+ * Get user notification history with pagination, date range, and filtering
  */
 async function getNotificationHistory(req, res, dependencies, config) {
     const { db, logger, collectionRegistry } = dependencies;
-    const { userCid, limit = 50, offset = 0, type, read } = req.query;
+    const { 
+        userCid, 
+        limit = 50, 
+        offset = 0, 
+        type, 
+        read,
+        subType,
+        alertType,
+        startDate,
+        endDate
+    } = req.query;
     
     if (!userCid) {
         return res.status(400).json({ error: "Missing userCid" });
@@ -466,10 +476,31 @@ async function getNotificationHistory(req, res, dependencies, config) {
             notificationsPath = `user_notifications/${userCid}/notifications`;
         }
         
-        // Try to query from new path first
+        // Parse date filters
+        let startDateObj = null;
+        let endDateObj = null;
+        if (startDate) {
+            startDateObj = new Date(startDate);
+            if (isNaN(startDateObj.getTime())) {
+                return res.status(400).json({ error: "Invalid startDate format" });
+            }
+        }
+        if (endDate) {
+            endDateObj = new Date(endDate);
+            if (isNaN(endDateObj.getTime())) {
+                return res.status(400).json({ error: "Invalid endDate format" });
+            }
+            // Set to end of day
+            endDateObj.setHours(23, 59, 59, 999);
+        }
+        
+        // Build query - fetch more than needed to apply filters in memory
+        // Firestore has limitations on complex queries, so we'll fetch a larger batch
+        // and filter in memory for date range and subType
+        const maxFetchLimit = 1000; // Fetch up to 1000 to apply filters
         let query = db.collection(notificationsPath)
             .orderBy('timestamp', 'desc')
-            .limit(parseInt(limit));
+            .limit(maxFetchLimit);
         
         if (type) {
             query = query.where('type', '==', type);
@@ -487,24 +518,74 @@ async function getNotificationHistory(req, res, dependencies, config) {
             logger.log('WARN', `[getNotificationHistory] Query failed, trying without filters: ${queryError.message}`);
             query = db.collection(notificationsPath)
                 .orderBy('timestamp', 'desc')
-                .limit(parseInt(limit));
+                .limit(maxFetchLimit);
             snapshot = await query.get();
         }
         
         const notifications = [];
+        const admin = require('firebase-admin');
         
         snapshot.forEach(doc => {
             const data = doc.data();
             
-            // Apply filters in memory if query filters failed
+            // Convert timestamp to Date object
+            let timestamp = null;
+            if (data.timestamp) {
+                if (data.timestamp.toDate) {
+                    timestamp = data.timestamp.toDate();
+                } else if (data.timestamp instanceof admin.firestore.Timestamp) {
+                    timestamp = data.timestamp.toDate();
+                } else if (data.timestamp instanceof Date) {
+                    timestamp = data.timestamp;
+                }
+            } else if (data.createdAt) {
+                if (data.createdAt.toDate) {
+                    timestamp = data.createdAt.toDate();
+                } else if (data.createdAt instanceof admin.firestore.Timestamp) {
+                    timestamp = data.createdAt.toDate();
+                } else if (data.createdAt instanceof Date) {
+                    timestamp = data.createdAt;
+                }
+            }
+            
+            if (!timestamp) {
+                timestamp = new Date();
+            }
+            
+            // Apply filters in memory
             let include = true;
+            
+            // Type filter (already applied in query if possible)
             if (type && data.type !== type) {
                 include = false;
             }
+            
+            // Read filter (already applied in query if possible)
             if (read !== undefined && data.read !== (read === 'true')) {
                 include = false;
             }
             
+            // SubType filter
+            if (subType && data.subType !== subType) {
+                include = false;
+            }
+            
+            // AlertType filter (for watchlist alerts, filters by metadata.alertType)
+            if (alertType) {
+                const metadata = data.metadata || {};
+                if (metadata.alertType !== alertType) {
+                    include = false;
+                }
+            }
+            
+            // Date range filter
+            if (startDateObj && timestamp < startDateObj) {
+                include = false;
+            }
+            if (endDateObj && timestamp > endDateObj) {
+                include = false;
+            }
+            
             if (include) {
                 notifications.push({
                     id: doc.id,
@@ -513,23 +594,31 @@ async function getNotificationHistory(req, res, dependencies, config) {
                     title: data.title || '',
                     message: data.message || '',
                     read: data.read || false,
-                    timestamp: data.timestamp?.toDate?.()?.toISOString() || data.createdAt?.toDate?.()?.toISOString() || new Date().toISOString(),
+                    timestamp: timestamp.toISOString(),
                     metadata: data.metadata || {}
                 });
             }
         });
         
-        // Apply offset in memory
+        // Sort by timestamp (descending) to ensure proper ordering
+        notifications.sort((a, b) => {
+            return new Date(b.timestamp) - new Date(a.timestamp);
+        });
+        
+        // Apply pagination
         const offsetNum = parseInt(offset);
-        const paginatedNotifications = notifications.slice(offsetNum, offsetNum + parseInt(limit));
+        const limitNum = parseInt(limit);
+        const totalCount = notifications.length;
+        const paginatedNotifications = notifications.slice(offsetNum, offsetNum + limitNum);
         
         return res.status(200).json({
             success: true,
             notifications: paginatedNotifications,
             count: paginatedNotifications.length,
-            total: notifications.length,
-            limit: parseInt(limit),
-            offset: offsetNum
+            total: totalCount,
+            limit: limitNum,
+            offset: offsetNum,
+            hasMore: offsetNum + limitNum < totalCount
         });
     } catch (error) {
         logger.log('ERROR', `[getNotificationHistory] Error fetching notifications for ${userCid}`, error);

package/package.json

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