bulltrackers-module 1.0.629 → 1.0.631

package/functions/old-generic-api/user-api/helpers/watchlist/watchlist_generation_helpers.js

@@ -1,310 +0,0 @@
-/**
- * @fileoverview Watchlist Generation Helpers
- * Handles auto-generation of watchlists from copied PIs
- */
-
-const { FieldValue } = require('@google-cloud/firestore');
-const { findLatestPortfolioDate, findLatestComputationDate } = require('../core/data_lookup_helpers');
-const { tryDecompress } = require('../core/compression_helpers');
-const { getEffectiveCid, getCopiedPIsWithDevOverride } = require('../dev/dev_helpers');
-const { writeWithMigration } = require('../core/path_resolution_helpers');
-const { getPIMasterList, getPIUsernameFromMasterList } = require('../core/user_status_helpers');
-
-/**
- * POST /user/me/watchlist/auto-generate
- * 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;
-    const { userCid } = req.body;
-    
-    if (!userCid) {
-        return res.status(400).json({ error: "Missing userCid" });
-    }
-    
-    try {
-        const effectiveCid = await getEffectiveCid(db, userCid, config, logger);
-        
-        let copiedPIs = [];
-        let dataSource = 'unknown';
-        let isDevOverride = false;
-        const today = new Date().toISOString().split('T')[0];
-        
-        // === DEV OVERRIDE CHECK ===
-        const devResult = await getCopiedPIsWithDevOverride(db, userCid, config, logger);
-        if (devResult.isDevOverride) {
-            copiedPIs = devResult.copiedPIs;
-            dataSource = devResult.dataSource;
-            isDevOverride = true;
-            logger.log('INFO', `[autoGenerateWatchlist] Using DEV OVERRIDE for user ${userCid}, found ${copiedPIs.length} fake copied PIs`);
-        }
-        
-        // === PRIMARY: Try to fetch from computation ===
-        if (!isDevOverride) {
-            const insightsCollection = config.unifiedInsightsCollection || 'unified_insights';
-            const category = 'signed_in_user';
-            const computationName = 'SignedInUserCopiedPIs';
-            const resultsSub = config.resultsSubcollection || 'results';
-            const compsSub = config.computationsSubcollection || 'computations';
-            
-            const computationDate = await findLatestComputationDate(
-                db, 
-                insightsCollection,
-                resultsSub,
-                compsSub,
-                category, 
-                computationName, 
-                effectiveCid, 
-                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 rawData = computationDoc.data();
-                    const computationData = tryDecompress(rawData);
-                    const userResult = computationData && typeof computationData === 'object' ? computationData[String(effectiveCid)] : null;
-                    
-                    if (userResult && userResult.current && userResult.current.length > 0) {
-                        copiedPIs = userResult.current.map(cid => ({
-                            cid: Number(cid),
-                            username: 'Unknown'
-                        }));
-                        dataSource = 'computation';
-                        logger.log('INFO', `[autoGenerateWatchlist] Using computation data (date: ${computationDate}) for user ${userCid}, found ${copiedPIs.length} copied PIs`);
-                    }
-                }
-            }
-        }
-        
-        // === FALLBACK: Read portfolio data directly ===
-        if (!isDevOverride && 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';
-            const portfolioDate = await findLatestPortfolioDate(db, signedInUsersCollection, userCid, 30);
-            
-            if (!portfolioDate) {
-                return res.status(200).json({ 
-                    success: true, 
-                    generated: 0, 
-                    totalCopied: 0,
-                    dataSource: 'none',
-                    message: "No portfolio data found for this user" 
-                });
-            }
-            
-            const partsRef = db.collection(signedInUsersCollection)
-                .doc(CANARY_BLOCK_ID)
-                .collection('snapshots')
-                .doc(portfolioDate)
-                .collection('parts');
-            
-            const partsSnapshot = await partsRef.get();
-            let portfolioData = null;
-            
-            for (const partDoc of partsSnapshot.docs) {
-                const partData = partDoc.data();
-                if (partData && partData[String(userCid)]) {
-                    portfolioData = partData[String(userCid)];
-                    break;
-                }
-            }
-            
-            if (portfolioData) {
-                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';
-            }
-        }
-        
-        if (copiedPIs.length === 0) {
-            return res.status(200).json({ 
-                success: true, 
-                generated: 0, 
-                totalCopied: 0,
-                dataSource: dataSource,
-                message: "User is not currently copying any PIs" 
-            });
-        }
-        
-        // Get usernames from master list (single source of truth)
-        const collectionRegistry = dependencies.collectionRegistry || null;
-        const investors = await getPIMasterList(db, collectionRegistry, logger);
-        
-        // Create watchlist items
-        let matchedCount = 0;
-        const watchlistItems = [];
-        
-        for (const copiedPI of copiedPIs) {
-            const cidStr = String(copiedPI.cid);
-            // Try to get username from master list
-            const username = await getPIUsernameFromMasterList(db, cidStr, collectionRegistry, logger) 
-                || copiedPI.username 
-                || 'Unknown';
-            
-            // Check if PI exists in master list
-            if (investors[cidStr]) {
-                matchedCount++;
-            }
-            
-            watchlistItems.push({
-                cid: Number(cidStr),
-                username: username,
-                addedAt: new Date(),
-                alertConfig: {
-                    newPositions: true,
-                    volatilityChanges: true,
-                    increasedRisk: true,
-                    newSector: true,
-                    increasedPositionSize: true,
-                    newSocialPost: true
-                }
-            });
-        }
-        
-        // Create or update auto-generated watchlist using new path with migration
-        const crypto = require('crypto');
-        let watchlistId = `watchlist_${Date.now()}_${crypto.randomBytes(4).toString('hex')}`;
-        
-        // Check if auto-generated watchlist exists
-        const { readWithMigration } = require('../core/path_resolution_helpers');
-        const existingResult = await readWithMigration(
-            db,
-            'signedInUsers',
-            'watchlists',
-            { cid: userCid },
-            {
-                isCollection: true,
-                dataType: 'watchlists',
-                config,
-                logger,
-                collectionRegistry: dependencies.collectionRegistry
-            }
-        );
-        
-        if (existingResult && existingResult.snapshot) {
-            for (const doc of existingResult.snapshot.docs) {
-                const data = doc.data();
-                if (data.isAutoGenerated) {
-                    watchlistId = doc.id;
-                    // Update existing
-                    await writeWithMigration(
-                        db,
-                        'signedInUsers',
-                        'watchlists',
-                        { cid: userCid },
-                        {
-                            ...data,
-                            items: watchlistItems,
-                            updatedAt: FieldValue.serverTimestamp()
-                        },
-                        {
-                            isCollection: true,
-                            merge: true,
-                            dataType: 'watchlists',
-                            config,
-                            documentId: watchlistId,
-                            dualWrite: true,
-                            collectionRegistry: dependencies.collectionRegistry
-                        }
-                    );
-                    logger.log('SUCCESS', `[autoGenerateWatchlist] Updated auto-generated watchlist ${watchlistId} for user ${userCid}`);
-                    return res.status(200).json({
-                        success: true,
-                        generated: watchlistItems.length,
-                        totalCopied: copiedPIs.length,
-                        matchedInRankings: matchedCount,
-                        dataSource: dataSource,
-                        watchlistId: watchlistId
-                    });
-                }
-            }
-        }
-        
-        // Create new watchlist
-        const watchlistData = {
-            id: watchlistId,
-            name: 'My Copy Watchlist',
-            type: 'static',
-            visibility: 'private',
-            createdBy: Number(userCid),
-            createdAt: FieldValue.serverTimestamp(),
-            updatedAt: FieldValue.serverTimestamp(),
-            isAutoGenerated: true,
-            copyCount: 0,
-            items: watchlistItems
-        };
-        
-        await writeWithMigration(
-            db,
-            'signedInUsers',
-            'watchlists',
-            { cid: userCid },
-            watchlistData,
-            {
-                isCollection: true,
-                merge: false,
-                dataType: 'watchlists',
-                config,
-                collectionRegistry: dependencies.collectionRegistry,
-                documentId: watchlistId,
-                dualWrite: true
-            }
-        );
-        
-        // Update global rootdata collections for computation system
-        if (watchlistItems && watchlistItems.length > 0) {
-            const { updateWatchlistMembershipRootData, updatePIWatchlistData } = require('../rootdata/rootdata_aggregation_helpers');
-            const today = new Date().toISOString().split('T')[0];
-            const isPublic = false; // Auto-generated watchlists are always private
-            
-            for (const item of watchlistItems) {
-                const piCid = String(item.cid);
-                // Update global WatchlistMembershipData/{date} document
-                await updateWatchlistMembershipRootData(db, logger, piCid, userCid, isPublic, today, 'add');
-                // Update PI-centric PopularInvestors/{piCid}/watchlistData
-                await updatePIWatchlistData(db, logger, piCid, userCid, today, 'add');
-            }
-        }
-        
-        logger.log('SUCCESS', `[autoGenerateWatchlist] Created auto-generated watchlist ${watchlistId} with ${watchlistItems.length} items for user ${userCid}`);
-        
-        return res.status(200).json({
-            success: true,
-            generated: watchlistItems.length,
-            totalCopied: copiedPIs.length,
-            matchedInRankings: matchedCount,
-            dataSource: dataSource,
-            watchlistId: watchlistId
-        });
-        
-    } catch (error) {
-        logger.log('ERROR', `[autoGenerateWatchlist] Error auto-generating watchlist for ${userCid}`, error);
-        return res.status(500).json({ error: error.message });
-    }
-}
-
-module.exports = {
-    autoGenerateWatchlist
-};
-