bulltrackers-module 1.0.394 → 1.0.396

package/functions/generic-api/user-api/helpers/data_helpers.js

@@ -672,7 +672,9 @@ async function getUserComputations(req, res, dependencies, config) {
 
 /**
  * POST /user/me/watchlist/auto-generate
- * Auto-generates watchlist based on copied PIs from SignedInUserCopiedPIs computation
+ * Auto-generates watchlist based on copied PIs
+ * Primary: Uses SignedInUserCopiedPIs computation (cheaper/faster)
+ * Fallback: Reads portfolio AggregatedMirrors directly if computation not available
  */
 async function autoGenerateWatchlist(req, res, dependencies, config) {
     const { db, logger } = dependencies;
@@ -683,44 +685,137 @@ async function autoGenerateWatchlist(req, res, dependencies, config) {
     }
     
     try {
-        // 1. Fetch SignedInUserCopiedPIs computation result
-        // Computations are stored in unified_insights/{date}/results/{category}/computations/{computationName}
+        let copiedPIs = [];
+        let dataSource = 'unknown';
+        const today = new Date().toISOString().split('T')[0];
+        
+        // === PRIMARY: Try to fetch from computation (cheaper/faster) ===
         const insightsCollection = config.unifiedInsightsCollection || 'unified_insights';
         const category = 'signed_in_user';
-        const today = new Date().toISOString().split('T')[0];
         const computationName = 'SignedInUserCopiedPIs';
         
-        const computationRef = db.collection(insightsCollection)
-            .doc(today)
-            .collection('results')
-            .doc(category)
-            .collection('computations')
-            .doc(computationName);
-        
-        const computationDoc = await computationRef.get();
-        
-        if (!computationDoc.exists) {
-            logger.log('INFO', `[autoGenerateWatchlist] No SignedInUserCopiedPIs computation found for ${userCid} on ${today}`);
-            return res.status(200).json({ 
-                success: true, 
-                generated: 0, 
-                message: "No copied PIs found or computation not yet run" 
-            });
+        // Try to find latest computation date (with fallback)
+        const computationDate = await findLatestComputationDate(
+            db, 
+            insightsCollection, 
+            category, 
+            computationName, 
+            userCid, 
+            30
+        );
+        
+        if (computationDate) {
+            const computationRef = db.collection(insightsCollection)
+                .doc(computationDate)
+                .collection('results')
+                .doc(category)
+                .collection('computations')
+                .doc(computationName);
+            
+            const computationDoc = await computationRef.get();
+            
+            if (computationDoc.exists) {
+                const computationData = computationDoc.data();
+                const userResult = computationData[String(userCid)];
+                
+                if (userResult && userResult.current && userResult.current.length > 0) {
+                    // Convert computation result to our format
+                    copiedPIs = userResult.current.map(cid => ({
+                        cid: Number(cid),
+                        username: 'Unknown' // Username not in computation, will get from rankings
+                    }));
+                    dataSource = 'computation';
+                    logger.log('INFO', `[autoGenerateWatchlist] Using computation data (date: ${computationDate}) for user ${userCid}, found ${copiedPIs.length} copied PIs`);
+                }
+            }
         }
         
-        const computationData = computationDoc.data();
-        // The computation result is stored with user CID as key
-        const userResult = computationData[String(userCid)];
-        const copiedPIs = userResult?.current || [];
+        // === FALLBACK: Read portfolio data directly if computation not available ===
+        if (copiedPIs.length === 0) {
+            logger.log('INFO', `[autoGenerateWatchlist] Computation not available, falling back to direct portfolio read for user ${userCid}`);
+            
+            const { signedInUsersCollection } = config;
+            const CANARY_BLOCK_ID = '19M';
+            
+            // Find latest available portfolio date (with fallback)
+            const portfolioDate = await findLatestPortfolioDate(db, signedInUsersCollection, userCid, 30);
+            
+            if (!portfolioDate) {
+                logger.log('INFO', `[autoGenerateWatchlist] No portfolio data found for ${userCid} (checked last 30 days)`);
+                return res.status(200).json({ 
+                    success: true, 
+                    generated: 0, 
+                    totalCopied: 0,
+                    dataSource: 'none',
+                    message: "No portfolio data found for this user" 
+                });
+            }
+            
+            if (portfolioDate !== today) {
+                logger.log('INFO', `[autoGenerateWatchlist] Using fallback portfolio date ${portfolioDate} for user ${userCid} (today: ${today})`);
+            }
+            
+            // Fetch portfolio from signed_in_users/19M/snapshots/{date}/parts/part_X
+            const partsRef = db.collection(signedInUsersCollection)
+                .doc(CANARY_BLOCK_ID)
+                .collection('snapshots')
+                .doc(portfolioDate)
+                .collection('parts');
+            
+            const partsSnapshot = await partsRef.get();
+            
+            let portfolioData = null;
+            
+            // Search through all parts to find the user's portfolio
+            for (const partDoc of partsSnapshot.docs) {
+                const partData = partDoc.data();
+                if (partData && partData[String(userCid)]) {
+                    portfolioData = partData[String(userCid)];
+                    break;
+                }
+            }
+            
+            if (!portfolioData) {
+                logger.log('WARN', `[autoGenerateWatchlist] Portfolio data not found in parts for ${userCid}`);
+                return res.status(200).json({ 
+                    success: true, 
+                    generated: 0, 
+                    totalCopied: 0,
+                    dataSource: 'none',
+                    message: "Portfolio data not found" 
+                });
+            }
+            
+            // Extract copied PIs from AggregatedMirrors
+            const aggregatedMirrors = portfolioData.AggregatedMirrors || [];
+            
+            for (const mirror of aggregatedMirrors) {
+                const parentCID = mirror.ParentCID;
+                if (parentCID && parentCID > 0) {
+                    copiedPIs.push({
+                        cid: parentCID,
+                        username: mirror.ParentUsername || 'Unknown'
+                    });
+                }
+            }
+            
+            dataSource = 'portfolio';
+            logger.log('INFO', `[autoGenerateWatchlist] Using portfolio data (date: ${portfolioDate}) for user ${userCid}, found ${copiedPIs.length} copied PIs`);
+        }
         
         if (copiedPIs.length === 0) {
+            logger.log('INFO', `[autoGenerateWatchlist] No copied PIs found for user ${userCid} (source: ${dataSource})`);
             return res.status(200).json({ 
                 success: true, 
                 generated: 0, 
+                totalCopied: 0,
+                dataSource: dataSource,
                 message: "User is not currently copying any PIs" 
             });
         }
         
+        logger.log('INFO', `[autoGenerateWatchlist] Found ${copiedPIs.length} copied PIs for user ${userCid} (source: ${dataSource}): ${copiedPIs.map(p => `${p.username} (${p.cid})`).join(', ')}`);
+        
         // 2. Fetch latest rankings data (with fallback to latest available date)
         const rankingsCollection = config.popularInvestorRankingsCollection || process.env.FIRESTORE_COLLECTION_PI_RANKINGS || 'popular_investor_rankings';
         const rankingsDate = await findLatestRankingsDate(db, rankingsCollection, 30);
@@ -753,59 +848,123 @@ async function autoGenerateWatchlist(req, res, dependencies, config) {
             }
         }
         
-        // 3. Match copied CIDs against rankings and create watchlist entries
-        const watchlistsCollection = config.watchlistsCollection || 'watchlists';
-        const watchlistRef = db.collection(watchlistsCollection).doc(String(userCid));
-        const watchlistDoc = await watchlistRef.get();
-        const existingWatchlist = watchlistDoc.exists ? watchlistDoc.data() : {};
-        
-        let generatedCount = 0;
-        const watchlistUpdates = {};
+        // 3. Create watchlist items from copied PIs
+        // Include ALL copied PIs, even if not in rankings (user is copying them, so they should be watched)
+        let matchedCount = 0;
+        const watchlistItems = [];
         
-        for (const copiedCID of copiedPIs) {
-            const cidStr = String(copiedCID);
+        for (const copiedPI of copiedPIs) {
+            const cidStr = String(copiedPI.cid);
             const rankEntry = rankingsMap.get(cidStr);
             
-            if (!rankEntry) {
-                logger.log('INFO', `[autoGenerateWatchlist] Copied PI ${cidStr} not found in rankings, skipping`);
-                continue;
-            }
+            // Use ranking data if available, otherwise use data from portfolio/computation
+            const username = rankEntry?.UserName || copiedPI.username || 'Unknown';
             
-            // Create watchlist entry ID
-            const entryId = `pi_${cidStr}`;
-            
-            // Only add if not already in watchlist
-            if (!existingWatchlist[entryId]) {
-                watchlistUpdates[entryId] = {
-                    type: 'popular_investor',
-                    cid: Number(cidStr),
-                    username: rankEntry.UserName || 'Unknown',
-                    addedAt: FieldValue.serverTimestamp(),
-                    alertConfig: {
-                        newPositions: true,
-                        volatilityChanges: false,
-                        increasedRisk: true,
-                        newSector: false,
-                        increasedPositionSize: false,
-                        newSocialPost: true
-                    },
-                    autoGenerated: true
-                };
-                generatedCount++;
+            if (rankEntry) {
+                matchedCount++;
+            } else {
+                logger.log('INFO', `[autoGenerateWatchlist] Copied PI ${copiedPI.username} (${cidStr}) not found in rankings, but including in watchlist anyway`);
             }
+            
+            watchlistItems.push({
+                cid: Number(cidStr),
+                username: username,
+                addedAt: FieldValue.serverTimestamp(),
+                alertConfig: {
+                    newPositions: true,
+                    volatilityChanges: true,
+                    increasedRisk: true,
+                    newSector: true,
+                    increasedPositionSize: true,
+                    newSocialPost: true
+                }
+            });
         }
         
-        // 4. Write watchlist entries to Firestore
-        if (Object.keys(watchlistUpdates).length > 0) {
-            await watchlistRef.set(watchlistUpdates, { merge: true });
-            logger.log('SUCCESS', `[autoGenerateWatchlist] Generated ${generatedCount} watchlist entries for user ${userCid}`);
+        if (watchlistItems.length === 0) {
+            logger.log('INFO', `[autoGenerateWatchlist] No PIs matched in rankings for user ${userCid}`);
+            return res.status(200).json({
+                success: true,
+                generated: 0,
+                totalCopied: copiedPIs.length,
+                matchedInRankings: 0,
+                dataSource: dataSource,
+                message: "No copied PIs found in rankings"
+            });
         }
         
+        // 4. Create or update the auto-generated watchlist using new structure
+        // The auto-generated watchlist should always reflect the CURRENT state of copied PIs
+        const watchlistsCollection = config.watchlistsCollection || 'watchlists';
+        const userWatchlistsRef = db.collection(watchlistsCollection)
+            .doc(String(userCid))
+            .collection('lists');
+        
+        // Check if auto-generated watchlist already exists
+        const existingWatchlistsSnapshot = await userWatchlistsRef
+            .where('isAutoGenerated', '==', true)
+            .limit(1)
+            .get();
+        
+        let watchlistId;
+        let generatedCount = watchlistItems.length;
+        
+        if (!existingWatchlistsSnapshot.empty) {
+            // Update existing auto-generated watchlist
+            // Replace items entirely to match current copied PIs (sync, not append)
+            const existingDoc = existingWatchlistsSnapshot.docs[0];
+            watchlistId = existingDoc.id;
+            const existingData = existingDoc.data();
+            const existingItems = existingData.items || [];
+            
+            // Calculate what changed
+            const existingCIDs = new Set(existingItems.map(item => item.cid));
+            const newCIDs = new Set(watchlistItems.map(item => item.cid));
+            
+            const added = watchlistItems.filter(item => !existingCIDs.has(item.cid));
+            const removed = existingItems.filter(item => !newCIDs.has(item.cid));
+            
+            // Replace entire items array to sync with current copied PIs
+            await existingDoc.ref.update({
+                items: watchlistItems, // Full replacement to match current state
+                updatedAt: FieldValue.serverTimestamp()
+            });
+            
+            logger.log('SUCCESS', `[autoGenerateWatchlist] Synced auto-generated watchlist ${watchlistId} for user ${userCid}: ${added.length} added, ${removed.length} removed, ${watchlistItems.length} total`);
+        } else {
+            // Create new auto-generated watchlist
+            const crypto = require('crypto');
+            watchlistId = `watchlist_${Date.now()}_${crypto.randomBytes(4).toString('hex')}`;
+            
+            const watchlistData = {
+                id: watchlistId,
+                name: 'My Copy Watchlist', // Hardcoded name as requested
+                type: 'static',
+                visibility: 'private',
+                createdBy: Number(userCid),
+                createdAt: FieldValue.serverTimestamp(),
+                updatedAt: FieldValue.serverTimestamp(),
+                isAutoGenerated: true,
+                copyCount: 0,
+                items: watchlistItems
+            };
+            
+            await userWatchlistsRef.doc(watchlistId).set(watchlistData);
+            logger.log('SUCCESS', `[autoGenerateWatchlist] Created auto-generated watchlist ${watchlistId} with ${watchlistItems.length} items for user ${userCid}`);
+        }
+        
+        // 5. Create subscriptions for all items in the watchlist
+        // This will be handled by the subscription system, but we log it here
+        logger.log('INFO', `[autoGenerateWatchlist] Watchlist ${watchlistId} ready for subscription setup (${watchlistItems.length} items)`);
+        
         return res.status(200).json({
             success: true,
             generated: generatedCount,
             totalCopied: copiedPIs.length,
-            message: `Generated ${generatedCount} watchlist entries from ${copiedPIs.length} copied PIs`
+            matchedInRankings: matchedCount,
+            dataSource: dataSource,
+            watchlistId: watchlistId,
+            message: `Generated ${generatedCount} watchlist entries from ${copiedPIs.length} copied PIs (${matchedCount} matched in rankings, source: ${dataSource})`
         });
         
     } catch (error) {

package/functions/generic-api/user-api/helpers/subscription_helpers.js

@@ -0,0 +1,328 @@
+/**
+ * @fileoverview Alert Subscription Management Helpers
+ * Handles subscriptions for watchlist alerts (static and dynamic)
+ */
+
+const { FieldValue } = require('@google-cloud/firestore');
+
+/**
+ * POST /user/me/subscriptions
+ * Subscribe to alerts for a PI in a watchlist
+ */
+async function subscribeToAlerts(req, res, dependencies, config) {
+    const { db, logger } = dependencies;
+    const { userCid, watchlistId, piCid, alertTypes, thresholds } = req.body;
+    
+    if (!userCid || !watchlistId || !piCid) {
+        return res.status(400).json({ error: "Missing required fields: userCid, watchlistId, piCid" });
+    }
+    
+    try {
+        // Verify watchlist exists and belongs to user
+        const watchlistsCollection = config.watchlistsCollection || 'watchlists';
+        const watchlistRef = db.collection(watchlistsCollection)
+            .doc(String(userCid))
+            .collection('lists')
+            .doc(watchlistId);
+        
+        const watchlistDoc = await watchlistRef.get();
+        
+        if (!watchlistDoc.exists) {
+            return res.status(404).json({ error: "Watchlist not found" });
+        }
+        
+        const watchlistData = watchlistDoc.data();
+        
+        // Verify PI is in the watchlist
+        let piInWatchlist = false;
+        if (watchlistData.type === 'static') {
+            piInWatchlist = watchlistData.items?.some(item => item.cid === Number(piCid));
+        } else if (watchlistData.type === 'dynamic') {
+            // For dynamic watchlists, we'll check if the PI is in the current computation result
+            // This is a simplified check - in production, you'd fetch the latest computation result
+            piInWatchlist = true; // Allow subscriptions for dynamic watchlists
+        }
+        
+        if (!piInWatchlist && watchlistData.type === 'static') {
+            return res.status(400).json({ error: "PI is not in this watchlist" });
+        }
+        
+        // Default alert types (all enabled) if not provided
+        const defaultAlertTypes = {
+            newPositions: true,
+            volatilityChanges: true,
+            increasedRisk: true,
+            newSector: true,
+            increasedPositionSize: true,
+            newSocialPost: true
+        };
+        
+        const subscriptionData = {
+            userCid: Number(userCid),
+            piCid: Number(piCid),
+            watchlistId: watchlistId,
+            alertTypes: alertTypes || defaultAlertTypes,
+            thresholds: thresholds || {},
+            subscribedAt: FieldValue.serverTimestamp(),
+            lastAlertAt: null
+        };
+        
+        // Store subscription
+        const subscriptionsCollection = config.watchlistSubscriptionsCollection || 'watchlist_subscriptions';
+        const subscriptionRef = db.collection(subscriptionsCollection)
+            .doc(String(userCid))
+            .collection('alerts')
+            .doc(String(piCid));
+        
+        await subscriptionRef.set(subscriptionData, { merge: true });
+        
+        logger.log('SUCCESS', `[subscribeToAlerts] User ${userCid} subscribed to alerts for PI ${piCid} in watchlist ${watchlistId}`);
+        
+        return res.status(200).json({
+            success: true,
+            subscription: subscriptionData
+        });
+        
+    } catch (error) {
+        logger.log('ERROR', `[subscribeToAlerts] Error creating subscription for user ${userCid}`, error);
+        return res.status(500).json({ error: error.message });
+    }
+}
+
+/**
+ * PUT /user/me/subscriptions/:piCid
+ * Update alert subscription settings
+ */
+async function updateSubscription(req, res, dependencies, config) {
+    const { db, logger } = dependencies;
+    const { userCid } = req.query;
+    const { piCid } = req.params;
+    const { alertTypes, thresholds } = req.body;
+    
+    if (!userCid || !piCid) {
+        return res.status(400).json({ error: "Missing userCid or piCid" });
+    }
+    
+    try {
+        const subscriptionsCollection = config.watchlistSubscriptionsCollection || 'watchlist_subscriptions';
+        const subscriptionRef = db.collection(subscriptionsCollection)
+            .doc(String(userCid))
+            .collection('alerts')
+            .doc(String(piCid));
+        
+        const subscriptionDoc = await subscriptionRef.get();
+        
+        if (!subscriptionDoc.exists) {
+            return res.status(404).json({ error: "Subscription not found" });
+        }
+        
+        const updates = {};
+        
+        if (alertTypes !== undefined) {
+            updates.alertTypes = alertTypes;
+        }
+        
+        if (thresholds !== undefined) {
+            updates.thresholds = thresholds;
+        }
+        
+        if (Object.keys(updates).length === 0) {
+            return res.status(400).json({ error: "No updates provided" });
+        }
+        
+        updates.updatedAt = FieldValue.serverTimestamp();
+        
+        await subscriptionRef.update(updates);
+        
+        logger.log('SUCCESS', `[updateSubscription] Updated subscription for user ${userCid}, PI ${piCid}`);
+        
+        const updatedDoc = await subscriptionRef.get();
+        return res.status(200).json({
+            success: true,
+            subscription: {
+                id: updatedDoc.id,
+                ...updatedDoc.data()
+            }
+        });
+        
+    } catch (error) {
+        logger.log('ERROR', `[updateSubscription] Error updating subscription for user ${userCid}`, error);
+        return res.status(500).json({ error: error.message });
+    }
+}
+
+/**
+ * DELETE /user/me/subscriptions/:piCid
+ * Unsubscribe from alerts for a PI
+ */
+async function unsubscribeFromAlerts(req, res, dependencies, config) {
+    const { db, logger } = dependencies;
+    const { userCid } = req.query;
+    const { piCid } = req.params;
+    
+    if (!userCid || !piCid) {
+        return res.status(400).json({ error: "Missing userCid or piCid" });
+    }
+    
+    try {
+        const subscriptionsCollection = config.watchlistSubscriptionsCollection || 'watchlist_subscriptions';
+        const subscriptionRef = db.collection(subscriptionsCollection)
+            .doc(String(userCid))
+            .collection('alerts')
+            .doc(String(piCid));
+        
+        const subscriptionDoc = await subscriptionRef.get();
+        
+        if (!subscriptionDoc.exists) {
+            return res.status(404).json({ error: "Subscription not found" });
+        }
+        
+        await subscriptionRef.delete();
+        
+        logger.log('SUCCESS', `[unsubscribeFromAlerts] User ${userCid} unsubscribed from alerts for PI ${piCid}`);
+        
+        return res.status(200).json({
+            success: true,
+            message: "Unsubscribed successfully"
+        });
+        
+    } catch (error) {
+        logger.log('ERROR', `[unsubscribeFromAlerts] Error unsubscribing user ${userCid} from PI ${piCid}`, error);
+        return res.status(500).json({ error: error.message });
+    }
+}
+
+/**
+ * GET /user/me/subscriptions
+ * Get all subscriptions for a user
+ */
+async function getUserSubscriptions(req, res, dependencies, config) {
+    const { db, logger } = dependencies;
+    const { userCid } = req.query;
+    
+    if (!userCid) {
+        return res.status(400).json({ error: "Missing userCid" });
+    }
+    
+    try {
+        const subscriptionsCollection = config.watchlistSubscriptionsCollection || 'watchlist_subscriptions';
+        const subscriptionsRef = db.collection(subscriptionsCollection)
+            .doc(String(userCid))
+            .collection('alerts');
+        
+        const snapshot = await subscriptionsRef.get();
+        
+        const subscriptions = [];
+        snapshot.forEach(doc => {
+            subscriptions.push({
+                piCid: Number(doc.id),
+                ...doc.data()
+            });
+        });
+        
+        return res.status(200).json({
+            subscriptions,
+            count: subscriptions.length
+        });
+        
+    } catch (error) {
+        logger.log('ERROR', `[getUserSubscriptions] Error fetching subscriptions for user ${userCid}`, error);
+        return res.status(500).json({ error: error.message });
+    }
+}
+
+/**
+ * POST /user/me/watchlists/:id/subscribe-all
+ * Subscribe to all PIs in a watchlist with default alert settings
+ */
+async function subscribeToWatchlist(req, res, dependencies, config) {
+    const { db, logger } = dependencies;
+    const { userCid } = req.query;
+    const { id } = req.params;
+    const { alertTypes, thresholds } = req.body;
+    
+    if (!userCid || !id) {
+        return res.status(400).json({ error: "Missing userCid or watchlist id" });
+    }
+    
+    try {
+        // Get watchlist
+        const watchlistsCollection = config.watchlistsCollection || 'watchlists';
+        const watchlistRef = db.collection(watchlistsCollection)
+            .doc(String(userCid))
+            .collection('lists')
+            .doc(id);
+        
+        const watchlistDoc = await watchlistRef.get();
+        
+        if (!watchlistDoc.exists) {
+            return res.status(404).json({ error: "Watchlist not found" });
+        }
+        
+        const watchlistData = watchlistDoc.data();
+        
+        // Default alert types
+        const defaultAlertTypes = alertTypes || {
+            newPositions: true,
+            volatilityChanges: true,
+            increasedRisk: true,
+            newSector: true,
+            increasedPositionSize: true,
+            newSocialPost: true
+        };
+        
+        const subscriptionsCollection = config.watchlistSubscriptionsCollection || 'watchlist_subscriptions';
+        const subscriptionsRef = db.collection(subscriptionsCollection)
+            .doc(String(userCid))
+            .collection('alerts');
+        
+        let subscribedCount = 0;
+        
+        if (watchlistData.type === 'static') {
+            // Subscribe to all PIs in static watchlist
+            const items = watchlistData.items || [];
+            
+            for (const item of items) {
+                const subscriptionData = {
+                    userCid: Number(userCid),
+                    piCid: item.cid,
+                    watchlistId: id,
+                    alertTypes: item.alertConfig || defaultAlertTypes,
+                    thresholds: thresholds || {},
+                    subscribedAt: FieldValue.serverTimestamp(),
+                    lastAlertAt: null
+                };
+                
+                await subscriptionsRef.doc(String(item.cid)).set(subscriptionData, { merge: true });
+                subscribedCount++;
+            }
+        } else if (watchlistData.type === 'dynamic') {
+            // For dynamic watchlists, we'd need to fetch the current computation result
+            // For now, we'll just set up the subscription structure
+            // The actual PIs will be determined when the computation runs
+            logger.log('INFO', `[subscribeToWatchlist] Dynamic watchlist subscription setup for ${id} (will be populated by computation)`);
+        }
+        
+        logger.log('SUCCESS', `[subscribeToWatchlist] Subscribed user ${userCid} to ${subscribedCount} PIs in watchlist ${id}`);
+        
+        return res.status(200).json({
+            success: true,
+            subscribed: subscribedCount,
+            watchlistId: id,
+            watchlistType: watchlistData.type
+        });
+        
+    } catch (error) {
+        logger.log('ERROR', `[subscribeToWatchlist] Error subscribing to watchlist ${id} for user ${userCid}`, error);
+        return res.status(500).json({ error: error.message });
+    }
+}
+
+module.exports = {
+    subscribeToAlerts,
+    updateSubscription,
+    unsubscribeFromAlerts,
+    getUserSubscriptions,
+    subscribeToWatchlist
+};
+

package/functions/generic-api/user-api/helpers/watchlist_helpers.js

@@ -0,0 +1,466 @@
+/**
+ * @fileoverview Watchlist Management Helpers
+ * Handles CRUD operations for user watchlists (static and dynamic)
+ */
+
+const { FieldValue } = require('@google-cloud/firestore');
+const crypto = require('crypto');
+
+/**
+ * Generate unique watchlist ID
+ */
+function generateWatchlistId() {
+    return `watchlist_${Date.now()}_${crypto.randomBytes(4).toString('hex')}`;
+}
+
+/**
+ * GET /user/me/watchlists
+ * List all watchlists for a user
+ */
+async function getUserWatchlists(req, res, dependencies, config) {
+    const { db, logger } = dependencies;
+    const { userCid } = req.query;
+    
+    if (!userCid) {
+        return res.status(400).json({ error: "Missing userCid" });
+    }
+    
+    try {
+        const watchlistsCollection = config.watchlistsCollection || 'watchlists';
+        const userWatchlistsRef = db.collection(watchlistsCollection)
+            .doc(String(userCid))
+            .collection('lists');
+        
+        const snapshot = await userWatchlistsRef.get();
+        
+        const watchlists = [];
+        snapshot.forEach(doc => {
+            watchlists.push({
+                id: doc.id,
+                ...doc.data()
+            });
+        });
+        
+        // Sort by creation date (newest first)
+        watchlists.sort((a, b) => {
+            const aTime = a.createdAt?.seconds || 0;
+            const bTime = b.createdAt?.seconds || 0;
+            return bTime - aTime;
+        });
+        
+        return res.status(200).json({
+            watchlists,
+            count: watchlists.length
+        });
+        
+    } catch (error) {
+        logger.log('ERROR', `[getUserWatchlists] Error fetching watchlists for ${userCid}`, error);
+        return res.status(500).json({ error: error.message });
+    }
+}
+
+/**
+ * GET /user/me/watchlists/:id
+ * Get a specific watchlist
+ */
+async function getWatchlist(req, res, dependencies, config) {
+    const { db, logger } = dependencies;
+    const { userCid } = req.query;
+    const { id } = req.params;
+    
+    if (!userCid || !id) {
+        return res.status(400).json({ error: "Missing userCid or watchlist id" });
+    }
+    
+    try {
+        const watchlistsCollection = config.watchlistsCollection || 'watchlists';
+        const watchlistRef = db.collection(watchlistsCollection)
+            .doc(String(userCid))
+            .collection('lists')
+            .doc(id);
+        
+        const watchlistDoc = await watchlistRef.get();
+        
+        if (!watchlistDoc.exists) {
+            return res.status(404).json({ error: "Watchlist not found" });
+        }
+        
+        return res.status(200).json({
+            id: watchlistDoc.id,
+            ...watchlistDoc.data()
+        });
+        
+    } catch (error) {
+        logger.log('ERROR', `[getWatchlist] Error fetching watchlist ${id} for ${userCid}`, error);
+        return res.status(500).json({ error: error.message });
+    }
+}
+
+/**
+ * POST /user/me/watchlists
+ * Create a new watchlist
+ */
+async function createWatchlist(req, res, dependencies, config) {
+    const { db, logger } = dependencies;
+    const { userCid, name, type, visibility = 'private', items, dynamicConfig } = req.body;
+    
+    if (!userCid || !name || !type) {
+        return res.status(400).json({ error: "Missing required fields: userCid, name, type" });
+    }
+    
+    if (type !== 'static' && type !== 'dynamic') {
+        return res.status(400).json({ error: "Type must be 'static' or 'dynamic'" });
+    }
+    
+    if (visibility !== 'public' && visibility !== 'private') {
+        return res.status(400).json({ error: "Visibility must be 'public' or 'private'" });
+    }
+    
+    try {
+        const watchlistsCollection = config.watchlistsCollection || 'watchlists';
+        const watchlistId = generateWatchlistId();
+        
+        const watchlistData = {
+            id: watchlistId,
+            name: name.trim(),
+            type,
+            visibility,
+            createdBy: Number(userCid),
+            createdAt: FieldValue.serverTimestamp(),
+            updatedAt: FieldValue.serverTimestamp(),
+            isAutoGenerated: false,
+            copyCount: 0
+        };
+        
+        if (type === 'static') {
+            watchlistData.items = items || [];
+        } else if (type === 'dynamic') {
+            if (!dynamicConfig || !dynamicConfig.computationName) {
+                return res.status(400).json({ error: "Dynamic watchlists require dynamicConfig with computationName" });
+            }
+            watchlistData.dynamicConfig = dynamicConfig;
+        }
+        
+        const watchlistRef = db.collection(watchlistsCollection)
+            .doc(String(userCid))
+            .collection('lists')
+            .doc(watchlistId);
+        
+        await watchlistRef.set(watchlistData);
+        
+        // If public, also add to public watchlists collection
+        if (visibility === 'public') {
+            const publicRef = db.collection('public_watchlists').doc(watchlistId);
+            await publicRef.set({
+                watchlistId,
+                createdBy: Number(userCid),
+                name: watchlistData.name,
+                type,
+                description: dynamicConfig?.description || '',
+                copyCount: 0,
+                createdAt: FieldValue.serverTimestamp(),
+                updatedAt: FieldValue.serverTimestamp()
+            });
+        }
+        
+        logger.log('SUCCESS', `[createWatchlist] Created ${type} watchlist "${name}" for user ${userCid}`);
+        
+        return res.status(201).json({
+            success: true,
+            watchlist: {
+                id: watchlistId,
+                ...watchlistData
+            }
+        });
+        
+    } catch (error) {
+        logger.log('ERROR', `[createWatchlist] Error creating watchlist for ${userCid}`, error);
+        return res.status(500).json({ error: error.message });
+    }
+}
+
+/**
+ * PUT /user/me/watchlists/:id
+ * Update a watchlist
+ */
+async function updateWatchlist(req, res, dependencies, config) {
+    const { db, logger } = dependencies;
+    const { userCid } = req.query;
+    const { id } = req.params;
+    const { name, visibility, items, dynamicConfig } = req.body;
+    
+    if (!userCid || !id) {
+        return res.status(400).json({ error: "Missing userCid or watchlist id" });
+    }
+    
+    try {
+        const watchlistsCollection = config.watchlistsCollection || 'watchlists';
+        const watchlistRef = db.collection(watchlistsCollection)
+            .doc(String(userCid))
+            .collection('lists')
+            .doc(id);
+        
+        const watchlistDoc = await watchlistRef.get();
+        
+        if (!watchlistDoc.exists) {
+            return res.status(404).json({ error: "Watchlist not found" });
+        }
+        
+        const existingData = watchlistDoc.data();
+        
+        // Verify ownership
+        if (existingData.createdBy !== Number(userCid)) {
+            return res.status(403).json({ error: "You can only modify your own watchlists" });
+        }
+        
+        const updates = {
+            updatedAt: FieldValue.serverTimestamp()
+        };
+        
+        if (name !== undefined) {
+            updates.name = name.trim();
+        }
+        
+        if (visibility !== undefined) {
+            if (visibility !== 'public' && visibility !== 'private') {
+                return res.status(400).json({ error: "Visibility must be 'public' or 'private'" });
+            }
+            updates.visibility = visibility;
+            
+            // Update public watchlists collection
+            const publicRef = db.collection('public_watchlists').doc(id);
+            if (visibility === 'public') {
+                await publicRef.set({
+                    watchlistId: id,
+                    createdBy: existingData.createdBy,
+                    name: updates.name || existingData.name,
+                    type: existingData.type,
+                    description: dynamicConfig?.description || '',
+                    copyCount: existingData.copyCount || 0,
+                    createdAt: existingData.createdAt,
+                    updatedAt: FieldValue.serverTimestamp()
+                }, { merge: true });
+            } else {
+                // Remove from public if making private
+                await publicRef.delete();
+            }
+        }
+        
+        if (items !== undefined && existingData.type === 'static') {
+            updates.items = items;
+        }
+        
+        if (dynamicConfig !== undefined && existingData.type === 'dynamic') {
+            updates.dynamicConfig = dynamicConfig;
+        }
+        
+        await watchlistRef.update(updates);
+        
+        logger.log('SUCCESS', `[updateWatchlist] Updated watchlist ${id} for user ${userCid}`);
+        
+        const updatedDoc = await watchlistRef.get();
+        return res.status(200).json({
+            success: true,
+            watchlist: {
+                id: updatedDoc.id,
+                ...updatedDoc.data()
+            }
+        });
+        
+    } catch (error) {
+        logger.log('ERROR', `[updateWatchlist] Error updating watchlist ${id} for ${userCid}`, error);
+        return res.status(500).json({ error: error.message });
+    }
+}
+
+/**
+ * DELETE /user/me/watchlists/:id
+ * Delete a watchlist
+ */
+async function deleteWatchlist(req, res, dependencies, config) {
+    const { db, logger } = dependencies;
+    const { userCid } = req.query;
+    const { id } = req.params;
+    
+    if (!userCid || !id) {
+        return res.status(400).json({ error: "Missing userCid or watchlist id" });
+    }
+    
+    try {
+        const watchlistsCollection = config.watchlistsCollection || 'watchlists';
+        const watchlistRef = db.collection(watchlistsCollection)
+            .doc(String(userCid))
+            .collection('lists')
+            .doc(id);
+        
+        const watchlistDoc = await watchlistRef.get();
+        
+        if (!watchlistDoc.exists) {
+            return res.status(404).json({ error: "Watchlist not found" });
+        }
+        
+        const watchlistData = watchlistDoc.data();
+        
+        // Verify ownership
+        if (watchlistData.createdBy !== Number(userCid)) {
+            return res.status(403).json({ error: "You can only delete your own watchlists" });
+        }
+        
+        // Delete watchlist
+        await watchlistRef.delete();
+        
+        // Remove from public watchlists if it was public
+        if (watchlistData.visibility === 'public') {
+            const publicRef = db.collection('public_watchlists').doc(id);
+            await publicRef.delete();
+        }
+        
+        // TODO: Clean up subscriptions for this watchlist
+        // This would require deleting entries in watchlist_subscriptions collection
+        
+        logger.log('SUCCESS', `[deleteWatchlist] Deleted watchlist ${id} for user ${userCid}`);
+        
+        return res.status(200).json({
+            success: true,
+            message: "Watchlist deleted successfully"
+        });
+        
+    } catch (error) {
+        logger.log('ERROR', `[deleteWatchlist] Error deleting watchlist ${id} for ${userCid}`, error);
+        return res.status(500).json({ error: error.message });
+    }
+}
+
+/**
+ * POST /user/me/watchlists/:id/copy
+ * Copy a public watchlist
+ */
+async function copyWatchlist(req, res, dependencies, config) {
+    const { db, logger } = dependencies;
+    const { userCid } = req.query;
+    const { id } = req.params;
+    const { name } = req.body; // Optional custom name
+    
+    if (!userCid || !id) {
+        return res.status(400).json({ error: "Missing userCid or watchlist id" });
+    }
+    
+    try {
+        // First, try to find in public watchlists
+        const publicRef = db.collection('public_watchlists').doc(id);
+        const publicDoc = await publicRef.get();
+        
+        if (!publicDoc.exists) {
+            return res.status(404).json({ error: "Public watchlist not found" });
+        }
+        
+        const publicData = publicDoc.data();
+        
+        // Find the original watchlist
+        const originalRef = db.collection(config.watchlistsCollection || 'watchlists')
+            .doc(String(publicData.createdBy))
+            .collection('lists')
+            .doc(id);
+        
+        const originalDoc = await originalRef.get();
+        
+        if (!originalDoc.exists) {
+            return res.status(404).json({ error: "Original watchlist not found" });
+        }
+        
+        const originalData = originalDoc.data();
+        
+        // Create new watchlist for the copying user
+        const newWatchlistId = generateWatchlistId();
+        const watchlistData = {
+            ...originalData,
+            id: newWatchlistId,
+            name: name || `${originalData.name} (Copy)`,
+            createdBy: Number(userCid),
+            visibility: 'private', // Copied watchlists are always private
+            copiedFrom: id,
+            createdAt: FieldValue.serverTimestamp(),
+            updatedAt: FieldValue.serverTimestamp(),
+            isAutoGenerated: false
+        };
+        
+        // Remove fields that shouldn't be copied
+        delete watchlistData.copyCount;
+        
+        const newWatchlistRef = db.collection(config.watchlistsCollection || 'watchlists')
+            .doc(String(userCid))
+            .collection('lists')
+            .doc(newWatchlistId);
+        
+        await newWatchlistRef.set(watchlistData);
+        
+        // Increment copy count on original
+        await publicRef.update({
+            copyCount: FieldValue.increment(1),
+            updatedAt: FieldValue.serverTimestamp()
+        });
+        
+        logger.log('SUCCESS', `[copyWatchlist] User ${userCid} copied watchlist ${id} as ${newWatchlistId}`);
+        
+        return res.status(201).json({
+            success: true,
+            watchlist: {
+                id: newWatchlistId,
+                ...watchlistData
+            }
+        });
+        
+    } catch (error) {
+        logger.log('ERROR', `[copyWatchlist] Error copying watchlist ${id} for ${userCid}`, error);
+        return res.status(500).json({ error: error.message });
+    }
+}
+
+/**
+ * GET /user/public-watchlists
+ * Browse public watchlists
+ */
+async function getPublicWatchlists(req, res, dependencies, config) {
+    const { db, logger } = dependencies;
+    const { limit = 50, offset = 0 } = req.query;
+    
+    try {
+        const publicRef = db.collection('public_watchlists')
+            .orderBy('copyCount', 'desc')
+            .orderBy('createdAt', 'desc')
+            .limit(parseInt(limit))
+            .offset(parseInt(offset));
+        
+        const snapshot = await publicRef.get();
+        
+        const watchlists = [];
+        snapshot.forEach(doc => {
+            watchlists.push({
+                id: doc.id,
+                ...doc.data()
+            });
+        });
+        
+        return res.status(200).json({
+            watchlists,
+            count: watchlists.length,
+            limit: parseInt(limit),
+            offset: parseInt(offset)
+        });
+        
+    } catch (error) {
+        logger.log('ERROR', `[getPublicWatchlists] Error fetching public watchlists`, error);
+        return res.status(500).json({ error: error.message });
+    }
+}
+
+module.exports = {
+    getUserWatchlists,
+    getWatchlist,
+    createWatchlist,
+    updateWatchlist,
+    deleteWatchlist,
+    copyWatchlist,
+    getPublicWatchlists
+};
+

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

@@ -6,6 +6,8 @@ const express = require('express');
 const { submitReview, getReviews } = require('./helpers/review_helpers');
 const { getPiAnalytics, getUserRecommendations, getWatchlist, updateWatchlist, autoGenerateWatchlist, getUserDataStatus, getUserPortfolio, getUserSocialPosts, getUserComputations, getUserVerification, getInstrumentMappings } = require('./helpers/data_helpers');
 const { initiateVerification, finalizeVerification } = require('./helpers/verification_helpers');
+const { getUserWatchlists, getWatchlist: getWatchlistById, createWatchlist, updateWatchlist: updateWatchlistById, deleteWatchlist, copyWatchlist, getPublicWatchlists } = require('./helpers/watchlist_helpers');
+const { subscribeToAlerts, updateSubscription, unsubscribeFromAlerts, getUserSubscriptions, subscribeToWatchlist } = require('./helpers/subscription_helpers');
 
 module.exports = (dependencies, config) => {
     const router = express.Router();
@@ -33,9 +35,28 @@ module.exports = (dependencies, config) => {
     router.get('/me/instrument-mappings', (req, res) => getInstrumentMappings(req, res, dependencies, config));
 
     // --- Watchlist & Alerts ---
+    // Legacy single watchlist endpoints (for backward compatibility)
     router.get('/me/watchlist', (req, res) => getWatchlist(req, res, dependencies, config));
     router.post('/watchlist', (req, res) => updateWatchlist(req, res, dependencies, config));
     router.post('/me/watchlist/auto-generate', (req, res) => autoGenerateWatchlist(req, res, dependencies, config));
-
+    
+    // New multi-watchlist endpoints
+    router.get('/me/watchlists', (req, res) => getUserWatchlists(req, res, dependencies, config));
+    router.post('/me/watchlists', (req, res) => createWatchlist(req, res, dependencies, config));
+    router.get('/me/watchlists/:id', (req, res) => getWatchlistById(req, res, dependencies, config));
+    router.put('/me/watchlists/:id', (req, res) => updateWatchlistById(req, res, dependencies, config));
+    router.delete('/me/watchlists/:id', (req, res) => deleteWatchlist(req, res, dependencies, config));
+    router.post('/me/watchlists/:id/copy', (req, res) => copyWatchlist(req, res, dependencies, config));
+    
+    // Public watchlists
+    router.get('/public-watchlists', (req, res) => getPublicWatchlists(req, res, dependencies, config));
+    
+    // --- Alert Subscriptions ---
+    router.post('/me/subscriptions', (req, res) => subscribeToAlerts(req, res, dependencies, config));
+    router.get('/me/subscriptions', (req, res) => getUserSubscriptions(req, res, dependencies, config));
+    router.put('/me/subscriptions/:piCid', (req, res) => updateSubscription(req, res, dependencies, config));
+    router.delete('/me/subscriptions/:piCid', (req, res) => unsubscribeFromAlerts(req, res, dependencies, config));
+    router.post('/me/watchlists/:id/subscribe-all', (req, res) => subscribeToWatchlist(req, res, dependencies, config));
+    
     return router;
 };

package/package.json

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