bulltrackers-module 1.0.592 → 1.0.593

package/functions/old-generic-api/user-api/helpers/data/computation_helpers.js

@@ -0,0 +1,503 @@
+/**
+ * @fileoverview Computation Data Helpers
+ * Handles computation results endpoints with migration support
+ */
+
+const { findLatestComputationDate } = require('../core/data_lookup_helpers');
+const { tryDecompress } = require('../core/compression_helpers');
+const { getEffectiveCid, getDevOverride } = require('../dev/dev_helpers');
+
+/**
+ * Check if a PI exists in a computation date
+ * For PopularInvestorProfileMetrics and SignedInUserProfileMetrics: reads from pages subcollection
+ * For other computations: reads from main computation document
+ * Returns { found: boolean, profileData: object | null, computationData: object | null }
+ * @param {object} db - Firestore instance
+ * @param {string} insightsCollection - Insights collection name
+ * @param {string} resultsSub - Results subcollection name
+ * @param {string} compsSub - Computations subcollection name
+ * @param {string} category - Category name
+ * @param {string} computationName - Computation name
+ * @param {string} dateStr - Date string (YYYY-MM-DD)
+ * @param {string} cidStr - CID as string
+ * @param {object} logger - Logger instance
+ * @returns {Promise<{found: boolean, profileData: object|null, computationData: object|null}>}
+ */
+async function checkPiInComputationDate(db, insightsCollection, resultsSub, compsSub, category, computationName, dateStr, cidStr, logger) {
+    try {
+        // Check if this computation uses the pages subcollection structure
+        const usesPagesStructure = computationName === 'PopularInvestorProfileMetrics' || 
+                                   computationName === 'SignedInUserProfileMetrics' || 
+                                   computationName === 'SignedInUserPIPersonalizedMetrics';
+        
+        if (usesPagesStructure) {
+            // New path format: /unified_insights/YYYY-MM-DD/results/popular-investor/computations/{computationName}/pages/{cid}
+            const pageRef = db.collection(insightsCollection)
+                .doc(dateStr)
+                .collection(resultsSub)
+                .doc(category)
+                .collection(compsSub)
+                .doc(computationName)
+                .collection('pages')
+                .doc(cidStr);
+            
+            const pageDoc = await pageRef.get();
+            
+            if (!pageDoc.exists) {
+                logger.log('INFO', `[checkPiInComputationDate] Page document not found for CID ${cidStr} in date ${dateStr}`);
+                return { found: false, profileData: null, computationData: null };
+            }
+            
+            const rawData = pageDoc.data();
+            let profileData = null;
+            
+            // Decompress if needed
+            profileData = tryDecompress(rawData);
+            
+            // Handle string decompression result
+            if (typeof profileData === 'string') {
+                try {
+                    profileData = JSON.parse(profileData);
+                } catch (e) {
+                    logger.log('WARN', `[checkPiInComputationDate] Failed to parse decompressed string for CID ${cidStr} on date ${dateStr}:`, e.message);
+                    return { found: false, profileData: null, computationData: null };
+                }
+            }
+            
+            if (profileData && typeof profileData === 'object') {
+                logger.log('INFO', `[checkPiInComputationDate] Found profile data for CID ${cidStr} in date ${dateStr}`);
+                // Return the profile data - computationData is set to null since we're reading individual pages
+                return { found: true, profileData, computationData: null };
+            } else {
+                logger.log('WARN', `[checkPiInComputationDate] Profile data is not an object for CID ${cidStr} on date ${dateStr}`);
+                return { found: false, profileData: null, computationData: null };
+            }
+        } else {
+            // Standard path for other computations: read from main computation document
+            const computationRef = db.collection(insightsCollection)
+                .doc(dateStr)
+                .collection(resultsSub)
+                .doc(category)
+                .collection(compsSub)
+                .doc(computationName);
+            
+            const computationDoc = await computationRef.get();
+            
+            if (!computationDoc.exists) {
+                return { found: false, profileData: null, computationData: null };
+            }
+            
+            const rawData = computationDoc.data();
+            let computationData = null;
+            
+            // Check if data is sharded
+            if (rawData._sharded === true && rawData._shardCount) {
+                const shardsCol = computationRef.collection('_shards');
+                const shardCount = rawData._shardCount;
+                
+                logger.log('INFO', `[checkPiInComputationDate] Reading ${shardCount} shards for date ${dateStr}`);
+                
+                computationData = {};
+                
+                // Read all shards (shard_0, shard_1, ..., shard_N-1)
+                for (let i = 0; i < shardCount; i++) {
+                    const shardDoc = await shardsCol.doc(`shard_${i}`).get();
+                    if (shardDoc.exists) {
+                        const shardData = shardDoc.data();
+                        Object.assign(computationData, shardData);
+                    } else {
+                        logger.log('WARN', `[checkPiInComputationDate] Shard shard_${i} missing for date ${dateStr}`);
+                    }
+                }
+            } else {
+                // Data is in the main document (compressed or raw)
+                computationData = tryDecompress(rawData);
+                
+                // Handle string decompression result
+                if (typeof computationData === 'string') {
+                    try {
+                        computationData = JSON.parse(computationData);
+                    } catch (e) {
+                        logger.log('WARN', `[checkPiInComputationDate] Failed to parse decompressed string for date ${dateStr}:`, e.message);
+                        return { found: false, profileData: null, computationData: null };
+                    }
+                }
+            }
+            
+            // Check if CID exists in the computation data
+            if (computationData && typeof computationData === 'object' && !Array.isArray(computationData)) {
+                // Filter out metadata keys that start with underscore
+                const cids = Object.keys(computationData).filter(key => !key.startsWith('_'));
+                
+                // Check if the requested CID exists
+                const profileData = computationData[cidStr];
+                if (profileData) {
+                    logger.log('INFO', `[checkPiInComputationDate] Found CID ${cidStr} in date ${dateStr} (total CIDs: ${cids.length})`);
+                    return { found: true, profileData, computationData };
+                } else {
+                    logger.log('INFO', `[checkPiInComputationDate] CID ${cidStr} not found in date ${dateStr} (total CIDs: ${cids.length})`);
+                    return { found: false, profileData: null, computationData };
+                }
+            } else {
+                logger.log('WARN', `[checkPiInComputationDate] Computation data is not an object for date ${dateStr}`);
+                return { found: false, profileData: null, computationData: null };
+            }
+        }
+    } catch (error) {
+        logger.log('ERROR', `[checkPiInComputationDate] Error checking PI in computation:`, error);
+        return { found: false, profileData: null, computationData: null };
+    }
+}
+
+/**
+ * Helper: Get computation metadata from schema collection
+ * @param {object} db - Firestore instance
+ * @param {string} computationName - Computation name
+ * @param {object} config - Config object
+ * @returns {Promise<object|null>} Metadata object or null if not found
+ */
+async function getComputationMetadata(db, computationName, config) {
+    try {
+        const schemaCollection = config.schemaCollection || 'computation_schemas';
+        const schemaDoc = await db.collection(schemaCollection).doc(computationName).get();
+        if (schemaDoc.exists) {
+            return schemaDoc.data().metadata || null;
+        }
+    } catch (err) {
+        // Non-critical, return null
+    }
+    return null;
+}
+
+/**
+ * GET /user/me/computations
+ * Fetches computation results for a specific signed-in user
+ */
+async function getUserComputations(req, res, dependencies, config) {
+    const { db, logger } = dependencies;
+    const { userCid, computation, mode = 'latest', limit = 30 } = req.query;
+    
+    if (!userCid) {
+        return res.status(400).json({ error: "Missing userCid" });
+    }
+
+    try {
+        // Check for dev override impersonation
+        const effectiveCid = await getEffectiveCid(db, userCid, config, logger);
+        const devOverride = await getDevOverride(db, userCid, config, logger);
+        const isImpersonating = devOverride && devOverride.enabled && devOverride.impersonateCid && effectiveCid !== Number(userCid);
+        
+        const insightsCollection = config.unifiedInsightsCollection || 'unified_insights';
+        const resultsSub = config.resultsSubcollection || 'results';
+        const compsSub = config.computationsSubcollection || 'computations';
+        
+        const category = 'popular-investor';
+        const today = new Date().toISOString().split('T')[0];
+        
+        const computationNames = computation ? computation.split(',') : [];
+        
+        if (computationNames.length === 0) {
+            return res.status(400).json({ error: "Please specify at least one computation name" });
+        }
+        
+        // [NEW] Pre-fetch metadata for all computations to determine which are meta vs standard
+        const computationMetadata = {};
+        for (const compName of computationNames) {
+            const metadata = await getComputationMetadata(db, compName, config);
+            if (metadata) {
+                computationMetadata[compName] = metadata;
+            }
+        }
+        
+        const isDevOverrideActive = devOverride && devOverride.enabled && devOverride.fakeCopiedPIs.length > 0;
+        
+        // Check if any of the requested computations are meta computations
+        const firstCompName = computationNames[0];
+        const firstCompMetadata = computationMetadata[firstCompName];
+        const isMetaComputation = firstCompMetadata && firstCompMetadata.type === 'meta';
+        
+        let datesToCheck = [today];
+        
+        if (mode === 'latest') {
+            let foundDate = null;
+            
+            if (isMetaComputation) {
+                // For meta computations: check today first, then look back 7 days
+                const maxDaysBack = 7;
+                
+                for (let daysBack = 0; daysBack < maxDaysBack; daysBack++) {
+                    const checkDate = new Date();
+                    checkDate.setDate(checkDate.getDate() - daysBack);
+                    const dateStr = checkDate.toISOString().split('T')[0];
+                    
+                    try {
+                        // For meta computations, just check if the document exists
+                        const computationRef = db.collection(insightsCollection)
+                            .doc(dateStr)
+                            .collection(resultsSub)
+                            .doc(category)
+                            .collection(compsSub)
+                            .doc(firstCompName);
+                        
+                        const computationDoc = await computationRef.get();
+                        
+                        if (computationDoc.exists) {
+                            foundDate = dateStr;
+                            if (dateStr !== today) {
+                                logger.log('INFO', `[getUserComputations] Meta computation ${firstCompName} found on fallback date ${foundDate} (today: ${today})`);
+                            } else {
+                                logger.log('INFO', `[getUserComputations] Meta computation ${firstCompName} found on today's date`);
+                            }
+                            break; // Found document, stop searching
+                        }
+                    } catch (error) {
+                        // Continue to next date if error
+                        logger.log('DEBUG', `[getUserComputations] Error checking date ${dateStr} for meta computation:`, error.message);
+                        continue;
+                    }
+                }
+            } else {
+                // For user-specific computations: use same logic as data-status
+                // Search backwards and verify user exists
+                const maxDaysBack = 30; // Match data-status search window
+                
+                for (let daysBack = 0; daysBack < maxDaysBack; daysBack++) {
+                    const checkDate = new Date();
+                    checkDate.setDate(checkDate.getDate() - daysBack);
+                    const dateStr = checkDate.toISOString().split('T')[0];
+                    
+                    try {
+                        // Check if page/computation document exists for this user and date
+                        // For computations using pages subcollection, checkPiInComputationDate handles it
+                        // For other computations, check the main document first
+                        const { found } = await checkPiInComputationDate(
+                            db,
+                            insightsCollection,
+                            resultsSub,
+                            compsSub,
+                            category,
+                            firstCompName,
+                            dateStr,
+                            String(effectiveCid),
+                            logger
+                        );
+                        
+                        if (found) {
+                            foundDate = dateStr;
+                            if (dateStr !== today) {
+                                logger.log('INFO', `[getUserComputations] Using fallback date ${foundDate} for effective CID ${effectiveCid} (today: ${today})`);
+                            } else {
+                                logger.log('INFO', `[getUserComputations] Found computation for effective CID ${effectiveCid} on today's date`);
+                            }
+                            break; // Found user, stop searching
+                        }
+                    } catch (error) {
+                        // Continue to next date if error
+                        logger.log('DEBUG', `[getUserComputations] Error checking date ${dateStr}:`, error.message);
+                        continue;
+                    }
+                }
+            }
+            
+            if (foundDate) {
+                datesToCheck = [foundDate];
+            } else {
+                const maxDaysBack = isMetaComputation ? 7 : 30;
+                logger.log('WARN', `[getUserComputations] No computation data found for ${isMetaComputation ? 'meta computation' : `CID ${effectiveCid}`} in last ${maxDaysBack} days. Frontend will use fallback.`);
+                return res.status(200).json({
+                    status: 'success',
+                    userCid: String(effectiveCid),
+                    mode,
+                    computations: computationNames,
+                    data: {},
+                    isFallback: true,
+                    requestedDate: today,
+                    isImpersonating: isImpersonating || false,
+                    actualCid: Number(userCid)
+                });
+            }
+        } else if (mode === 'series') {
+            const limitNum = parseInt(limit) || 30;
+            datesToCheck = [];
+            for (let i = 0; i < limitNum; i++) {
+                const date = new Date();
+                date.setDate(date.getDate() - i);
+                datesToCheck.push(date.toISOString().split('T')[0]);
+            }
+        }
+        
+        const results = {};
+        let isFallback = false;
+        
+        for (const date of datesToCheck) {
+            results[date] = {};
+            
+            for (const compName of computationNames) {
+                try {
+                    let userResult = null;
+                    
+                    // Special handling for computations that use pages subcollection structure
+                    // PopularInvestorProfileMetrics, SignedInUserProfileMetrics, and SignedInUserPIPersonalizedMetrics use pages subcollection
+                    if (compName === 'PopularInvestorProfileMetrics' || 
+                        compName === 'SignedInUserProfileMetrics' || 
+                        compName === 'SignedInUserPIPersonalizedMetrics') {
+                        const pageRef = db.collection(insightsCollection)
+                            .doc(date)
+                            .collection(resultsSub)
+                            .doc(category)
+                            .collection(compsSub)
+                            .doc(compName)
+                            .collection('pages')
+                            .doc(String(effectiveCid));
+                        
+                        const pageDoc = await pageRef.get();
+                        
+                        if (pageDoc.exists) {
+                            const rawData = pageDoc.data();
+                            let data = tryDecompress(rawData);
+                            
+                            if (typeof data === 'string') {
+                                try {
+                                    data = JSON.parse(data);
+                                } catch (e) {
+                                    logger.log('WARN', `[getUserComputations] Failed to parse decompressed string for ${compName} page on ${date}:`, e.message);
+                                    data = null;
+                                }
+                            }
+                            
+                            if (data && typeof data === 'object') {
+                                userResult = data;
+                            }
+                        }
+                    } else {
+                        // Standard path for other computations
+                        const docRef = db.collection(insightsCollection)
+                            .doc(date)
+                            .collection(resultsSub)
+                            .doc(category)
+                            .collection(compsSub)
+                            .doc(compName);
+                        
+                        const doc = await docRef.get();
+                        
+                        if (doc.exists) {
+                            const rawData = doc.data();
+                            let data = tryDecompress(rawData);
+                            
+                            if (typeof data === 'string') {
+                                try {
+                                    data = JSON.parse(data);
+                                } catch (e) {
+                                    logger.log('WARN', `[getUserComputations] Failed to parse decompressed string for ${compName} on ${date}:`, e.message);
+                                    data = null;
+                                }
+                            }
+                            
+                            if (data && data._sharded === true && data._shardCount) {
+                                const shardsCol = docRef.collection('_shards');
+                                const shardsSnapshot = await shardsCol.get();
+                                
+                                if (!shardsSnapshot.empty) {
+                                    data = {};
+                                    for (const shardDoc of shardsSnapshot.docs) {
+                                        const shardData = shardDoc.data();
+                                        Object.assign(data, shardData);
+                                    }
+                                } else {
+                                    data = null;
+                                }
+                            }
+                            
+                            // [FIX] Handle meta computations (global results) vs standard computations (user-specific)
+                            // Use metadata from schema collection to determine computation type
+                            if (data && typeof data === 'object') {
+                                const metadata = computationMetadata[compName];
+                                const isMetaComputation = metadata && metadata.type === 'meta';
+                                
+                                if (isMetaComputation) {
+                                    // Meta computation: return entire data object (global results)
+                                    userResult = data;
+                                } else {
+                                    // Standard computation: extract user-specific result
+                                    const userCidKey = String(effectiveCid);
+                                    userResult = data.hasOwnProperty(userCidKey) ? data[userCidKey] : null;
+                                }
+                            }
+                        }
+                    }
+                    
+                    if (isDevOverrideActive && (compName === 'SignedInUserProfileMetrics' || compName === 'SignedInUserCopiedPIs')) {
+                        if (compName === 'SignedInUserCopiedPIs') {
+                            userResult = {
+                                current: devOverride.fakeCopiedPIs,
+                                past: [],
+                                all: devOverride.fakeCopiedPIs
+                            };
+                            logger.log('INFO', `[getUserComputations] Applied DEV OVERRIDE to SignedInUserCopiedPIs for user ${userCid}`);
+                        } else if (compName === 'SignedInUserProfileMetrics' && userResult && userResult.copiedPIs) {
+                            const fakeMirrors = devOverride.fakeCopiedPIs.map(cid => ({
+                                cid: Number(cid),
+                                username: `PI-${cid}`,
+                                invested: 0,
+                                netProfit: 0,
+                                value: 0,
+                                pendingClosure: false,
+                                isRanked: false
+                            }));
+                            
+                            userResult = {
+                                ...userResult,
+                                copiedPIs: {
+                                    chartType: 'cards',
+                                    data: fakeMirrors
+                                }
+                            };
+                            logger.log('INFO', `[getUserComputations] Applied DEV OVERRIDE to SignedInUserProfileMetrics.copiedPIs for user ${userCid}`);
+                        }
+                    }
+                    
+                    if (userResult) {
+                        results[date][compName] = userResult;
+                    }
+                } catch (err) {
+                    logger.log('WARN', `[getUserComputations] Error fetching ${compName} for ${date}`, err);
+                }
+            }
+            
+            if (mode === 'latest' && Object.keys(results[date]).length > 0) {
+                isFallback = date !== today;
+                break;
+            }
+        }
+        
+        const cleanedResults = {};
+        for (const [date, data] of Object.entries(results)) {
+            if (Object.keys(data).length > 0) {
+                cleanedResults[date] = data;
+            }
+        }
+        
+        return res.status(200).json({
+            status: 'success',
+            userCid: String(effectiveCid),
+            mode,
+            computations: computationNames,
+            data: cleanedResults,
+            isFallback: isFallback,
+            requestedDate: today,
+            devOverrideActive: isDevOverrideActive,
+            isImpersonating: isImpersonating || false,
+            actualCid: Number(userCid)
+        });
+
+    } catch (error) {
+        logger.log('ERROR', `[getUserComputations] Error fetching computations for ${userCid}`, error);
+        return res.status(500).json({ error: error.message });
+    }
+}
+
+module.exports = {
+    getUserComputations,
+    checkPiInComputationDate
+};
+

package/functions/old-generic-api/user-api/helpers/data/instrument_helpers.js

@@ -0,0 +1,55 @@
+/**
+ * @fileoverview Instrument Mappings Helpers
+ * Handles instrument ID to ticker and sector mappings
+ */
+
+/**
+ * GET /user/me/instrument-mappings
+ * Fetches instrument ID to ticker and sector mappings for the frontend
+ */
+async function getInstrumentMappings(req, res, dependencies, config) {
+    const { db, logger } = dependencies;
+
+    try {
+        // Fetch from Firestore (same source as computation system)
+        const [tickerToIdDoc, tickerToSectorDoc] = await Promise.all([
+            db.collection('instrument_mappings').doc('etoro_to_ticker').get(),
+            db.collection('instrument_sector_mappings').doc('sector_mappings').get()
+        ]);
+        
+        if (!tickerToIdDoc.exists) {
+            return res.status(404).json({ error: "Instrument mappings not found" });
+        }
+        
+        const tickerToId = tickerToIdDoc.data();
+        const tickerToSector = tickerToSectorDoc.exists ? tickerToSectorDoc.data() : {};
+        
+        // Convert to ID -> Ticker mapping (reverse the mapping)
+        const idToTicker = {};
+        const idToSector = {};
+        
+        for (const [id, ticker] of Object.entries(tickerToId)) {
+            idToTicker[String(id)] = ticker;
+            // Map ID -> Sector via ticker
+            if (tickerToSector[ticker]) {
+                idToSector[String(id)] = tickerToSector[ticker];
+            }
+        }
+        
+        return res.status(200).json({
+            instrumentToTicker: idToTicker,
+            instrumentToSector: idToSector,
+            count: Object.keys(idToTicker).length,
+            sectorCount: Object.keys(idToSector).length
+        });
+
+    } catch (error) {
+        logger.log('ERROR', `[getInstrumentMappings] Error fetching mappings`, error);
+        return res.status(500).json({ error: error.message });
+    }
+}
+
+module.exports = {
+    getInstrumentMappings
+};
+