bulltrackers-module 1.0.504 → 1.0.506

package/functions/generic-api/user-api/helpers/profile/pi_profile_helpers.js

@@ -0,0 +1,200 @@
+/**
+ * @fileoverview Popular Investor Profile Helpers
+ * Handles PI profile and analytics endpoints with migration support
+ */
+
+const { findLatestComputationDate } = require('../core/data_lookup_helpers');
+const { checkPiInComputationDate } = require('../data/computation_helpers');
+const { readWithMigration } = require('../core/path_resolution_helpers');
+
+/**
+ * GET /pi/:cid/analytics
+ * Fetches pre-computed analytics from the 'analytics_results' collection
+ */
+async function getPiAnalytics(req, res, dependencies, config) {
+    const { db } = dependencies;
+    const { cid } = req.params;
+
+    try {
+        // Try new path first with migration
+        const result = await readWithMigration(
+            db,
+            'popularInvestors',
+            'analytics',
+            { piCid: cid },
+            {
+                isCollection: false,
+                dataType: 'piAnalytics',
+                config,
+                documentId: String(cid)
+            }
+        );
+        
+        if (result && result.data) {
+            return res.status(200).json(result.data);
+        }
+        
+        // Fallback to legacy collection
+        const docRef = db.collection(config.piAnalyticsSummaryCollection || 'pi_analytics_summary').doc(String(cid));
+        const doc = await docRef.get();
+
+        if (!doc.exists) {
+            return res.status(404).json({ error: "No analytics found for this user." });
+        }
+
+        return res.status(200).json(doc.data());
+
+    } catch (error) {
+        return res.status(500).json({ error: error.message });
+    }
+}
+
+/**
+ * GET /pi/:cid/profile
+ * Fetches Popular Investor profile data from computation
+ * Falls back to latest available date if today's data doesn't exist
+ */
+async function getPiProfile(req, res, dependencies, config) {
+    const { db, logger } = dependencies;
+    const { cid } = req.params;
+    
+    if (!cid) {
+        return res.status(400).json({ error: "Missing PI CID" });
+    }
+
+    try {
+        const insightsCollection = config.unifiedInsightsCollection || 'unified_insights';
+        const resultsSub = config.resultsSubcollection || 'results';
+        const compsSub = config.computationsSubcollection || 'computations';
+        const computationName = 'PopularInvestorProfileMetrics';
+        const category = 'popular-investor';
+        const today = new Date().toISOString().split('T')[0];
+        const cidStr = String(cid);
+        const maxDaysBackForPi = 7;
+        
+        logger.log('INFO', `[getPiProfile] Starting search for PI CID: ${cid}`);
+        
+        // Find latest available computation date
+        const latestDate = await findLatestComputationDate(
+            db, 
+            insightsCollection,
+            resultsSub,
+            compsSub,
+            category, 
+            computationName, 
+            null,
+            30
+        );
+        
+        logger.log('INFO', `[getPiProfile] Latest computation date found: ${latestDate || 'NONE'}`);
+        
+        if (!latestDate) {
+            logger.log('WARN', `[getPiProfile] No computation document found for ${computationName} in last 30 days`);
+            return res.status(404).json({ 
+                error: "Profile data not available",
+                message: "No computation results found for this Popular Investor"
+            });
+        }
+        
+        // Try to find the PI starting from the latest date, then going back up to 7 days
+        let foundDate = null;
+        let profileData = null;
+        let checkedDates = [];
+        
+        const latestDateObj = new Date(latestDate + 'T00:00:00Z');
+        
+        for (let daysBack = 0; daysBack <= maxDaysBackForPi; daysBack++) {
+            const checkDate = new Date(latestDateObj);
+            checkDate.setUTCDate(latestDateObj.getUTCDate() - daysBack);
+            const dateStr = checkDate.toISOString().split('T')[0];
+            checkedDates.push(dateStr);
+            
+            logger.log('INFO', `[getPiProfile] Checking date ${dateStr} for CID ${cid} (${daysBack} days back from latest)`);
+            
+            const result = await checkPiInComputationDate(
+                db,
+                insightsCollection,
+                resultsSub,
+                compsSub,
+                category,
+                computationName,
+                dateStr,
+                cidStr,
+                logger
+            );
+            
+            if (result.found) {
+                foundDate = dateStr;
+                profileData = result.profileData;
+                logger.log('SUCCESS', `[getPiProfile] Found profile data for CID ${cid} in date ${dateStr} (${daysBack} days back from latest)`);
+                break;
+            } else {
+                logger.log('INFO', `[getPiProfile] CID ${cid} not found in date ${dateStr}`);
+            }
+        }
+        
+        // If not found in any checked date, return 404
+        if (!foundDate || !profileData) {
+            logger.log('WARN', `[getPiProfile] CID ${cid} not found in any checked dates: ${checkedDates.join(', ')}`);
+            
+            // Try to get sample data from the latest date to show what CIDs are available
+            const latestResult = await checkPiInComputationDate(
+                db,
+                insightsCollection,
+                resultsSub,
+                compsSub,
+                category,
+                computationName,
+                latestDate,
+                cidStr,
+                logger
+            );
+            
+            const allAvailableCids = latestResult.computationData && typeof latestResult.computationData === 'object' && !Array.isArray(latestResult.computationData)
+                ? Object.keys(latestResult.computationData)
+                    .filter(key => !key.startsWith('_'))
+                    .sort()
+                : [];
+            
+            return res.status(404).json({ 
+                error: "Profile data not found",
+                message: `Popular Investor ${cid} does not exist in computation results for the last ${maxDaysBackForPi + 1} days. This PI may not have been processed recently.`,
+                debug: {
+                    searchedCid: cidStr,
+                    checkedDates: checkedDates,
+                    totalCidsInLatestDocument: allAvailableCids.length,
+                    sampleAvailableCids: allAvailableCids.slice(0, 20),
+                    latestDate: latestDate
+                }
+            });
+        }
+        
+        // Get username from rankings
+        const { getPiUsername } = require('../on_demand_fetch_helpers');
+        const username = await getPiUsername(db, cid, config, logger);
+        
+        logger.log('SUCCESS', `[getPiProfile] Returning profile data for CID ${cid} from date ${foundDate} (requested: ${today}, latest available: ${latestDate})`);
+        
+        return res.status(200).json({
+            status: 'success',
+            cid: cidStr,
+            username: username || null,
+            data: profileData,
+            isFallback: foundDate !== latestDate || foundDate !== today,
+            dataDate: foundDate,
+            latestComputationDate: latestDate,
+            requestedDate: today,
+            daysBackFromLatest: checkedDates.indexOf(foundDate)
+        });
+
+    } catch (error) {
+        logger.log('ERROR', `[getPiProfile] Error fetching PI profile for ${cid}`, error);
+        return res.status(500).json({ error: error.message });
+    }
+}
+
+module.exports = {
+    getPiAnalytics,
+    getPiProfile
+};
+

package/functions/generic-api/user-api/helpers/profile/profile_view_helpers.js

@@ -0,0 +1,125 @@
+/**
+ * @fileoverview Profile View Tracking Helpers
+ * Handles profile view tracking with migration support
+ */
+
+const { FieldValue } = require('@google-cloud/firestore');
+const { readWithMigration, writeWithMigration, getCidFromFirebaseUid } = require('../core/path_resolution_helpers');
+
+/**
+ * POST /pi/:piCid/track-view
+ * Tracks a profile view for a Popular Investor
+ * Migrates from legacy path to new path automatically
+ */
+async function trackProfileView(req, res, dependencies, config) {
+    const { db, logger } = dependencies;
+    const { piCid } = req.params;
+    const { viewerCid, viewerType = 'anonymous', firebaseUid } = req.body;
+    
+    if (!piCid) {
+        return res.status(400).json({ error: "Missing piCid" });
+    }
+    
+    try {
+        // If firebaseUid is provided, get CID
+        let effectiveViewerCid = viewerCid;
+        if (firebaseUid && !viewerCid) {
+            effectiveViewerCid = await getCidFromFirebaseUid(db, firebaseUid);
+        }
+        
+        const today = new Date().toISOString().split('T')[0];
+        const timestamp = Date.now();
+        
+        // Create/update daily view document (new path)
+        const viewData = {
+            piCid: Number(piCid),
+            date: today,
+            totalViews: FieldValue.increment(1),
+            lastUpdated: FieldValue.serverTimestamp()
+        };
+        
+        // Add unique viewers if viewer CID is provided
+        if (effectiveViewerCid) {
+            // Read existing to merge unique viewers
+            const existingResult = await readWithMigration(
+                db,
+                'popularInvestors',
+                'profileViews',
+                { piCid, date: today },
+                {
+                    isCollection: false,
+                    dataType: 'piProfileViews',
+                    config,
+                    documentId: today
+                }
+            );
+            
+            const existingUniqueViewers = existingResult?.data?.uniqueViewers || [];
+            const viewerCidStr = String(effectiveViewerCid);
+            
+            if (!existingUniqueViewers.includes(viewerCidStr)) {
+                viewData.uniqueViewers = [...existingUniqueViewers, viewerCidStr];
+            } else {
+                viewData.uniqueViewers = existingUniqueViewers;
+            }
+        }
+        
+        // Write to new path (with dual write to legacy during migration)
+        await writeWithMigration(
+            db,
+            'popularInvestors',
+            'profileViews',
+            { piCid, date: today },
+            viewData,
+            {
+                isCollection: false,
+                merge: true,
+                dataType: 'piProfileViews',
+                config,
+                documentId: today,
+                dualWrite: true
+            }
+        );
+        
+        // Track individual view if viewer CID is provided
+        if (effectiveViewerCid) {
+            const viewId = `${piCid}_${effectiveViewerCid}_${timestamp}`;
+            const individualViewData = {
+                piCid: Number(piCid),
+                viewerCid: Number(effectiveViewerCid),
+                viewerType: viewerType,
+                viewedAt: FieldValue.serverTimestamp(),
+                date: today
+            };
+            
+            // Write individual view (new path)
+            await writeWithMigration(
+                db,
+                'popularInvestors',
+                'individualViews',
+                { piCid, viewId },
+                individualViewData,
+                {
+                    isCollection: false,
+                    merge: true,
+                    dataType: 'piIndividualViews',
+                    config,
+                    documentId: viewId,
+                    dualWrite: true
+                }
+            );
+        }
+        
+        return res.status(200).json({ success: true, message: "View tracked" });
+        
+    } catch (error) {
+        logger.log('ERROR', `[trackProfileView] Error tracking view for PI ${piCid}:`, error);
+        // Don't fail the request if tracking fails
+        return res.status(200).json({ success: false, message: "View tracking failed but request succeeded" });
+    }
+}
+
+module.exports = {
+    trackProfileView
+};
+

package/functions/generic-api/user-api/helpers/profile/user_profile_helpers.js

@@ -0,0 +1,178 @@
+/**
+ * @fileoverview User Profile Helpers
+ * Handles signed-in user profile endpoints with migration support
+ */
+
+const { checkIfUserIsPI } = require('../core/user_status_helpers');
+const { readWithMigration, getCidFromFirebaseUid } = require('../core/path_resolution_helpers');
+const { getEffectiveCid, getDevOverride } = require('../dev_helpers');
+
+/**
+ * GET /user/me/verification
+ * Fetches the signed-in user's verification data (includes avatar URL)
+ * Uses migration to read from new path or legacy path
+ */
+async function getUserVerification(req, res, dependencies, config) {
+    const { db, logger } = dependencies;
+    const { userCid, firebaseUid } = req.query;
+    
+    if (!userCid && !firebaseUid) {
+        return res.status(400).json({ error: "Missing userCid or firebaseUid" });
+    }
+
+    try {
+        // Get CID if firebaseUid provided
+        let effectiveCid = userCid ? Number(userCid) : null;
+        if (firebaseUid && !effectiveCid) {
+            effectiveCid = await getCidFromFirebaseUid(db, firebaseUid);
+            if (!effectiveCid) {
+                return res.status(404).json({ error: "User not found" });
+            }
+        }
+        
+        // Check for dev override impersonation
+        const devOverride = await getDevOverride(db, effectiveCid, config, logger);
+        const isImpersonating = devOverride && devOverride.enabled && devOverride.impersonateCid && effectiveCid !== Number(userCid);
+        
+        if (isImpersonating) {
+            effectiveCid = devOverride.impersonateCid;
+        }
+        
+        // If impersonating a PI, try to get username from rankings
+        if (isImpersonating) {
+            const rankEntry = await checkIfUserIsPI(db, effectiveCid, config, logger);
+            if (rankEntry) {
+                return res.status(200).json({
+                    avatar: null,
+                    username: rankEntry.UserName || null,
+                    fullName: null,
+                    cid: effectiveCid,
+                    verifiedAt: null,
+                    isImpersonating: true,
+                    effectiveCid: effectiveCid,
+                    actualCid: Number(userCid)
+                });
+            }
+        }
+        
+        // Try to read from new path with migration
+        const result = await readWithMigration(
+            db,
+            'signedInUsers',
+            'verification',
+            { cid: effectiveCid },
+            {
+                isCollection: false,
+                dataType: 'verification',
+                config,
+                logger,
+                documentId: 'data'
+            }
+        );
+        
+        if (result && result.data) {
+            return res.status(200).json({
+                avatar: result.data.avatar || null,
+                username: result.data.username || null,
+                fullName: result.data.fullName || null,
+                cid: result.data.cid || effectiveCid,
+                verifiedAt: result.data.verifiedAt || null,
+                isImpersonating: isImpersonating || false,
+                effectiveCid: effectiveCid,
+                actualCid: Number(userCid),
+                migrated: result.source === 'legacy'
+            });
+        }
+        
+        // Fallback to legacy: try reading from signedInUsers main document
+        const { signedInUsersCollection } = config;
+        const userDocRef = db.collection(signedInUsersCollection).doc(String(effectiveCid));
+        const userDoc = await userDocRef.get();
+        
+        if (!userDoc.exists) {
+            return res.status(404).json({ error: "User verification data not found" });
+        }
+        
+        const data = userDoc.data();
+        
+        return res.status(200).json({
+            avatar: data.avatar || null,
+            username: data.username || data.etoroUsername || null,
+            fullName: data.displayName || null,
+            cid: data.cid || data.etoroCID || effectiveCid,
+            verifiedAt: data.verifiedAt || null,
+            isImpersonating: isImpersonating || false,
+            effectiveCid: effectiveCid,
+            actualCid: Number(userCid)
+        });
+
+    } catch (error) {
+        logger.log('ERROR', `[getUserVerification] Error fetching verification for ${userCid}`, error);
+        return res.status(500).json({ error: error.message });
+    }
+}
+
+/**
+ * GET /user/me/is-popular-investor
+ * Check if signed-in user is also a Popular Investor
+ * Supports dev override impersonation
+ */
+async function checkIfUserIsPopularInvestor(req, res, dependencies, config) {
+    const { db, logger } = dependencies;
+    const { userCid } = 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);
+        
+        // Use effective CID (impersonated or actual) to check PI status
+        const rankEntry = await checkIfUserIsPI(db, effectiveCid, config, logger);
+        
+        if (!rankEntry) {
+            return res.status(200).json({
+                isPopularInvestor: false,
+                rankingData: null,
+                isImpersonating: isImpersonating || false,
+                effectiveCid: effectiveCid
+            });
+        }
+        
+        // Check if this is a dev override (pretendToBePI)
+        const isDevOverride = devOverride && devOverride.enabled && devOverride.pretendToBePI;
+        
+        // Return ranking data
+        return res.status(200).json({
+            isPopularInvestor: true,
+            rankingData: {
+                cid: rankEntry.CustomerId,
+                username: rankEntry.UserName,
+                aum: rankEntry.AUMValue || 0,
+                copiers: rankEntry.Copiers || 0,
+                riskScore: rankEntry.RiskScore || 0,
+                gain: rankEntry.Gain || 0,
+                winRatio: rankEntry.WinRatio || 0,
+                trades: rankEntry.Trades || 0
+            },
+            isDevOverride: isDevOverride || false,
+            isImpersonating: isImpersonating || false,
+            effectiveCid: effectiveCid,
+            actualCid: Number(userCid)
+        });
+        
+    } catch (error) {
+        logger.log('ERROR', `[checkIfUserIsPopularInvestor] Error checking PI status for ${userCid}:`, error);
+        return res.status(500).json({ error: error.message });
+    }
+}
+
+module.exports = {
+    getUserVerification,
+    checkIfUserIsPopularInvestor
+};
+

package/functions/generic-api/user-api/helpers/recommendations/recommendation_helpers.js

@@ -0,0 +1,65 @@
+/**
+ * @fileoverview User Recommendations Helpers
+ * Handles personalized recommendations endpoints
+ */
+
+const { readWithMigration } = require('../core/path_resolution_helpers');
+
+/**
+ * GET /user/me/hedges (and /similar)
+ * Returns personalized recommendations calculated in Phase 3
+ */
+async function getUserRecommendations(req, res, dependencies, config, type = 'hedges') {
+    const { db, logger } = dependencies;
+    const { userCid } = req.query;
+    
+    if (!userCid) {
+        return res.status(400).json({ error: "Missing userCid" });
+    }
+
+    try {
+        // Try new path with migration
+        const result = await readWithMigration(
+            db,
+            'signedInUsers',
+            'recommendations',
+            { cid: userCid },
+            {
+                isCollection: false,
+                dataType: 'recommendations',
+                config,
+                logger,
+                documentId: type
+            }
+        );
+        
+        if (result && result.data) {
+            const recs = result.data[type] || result.data || [];
+            return res.status(200).json({ 
+                [type]: recs,
+                migrated: result.source === 'legacy'
+            });
+        }
+        
+        // Fallback: Recommendations may be stored in user doc
+        const userDoc = await db.collection(config.signedInUsersCollection || 'signedInUsers').doc(String(userCid)).get();
+        
+        if (!userDoc.exists) {
+            return res.status(404).json({ error: "User not found" });
+        }
+
+        const data = userDoc.data();
+        const recs = data.recommendations ? data.recommendations[type] : [];
+
+        return res.status(200).json({ [type]: recs || [] });
+
+    } catch (error) {
+        logger.log('ERROR', `[getUserRecommendations] Error fetching recommendations for ${userCid}`, error);
+        return res.status(500).json({ error: error.message });
+    }
+}
+
+module.exports = {
+    getUserRecommendations
+};
+