bulltrackers-module 1.0.521 → 1.0.522

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

@@ -1,35 +1,124 @@
 /**
  * @fileoverview Notification Helpers for On-Demand Requests
  * Sends notifications to users when their on-demand sync/computation requests complete
+ * UPDATED: Added notification preferences support and task engine notifications
  */
 
 const { FieldValue } = require('@google-cloud/firestore');
+const { readWithMigration, writeWithMigration } = require('../core/path_resolution_helpers');
+
+/**
+ * Get user notification preferences
+ * @param {object} db - Firestore instance
+ * @param {object} collectionRegistry - Collection registry
+ * @param {number} userCid - User CID
+ * @param {object} config - Config object
+ * @returns {Promise<object>} Notification preferences object
+ */
+async function getUserNotificationPreferences(db, collectionRegistry, userCid, config) {
+    try {
+        // Use readWithMigration to support legacy paths during migration
+        const result = await readWithMigration(
+            db,
+            'signedInUsers',
+            'notificationPreferences',
+            { cid: String(userCid) },
+            {
+                isCollection: false,
+                dataType: 'notificationPreferences',
+                config,
+                documentId: 'settings',
+                collectionRegistry
+            }
+        );
+        
+        if (result && result.data) {
+            const data = result.data;
+            // Support both nested structure (settings: {...}) and flat structure
+            const preferences = data.settings || data || {};
+            
+            // Default preferences (all enabled except test alerts)
+            return {
+                syncProcesses: preferences.syncProcesses !== undefined ? preferences.syncProcesses : true,
+                userActionCompletions: preferences.userActionCompletions !== undefined ? preferences.userActionCompletions : true,
+                watchlistAlerts: preferences.watchlistAlerts !== undefined ? preferences.watchlistAlerts : true,
+                testAlerts: preferences.testAlerts !== undefined ? preferences.testAlerts : false
+            };
+        }
+        
+        // If document doesn't exist, return defaults
+        return {
+            syncProcesses: true,
+            userActionCompletions: true,
+            watchlistAlerts: true,
+            testAlerts: false
+        };
+    } catch (error) {
+        // If error, return defaults
+        return {
+            syncProcesses: true,
+            userActionCompletions: true,
+            watchlistAlerts: true,
+            testAlerts: false
+        };
+    }
+}
+
+/**
+ * Check if user should receive a notification of a given type
+ * @param {object} db - Firestore instance
+ * @param {object} collectionRegistry - Collection registry
+ * @param {number} userCid - User CID
+ * @param {string} notificationType - Notification type ('syncProcesses', 'userActionCompletions', 'watchlistAlerts', 'testAlerts')
+ * @param {object} config - Config object
+ * @returns {Promise<boolean>} True if user should receive notification
+ */
+async function shouldSendNotification(db, collectionRegistry, userCid, notificationType, config) {
+    const preferences = await getUserNotificationPreferences(db, collectionRegistry, userCid, config);
+    return preferences[notificationType] === true;
+}
 
 /**
  * Send a notification to a user about their on-demand request
- * @param {Firestore} db - Firestore instance
- * @param {Object} logger - Logger instance
+ * @param {object} db - Firestore instance
+ * @param {object} logger - Logger instance
  * @param {number} userCid - User CID to notify
  * @param {string} type - Notification type ('success', 'error', 'progress')
  * @param {string} title - Notification title
  * @param {string} message - Notification message
- * @param {Object} metadata - Additional metadata (requestId, computationName, etc.)
+ * @param {object} metadata - Additional metadata (requestId, computationName, etc.)
+ * @param {object} options - Optional: { collectionRegistry, config, notificationType }
  */
-async function sendOnDemandNotification(db, logger, userCid, type, title, message, metadata = {}) {
+async function sendOnDemandNotification(db, logger, userCid, type, title, message, metadata = {}, options = {}) {
+    // Check notification preferences if collectionRegistry is provided
+    if (options.collectionRegistry && options.config && options.notificationType) {
+        const shouldSend = await shouldSendNotification(
+            db, 
+            options.collectionRegistry, 
+            userCid, 
+            options.notificationType, 
+            options.config
+        );
+        
+        if (!shouldSend) {
+            logger.log('INFO', `[sendOnDemandNotification] Skipping notification to user ${userCid} (preference disabled for ${options.notificationType})`);
+            return;
+        }
+    }
     try {
-        const notificationId = `ondemand_${Date.now()}_${userCid}_${Math.random().toString(36).substring(2, 9)}`;
-        const notificationRef = db.collection('user_notifications')
-            .doc(String(userCid))
-            .collection('notifications')
-            .doc(notificationId);
+        const { collectionRegistry } = options;
+        const config = options.config || {};
+        
+        const notificationId = `notif_${Date.now()}_${userCid}_${Math.random().toString(36).substring(2, 9)}`;
         
         const notificationData = {
             id: notificationId,
-            type: 'on_demand',
-            subType: type, // 'success', 'error', 'progress'
+            type: metadata.notificationType || 'on_demand',
+            subType: type, // 'success', 'error', 'progress', 'info'
             title,
             message,
             read: false,
+            timestamp: FieldValue.serverTimestamp(),
             createdAt: FieldValue.serverTimestamp(),
             metadata: {
                 ...metadata,
@@ -37,21 +126,30 @@ async function sendOnDemandNotification(db, logger, userCid, type, title, messag
             }
         };
         
-        await notificationRef.set(notificationData);
-        
-        // Update notification counter
-        const today = new Date().toISOString().split('T')[0];
-        const counterRef = db.collection('user_notifications')
-            .doc(String(userCid))
-            .collection('counters')
-            .doc(today);
-        
-        await counterRef.set({
-            date: today,
-            unreadCount: FieldValue.increment(1),
-            totalCount: FieldValue.increment(1),
-            lastUpdated: FieldValue.serverTimestamp()
-        }, { merge: true });
+        // Write using collection registry
+        if (collectionRegistry) {
+            await writeWithMigration(
+                db,
+                'signedInUsers',
+                'notifications',
+                { cid: String(userCid), notificationId },
+                notificationData,
+                {
+                    isCollection: false,
+                    merge: false,
+                    dataType: 'notifications',
+                    config,
+                    collectionRegistry
+                }
+            );
+        } else {
+            // Fallback to legacy path
+            const notificationRef = db.collection('user_notifications')
+                .doc(String(userCid))
+                .collection('notifications')
+                .doc(notificationId);
+            await notificationRef.set(notificationData);
+        }
         
         logger.log('INFO', `[sendOnDemandNotification] Sent ${type} notification to user ${userCid}: ${title}`);
         
@@ -64,7 +162,7 @@ async function sendOnDemandNotification(db, logger, userCid, type, title, messag
 /**
  * Send notification when task engine completes data fetch
  */
-async function notifyTaskEngineComplete(db, logger, requestingUserCid, requestId, username, success, error = null) {
+async function notifyTaskEngineComplete(db, logger, requestingUserCid, requestId, username, success, error = null, options = {}) {
     if (!requestingUserCid) return; // No user to notify
     
     const type = success ? 'success' : 'error';
@@ -79,14 +177,83 @@ async function notifyTaskEngineComplete(db, logger, requestingUserCid, requestId
         requestId,
         username,
         stage: 'task_engine',
-        success
+        success,
+        notificationType: 'syncProcesses'
+    }, {
+        ...options,
+        notificationType: 'syncProcesses'
     });
 }
 
+/**
+ * Send notification when PI data is refreshed (for users with PI in watchlist)
+ * @param {object} db - Firestore instance
+ * @param {object} logger - Logger instance
+ * @param {object} collectionRegistry - Collection registry
+ * @param {number} piCid - Popular Investor CID
+ * @param {string} piUsername - Popular Investor username
+ * @param {object} config - Config object
+ */
+async function notifyPIDataRefreshed(db, logger, collectionRegistry, piCid, piUsername, config) {
+    try {
+        // Find all users who have this PI in their watchlist
+        // Check both static and dynamic watchlists
+        const watchlistMembershipRef = db.collection('WatchlistMembershipData')
+            .doc(new Date().toISOString().split('T')[0]);
+        
+        const membershipDoc = await watchlistMembershipRef.get();
+        if (!membershipDoc.exists) {
+            logger.log('INFO', `[notifyPIDataRefreshed] No watchlist membership data found for today`);
+            return;
+        }
+        
+        const membershipData = membershipDoc.data();
+        const piCidStr = String(piCid);
+        const piMembership = membershipData[piCidStr];
+        
+        if (!piMembership || !piMembership.users || !Array.isArray(piMembership.users)) {
+            logger.log('INFO', `[notifyPIDataRefreshed] No users have PI ${piCid} in their watchlist`);
+            return;
+        }
+        
+        const userIds = piMembership.users.map(u => String(u));
+        logger.log('INFO', `[notifyPIDataRefreshed] Found ${userIds.length} users with PI ${piCid} in watchlist`);
+        
+        // Send notification to each user
+        const notificationPromises = userIds.map(async (userId) => {
+            await sendOnDemandNotification(
+                db,
+                logger,
+                Number(userId),
+                'info',
+                'Popular Investor Data Updated',
+                `${piUsername} had their data refreshed. Portfolio, trade history, and social data have been updated.`,
+                {
+                    piCid: Number(piCid),
+                    piUsername: piUsername,
+                    notificationType: 'watchlistAlerts'
+                },
+                {
+                    collectionRegistry,
+                    config,
+                    notificationType: 'watchlistAlerts'
+                }
+            );
+        });
+        
+        await Promise.all(notificationPromises);
+        logger.log('INFO', `[notifyPIDataRefreshed] Sent notifications to ${userIds.length} users for PI ${piCid}`);
+        
+    } catch (error) {
+        logger.log('ERROR', `[notifyPIDataRefreshed] Failed to send notifications for PI ${piCid}`, error);
+        // Don't throw - notifications are non-critical
+    }
+}
+
 /**
  * Send notification when computation completes
  */
-async function notifyComputationComplete(db, logger, requestingUserCid, requestId, computationName, displayName, success, error = null) {
+async function notifyComputationComplete(db, logger, requestingUserCid, requestId, computationName, displayName, success, error = null, options = {}) {
     if (!requestingUserCid) return; // No user to notify
     
     const type = success ? 'success' : 'error';
@@ -102,7 +269,11 @@ async function notifyComputationComplete(db, logger, requestingUserCid, requestI
         computationName,
         displayName,
         stage: 'computation',
-        success
+        success,
+        notificationType: 'userActionCompletions'
+    }, {
+        ...options,
+        notificationType: 'userActionCompletions'
     });
 }
 
@@ -122,9 +293,170 @@ function getComputationDisplayName(computationName) {
     return displayNames[computationName] || computationName;
 }
 
+/**
+ * GET /user/me/notification-preferences
+ * Get user notification preferences
+ */
+async function getNotificationPreferences(req, res, dependencies, config) {
+    const { db, logger, collectionRegistry } = dependencies;
+    const { userCid } = req.query;
+    
+    if (!userCid) {
+        return res.status(400).json({ error: "Missing userCid" });
+    }
+    
+    try {
+        const preferences = await getUserNotificationPreferences(db, collectionRegistry, Number(userCid), config);
+        return res.status(200).json({
+            success: true,
+            preferences
+        });
+    } catch (error) {
+        logger.log('ERROR', `[getNotificationPreferences] Error fetching preferences for ${userCid}`, error);
+        return res.status(500).json({ error: error.message });
+    }
+}
+
+/**
+ * PUT /user/me/notification-preferences
+ * Update user notification preferences
+ */
+async function updateNotificationPreferences(req, res, dependencies, config) {
+    const { db, logger, collectionRegistry } = dependencies;
+    const { userCid } = req.query;
+    const { preferences } = req.body;
+    
+    if (!userCid) {
+        return res.status(400).json({ error: "Missing userCid" });
+    }
+    
+    if (!preferences || typeof preferences !== 'object') {
+        return res.status(400).json({ error: "Missing or invalid preferences object" });
+    }
+    
+    try {
+        // Validate preferences
+        const validKeys = ['syncProcesses', 'userActionCompletions', 'watchlistAlerts', 'testAlerts'];
+        const settingsData = {};
+        
+        for (const key of validKeys) {
+            if (preferences.hasOwnProperty(key)) {
+                settingsData[key] = Boolean(preferences[key]);
+            }
+        }
+        
+        if (Object.keys(settingsData).length === 0) {
+            return res.status(400).json({ error: "No valid preferences provided" });
+        }
+        
+        // Use writeWithMigration to support legacy paths during migration
+        await writeWithMigration(
+            db,
+            'signedInUsers',
+            'notificationPreferences',
+            { cid: String(userCid) },
+            {
+                settings: settingsData,
+                updatedAt: FieldValue.serverTimestamp()
+            },
+            {
+                isCollection: false,
+                merge: true,
+                dataType: 'notificationPreferences',
+                config,
+                documentId: 'settings',
+                collectionRegistry
+            }
+        );
+        
+        logger.log('INFO', `[updateNotificationPreferences] Updated preferences for user ${userCid}`);
+        
+        // Return updated preferences
+        const updatedPreferences = await getUserNotificationPreferences(db, collectionRegistry, Number(userCid), config);
+        
+        return res.status(200).json({
+            success: true,
+            preferences: updatedPreferences
+        });
+    } catch (error) {
+        logger.log('ERROR', `[updateNotificationPreferences] Error updating preferences for ${userCid}`, error);
+        return res.status(500).json({ error: error.message });
+    }
+}
+
+/**
+ * GET /user/me/notifications
+ * Get user notification history
+ */
+async function getNotificationHistory(req, res, dependencies, config) {
+    const { db, logger, collectionRegistry } = dependencies;
+    const { userCid, limit = 50, offset = 0, type, read } = req.query;
+    
+    if (!userCid) {
+        return res.status(400).json({ error: "Missing userCid" });
+    }
+    
+    try {
+        // Use collection registry to get notifications path
+        let notificationsPath;
+        if (collectionRegistry && collectionRegistry.getCollectionPath) {
+            notificationsPath = collectionRegistry.getCollectionPath('signedInUsers', 'notifications', { cid: String(userCid) });
+        } else {
+            // Fallback to legacy path
+            notificationsPath = `user_notifications/${userCid}/notifications`;
+        }
+        
+        let query = db.collection(notificationsPath)
+            .orderBy('timestamp', 'desc')
+            .limit(parseInt(limit));
+        
+        if (type) {
+            query = query.where('type', '==', type);
+        }
+        
+        if (read !== undefined) {
+            query = query.where('read', '==', read === 'true');
+        }
+        
+        const snapshot = await query.get();
+        const notifications = [];
+        
+        snapshot.forEach(doc => {
+            const data = doc.data();
+            notifications.push({
+                id: doc.id,
+                type: data.type || 'other',
+                subType: data.subType,
+                title: data.title || '',
+                message: data.message || '',
+                read: data.read || false,
+                timestamp: data.timestamp?.toDate?.()?.toISOString() || data.createdAt?.toDate?.()?.toISOString() || new Date().toISOString(),
+                metadata: data.metadata || {}
+            });
+        });
+        
+        return res.status(200).json({
+            success: true,
+            notifications,
+            count: notifications.length,
+            limit: parseInt(limit),
+            offset: parseInt(offset)
+        });
+    } catch (error) {
+        logger.log('ERROR', `[getNotificationHistory] Error fetching notifications for ${userCid}`, error);
+        return res.status(500).json({ error: error.message });
+    }
+}
+
 module.exports = {
     sendOnDemandNotification,
     notifyTaskEngineComplete,
     notifyComputationComplete,
-    getComputationDisplayName
+    notifyPIDataRefreshed,
+    getComputationDisplayName,
+    getUserNotificationPreferences,
+    shouldSendNotification,
+    getNotificationPreferences,
+    updateNotificationPreferences,
+    getNotificationHistory
 };

package/functions/generic-api/user-api/index.js

@@ -13,6 +13,7 @@ const { getAlertTypes, getDynamicWatchlistComputations, getUserAlerts, getAlertC
 const { requestPiFetch, getPiFetchStatus } = require('./helpers/fetch/on_demand_fetch_helpers');
 const { requestUserSync, getUserSyncStatus } = require('./helpers/sync/user_sync_helpers');
 const { sendTestAlert } = require('./helpers/alerts/test_alert_helpers');
+const { getNotificationPreferences, updateNotificationPreferences, getNotificationHistory } = require('./helpers/notifications/notification_helpers');
 
 module.exports = (dependencies, config) => {
     const router = express.Router();
@@ -99,5 +100,10 @@ module.exports = (dependencies, config) => {
     router.put('/me/alerts/read-all', (req, res) => markAllAlertsRead(req, res, dependencies, config));
     router.delete('/me/alerts/:alertId', (req, res) => deleteAlert(req, res, dependencies, config));
     
+    // --- Notification Preferences & History ---
+    router.get('/me/notification-preferences', (req, res) => getNotificationPreferences(req, res, dependencies, config));
+    router.put('/me/notification-preferences', (req, res) => updateNotificationPreferences(req, res, dependencies, config));
+    router.get('/me/notifications', (req, res) => getNotificationHistory(req, res, dependencies, config));
+    
     return router;
 };

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

@@ -515,6 +515,17 @@ async function handlePopularInvestorUpdate(taskData, config, dependencies) {
 
         logger.log('SUCCESS', `[PI Update] Completed full update for ${username} (Portfolio: ✓, History: ✓, Social: ${socialFetched ? '✓' : '✗'})`);
         
+        // Send notifications to users who have this PI in their watchlist
+        if (cid && username && db && collectionRegistry && config) {
+            try {
+                const { notifyPIDataRefreshed } = require('../../../generic-api/user-api/helpers/notifications/notification_helpers');
+                await notifyPIDataRefreshed(db, logger, collectionRegistry, cid, username, config);
+            } catch (notifError) {
+                logger.log('WARN', `[PI Update] Failed to send notifications for PI ${cid}: ${notifError.message}`);
+                // Non-critical, continue
+            }
+        }
+        
         // Update request status and trigger computation if this is an on-demand request (PI fetch or sync)
         if (requestId && (source === 'on_demand' || source === 'on_demand_sync') && db) {
             try {

package/package.json

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