bulltrackers-module 1.0.591 → 1.0.592

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

@@ -1,641 +0,0 @@
-/**
- * @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 {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} options - Optional: { collectionRegistry, config, notificationType }
- */
-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 { collectionRegistry } = options;
-        const config = options.config || {};
-        
-        const notificationId = `notif_${Date.now()}_${userCid}_${Math.random().toString(36).substring(2, 9)}`;
-        
-        const notificationData = {
-            id: notificationId,
-            type: metadata.notificationType || 'on_demand',
-            subType: type, // 'success', 'error', 'progress', 'info'
-            title,
-            message,
-            read: false,
-            timestamp: FieldValue.serverTimestamp(),
-            createdAt: FieldValue.serverTimestamp(),
-            metadata: {
-                ...metadata,
-                userCid: Number(userCid)
-            }
-        };
-        
-        // Write using collection registry
-        // notifications is a subcollection, so we need isCollection: true and documentId
-        if (collectionRegistry) {
-            await writeWithMigration(
-                db,
-                'signedInUsers',
-                'notifications',
-                { cid: String(userCid) },
-                notificationData,
-                {
-                    isCollection: true,
-                    merge: false,
-                    dataType: 'notifications',
-                    documentId: notificationId,
-                    dualWrite: false, // Disable dual write - we're fully migrated to new path
-                    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}`);
-        
-    } catch (error) {
-        logger.log('ERROR', `[sendOnDemandNotification] Failed to send notification to user ${userCid}`, error);
-        // Don't throw - notifications are non-critical
-    }
-}
-
-/**
- * Send progress notification during task engine processing
- */
-async function notifyTaskEngineProgress(db, logger, requestingUserCid, requestId, username, stage, dataType = null, options = {}) {
-    if (!requestingUserCid) return; // No user to notify
-    
-    let title = 'Data Sync In Progress';
-    let message = `Syncing data for ${username}...`;
-    
-    if (stage === 'started') {
-        title = 'Data Sync Started';
-        message = `Started syncing data for ${username}. This may take a few minutes.`;
-    } else if (stage === 'portfolio_complete') {
-        title = 'Portfolio Data Synced';
-        message = `Portfolio data for ${username} has been fetched and stored.`;
-    } else if (stage === 'history_complete') {
-        title = 'Trade History Synced';
-        message = `Trade history for ${username} has been fetched and stored.`;
-    } else if (stage === 'social_complete') {
-        title = 'Social Posts Synced';
-        message = `Social posts for ${username} have been fetched and stored.`;
-    } else if (stage === 'indexing') {
-        title = 'Indexing Data';
-        message = `Indexing data for ${username}...`;
-    } else if (stage === 'computing') {
-        title = 'Computing Metrics';
-        message = `Computing metrics for ${username}...`;
-    }
-    
-    await sendOnDemandNotification(db, logger, requestingUserCid, 'progress', title, message, {
-        requestId,
-        username,
-        stage,
-        dataType,
-        notificationType: 'syncProcesses'
-    }, {
-        ...options,
-        notificationType: 'syncProcesses'
-    });
-}
-
-/**
- * Send notification when task engine completes data fetch
- */
-async function notifyTaskEngineComplete(db, logger, requestingUserCid, requestId, username, success, error = null, options = {}) {
-    if (!requestingUserCid) return; // No user to notify
-    
-    const type = success ? 'success' : 'error';
-    const title = success 
-        ? 'Data Sync Complete' 
-        : 'Data Sync Failed';
-    
-    // Build a more detailed message based on what succeeded
-    let message = '';
-    if (success && typeof success === 'object') {
-        const completed = [];
-        if (success.portfolio) completed.push('portfolio');
-        if (success.history) completed.push('trade history');
-        if (success.social) completed.push('social posts');
-        
-        if (completed.length > 0) {
-            message = `Your data sync for ${username} has completed. ${completed.join(', ')} data ${completed.length === 1 ? 'has' : 'have'} been stored.`;
-        } else {
-            message = `Your data sync for ${username} has completed, but no data was stored.`;
-        }
-    } else if (success) {
-        message = `Your data sync for ${username} has completed. Portfolio, history, and social data have been stored.`;
-    } else {
-        message = error || 'An error occurred while syncing your data. Please try again.';
-    }
-    
-    await sendOnDemandNotification(db, logger, requestingUserCid, type, title, message, {
-        requestId,
-        username,
-        stage: 'task_engine',
-        success: typeof success === 'object' ? success : { portfolio: success, history: success, social: 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, options = {}) {
-    if (!requestingUserCid) return; // No user to notify
-    
-    const type = success ? 'success' : 'error';
-    const title = success
-        ? 'Computation Complete'
-        : 'Computation Failed';
-    const message = success
-        ? `${displayName || computationName} has been computed and stored.`
-        : (error || `Failed to compute ${displayName || computationName}. Please try again.`);
-    
-    await sendOnDemandNotification(db, logger, requestingUserCid, type, title, message, {
-        requestId,
-        computationName,
-        displayName,
-        stage: 'computation',
-        success,
-        notificationType: 'userActionCompletions'
-    }, {
-        ...options,
-        notificationType: 'userActionCompletions'
-    });
-}
-
-/**
- * Get human-readable name for a computation
- */
-function getComputationDisplayName(computationName) {
-    const displayNames = {
-        'SignedInUserProfileMetrics': 'Profile Metrics',
-        'SignedInUserCopiedList': 'Copied Investors List',
-        'SignedInUserCopiedPIs': 'Copied Popular Investors',
-        'SignedInUserPastCopies': 'Past Copy History',
-        'PopularInvestorProfileMetrics': 'Popular Investor Profile',
-        'SignedInUserPIPersonalizedMetrics': 'Personalized Metrics'
-    };
-    
-    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 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,
-        subType,
-        alertType,
-        startDate,
-        endDate
-    } = 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`;
-        }
-        
-        // 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(maxFetchLimit);
-        
-        if (type) {
-            query = query.where('type', '==', type);
-        }
-        
-        if (read !== undefined) {
-            query = query.where('read', '==', read === 'true');
-        }
-        
-        let snapshot;
-        try {
-            snapshot = await query.get();
-        } catch (queryError) {
-            // If query fails (e.g., missing index), try without filters
-            logger.log('WARN', `[getNotificationHistory] Query failed, trying without filters: ${queryError.message}`);
-            query = db.collection(notificationsPath)
-                .orderBy('timestamp', 'desc')
-                .limit(maxFetchLimit);
-            snapshot = await query.get();
-        }
-        
-        const notifications = [];
-        const admin = require('firebase-admin');
-        
-        snapshot.forEach(doc => {
-            const data = doc.data();
-            
-            // 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,
-                    type: data.type || 'other',
-                    subType: data.subType,
-                    title: data.title || '',
-                    message: data.message || '',
-                    read: data.read || false,
-                    timestamp: timestamp.toISOString(),
-                    metadata: data.metadata || {}
-                });
-            }
-        });
-        
-        // 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 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: totalCount,
-            limit: limitNum,
-            offset: offsetNum,
-            hasMore: offsetNum + limitNum < totalCount
-        });
-    } catch (error) {
-        logger.log('ERROR', `[getNotificationHistory] Error fetching notifications for ${userCid}`, error);
-        return res.status(500).json({ error: error.message });
-    }
-}
-
-module.exports = {
-    sendOnDemandNotification,
-    notifyTaskEngineProgress,
-    notifyTaskEngineComplete,
-    notifyComputationComplete,
-    notifyPIDataRefreshed,
-    getComputationDisplayName,
-    getUserNotificationPreferences,
-    shouldSendNotification,
-    getNotificationPreferences,
-    updateNotificationPreferences,
-    getNotificationHistory
-};