bulltrackers-module 1.0.568 → 1.0.570

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/functions/orchestrator/helpers/update_helpers.js

@@ -42,17 +42,47 @@ async function getUpdateTargets(userType, thresholds, config, dependencies) {
 
 /**
  * Sub-pipe: pipe.orchestrator.dispatchUpdates
+ * UPDATED: Added real-time validation to skip users already updated today.
  */
 async function dispatchUpdates(targets, userType, config, dependencies) {
-    const { logger, pubsubUtils } = dependencies;
+    const { logger, pubsubUtils, db } = dependencies;
     const { dispatcherTopicName, taskBatchSize, pubsubBatchSize } = config;
     
-    if (targets.length === 0) { 
-        logger.log('INFO', `[Orchestrator Helpers] No ${userType} update targets to dispatch.`); 
-        return; 
-    }
+    if (targets.length === 0) return;
+
+    // --- NEW VALIDATION BLOCK ---
+    const startOfToday = new Date();
+    startOfToday.setUTCHours(0, 0, 0, 0);
+    
+    logger.log('INFO', `[Orchestrator Validation] Verifying ${targets.length} targets for ${userType}...`);
     
-    logger.log('INFO', `[Orchestrator Helpers] Dispatching ${targets.length} update tasks for ${userType} to ${dispatcherTopicName}...`);
+    const validTargets = [];
+    for (const target of targets) {
+        const cid = target.userId || target.cid || (typeof target === 'string' ? target : null);
+        if (!cid) { validTargets.push(target); continue; }
+
+        // Check the actual Firestore record for today's completion
+        const collection = userType === 'popular_investor' ? 'PopularInvestors' : 
+                           userType === 'signed_in_user' ? 'SignedInUsers' : 'NormalUsers';
+        
+        const doc = await db.collection(collection).doc(String(cid)).get();
+        const lastUpdated = doc.data()?.lastUpdated?.updatedAt?.toDate?.() || 
+                           doc.data()?.lastUpdate?.toDate?.();
+
+        if (lastUpdated && lastUpdated >= startOfToday) {
+            logger.log('TRACE', `[Orchestrator Validation] Skipping ${cid} - Already updated today.`);
+            continue;
+        }
+        validTargets.push(target);
+    }
+
+    if (validTargets.length === 0) {
+        logger.log('INFO', `[Orchestrator Helpers] All ${targets.length} targets already updated. Skipping dispatch.`);
+        return;
+    }
+    // --- END VALIDATION BLOCK ---
+
+    logger.log('INFO', `[Orchestrator Helpers] Dispatching ${validTargets.length} validated update tasks for ${userType}...`);
     
     const individualTasks = targets.map(target => {
         let task = { userType };

package/functions/task-engine/handler_creator.js

@@ -133,7 +133,7 @@ async function handleRequest(message, context, configObj, dependencies) {
             if (updateTasksCount > 0) {
                 try {
                     // This batch counter is critical for triggering the Root Data Indexer
-                    batchCounterRef = db.collection('task_engine_batch_counters').doc(`${today}-${taskId}`);
+                    batchCounterRef = db.collection('system_task_counts').doc(`${today}-${taskId}`);
                     await batchCounterRef.set({
                         totalTasks: updateTasksCount,
                         remainingTasks: updateTasksCount,

package/functions/task-engine/helpers/popular_investor_helpers.js

@@ -308,7 +308,7 @@ async function handleGenericUserUpdate(taskData, config, dependencies, isPI) {
         
         // 5. Batch Counter Decrement (Critical for Scheduled Runs)
         if (batchCounterId) {
-             const counterRef = db.collection('task_engine_batch_counters').doc(batchCounterId);
+             const counterRef = db.collection('system_task_counts').doc(batchCounterId);
              await counterRef.update({ remainingTasks: FieldValue.increment(-1) });
              
              // Check if we need to trigger root indexer for the batch

package/package.json

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