bulltrackers-module 1.0.421 → 1.0.423

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

@@ -154,6 +154,67 @@ async function findLatestComputationDate(db, insightsCollection, resultsSub, com
     return null; // No document found in the last maxDaysBack days
 }
 
+/**
+ * Check if a signed-in user is also a Popular Investor
+ * Returns ranking entry if found, null otherwise
+ * Checks dev overrides first for pretendToBePI flag
+ */
+async function checkIfUserIsPI(db, userCid, config, logger = null) {
+    try {
+        // Check dev override first (for developer accounts)
+        const { getDevOverride } = require('./dev_helpers');
+        const devOverride = await getDevOverride(db, userCid, config, logger);
+        
+        if (devOverride && devOverride.pretendToBePI) {
+            // Generate fake ranking entry for dev testing
+            const fakeRankEntry = {
+                CustomerId: Number(userCid),
+                UserName: 'Dev Test PI',
+                AUMValue: 500000 + Math.floor(Math.random() * 1000000), // Random AUM between 500k-1.5M
+                Copiers: 150 + Math.floor(Math.random() * 200), // Random copiers between 150-350
+                RiskScore: 3 + Math.floor(Math.random() * 3), // Random risk score 3-5
+                Gain: 25 + Math.floor(Math.random() * 50), // Random gain 25-75%
+                WinRatio: 50 + Math.floor(Math.random() * 20), // Random win ratio 50-70%
+                Trades: 500 + Math.floor(Math.random() * 1000) // Random trades 500-1500
+            };
+            
+            if (logger && logger.log) {
+                logger.log('INFO', `[checkIfUserIsPI] DEV OVERRIDE: User ${userCid} pretending to be PI with fake ranking data`);
+            } else {
+                console.log(`[checkIfUserIsPI] DEV OVERRIDE: User ${userCid} pretending to be PI with fake ranking data`);
+            }
+            
+            return fakeRankEntry;
+        }
+        
+        // Otherwise, check real rankings
+        const rankingsCollection = config.popularInvestorRankingsCollection || process.env.FIRESTORE_COLLECTION_PI_RANKINGS || 'popular_investor_rankings';
+        const rankingsDate = await findLatestRankingsDate(db, rankingsCollection, 30);
+        
+        if (!rankingsDate) {
+            return null;
+        }
+        
+        const rankingsRef = db.collection(rankingsCollection).doc(rankingsDate);
+        const rankingsDoc = await rankingsRef.get();
+        
+        if (!rankingsDoc.exists) {
+            return null;
+        }
+        
+        const rankingsData = rankingsDoc.data();
+        const rankingsItems = rankingsData.Items || [];
+        
+        // Find user in rankings
+        const userRankEntry = rankingsItems.find(item => String(item.CustomerId) === String(userCid));
+        
+        return userRankEntry || null;
+    } catch (error) {
+        console.error('[checkIfUserIsPI] Error checking if user is PI:', error);
+        return null;
+    }
+}
+
 /**
  * Helper function to find the latest available date for Popular Investor rankings
  * Searches backwards from today up to 30 days
@@ -546,12 +607,30 @@ async function getUserPortfolio(req, res, dependencies, config) {
             return res.status(404).json({ error: "Portfolio data not found for this user" });
         }
         
+        // Apply dev override to AggregatedMirrors if dev override is active
+        const { getDevOverride } = require('./dev_helpers');
+        const devOverride = await getDevOverride(db, userCid, config, logger);
+        if (devOverride && devOverride.enabled && devOverride.fakeCopiedPIs.length > 0 && portfolioData.AggregatedMirrors) {
+            logger.log('INFO', `[getUserPortfolio] Applying DEV OVERRIDE to AggregatedMirrors for user ${userCid}`);
+            
+            // Replace AggregatedMirrors with fake ones from dev override
+            portfolioData.AggregatedMirrors = devOverride.fakeCopiedPIs.map(cid => ({
+                ParentCID: Number(cid),
+                ParentUsername: `PI-${cid}`, // Placeholder, will be resolved if needed
+                Invested: 0,
+                NetProfit: 0,
+                Value: 0,
+                PendingForClosure: false
+            }));
+        }
+        
         return res.status(200).json({
             portfolio: portfolioData,
             date: dataDate,
             isFallback: isFallback,
             requestedDate: today,
-            userCid: String(userCid)
+            userCid: String(userCid),
+            devOverrideActive: devOverride && devOverride.enabled
         });
 
     } catch (error) {
@@ -710,6 +789,11 @@ async function getUserComputations(req, res, dependencies, config) {
             return res.status(400).json({ error: "Please specify at least one computation name" });
         }
         
+        // Check for dev override (for developer accounts)
+        const { getDevOverride } = require('./dev_helpers');
+        const devOverride = await getDevOverride(db, userCid, config, logger);
+        const isDevOverrideActive = devOverride && devOverride.enabled && devOverride.fakeCopiedPIs.length > 0;
+        
         let datesToCheck = [today];
         
         // If mode is 'latest', try to find the latest available date for the first computation
@@ -777,7 +861,42 @@ async function getUserComputations(req, res, dependencies, config) {
                         const rawData = doc.data();
                         const data = tryDecompress(rawData);
                         // Filter by user CID - computation results are stored as { cid: result }
-                        const userResult = data[String(userCid)];
+                        let userResult = data[String(userCid)];
+                        
+                        // Apply dev override for computations that include copied PIs
+                        if (isDevOverrideActive && (compName === 'SignedInUserProfileMetrics' || compName === 'SignedInUserCopiedPIs')) {
+                            if (compName === 'SignedInUserCopiedPIs') {
+                                // Override the copied PIs list
+                                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) {
+                                // Override the copiedPIs data in SignedInUserProfileMetrics
+                                // We need to construct fake mirror data from the dev override PIs
+                                const fakeMirrors = devOverride.fakeCopiedPIs.map(cid => ({
+                                    cid: Number(cid),
+                                    username: `PI-${cid}`, // Placeholder, will be resolved from rankings if available
+                                    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;
                         }
@@ -809,7 +928,8 @@ async function getUserComputations(req, res, dependencies, config) {
             computations: computationNames,
             data: cleanedResults,
             isFallback: isFallback,
-            requestedDate: today
+            requestedDate: today,
+            devOverrideActive: isDevOverrideActive
         });
 
     } catch (error) {
@@ -1619,6 +1739,609 @@ async function getPiProfile(req, res, dependencies, config) {
     }
 }
 
+/**
+ * GET /user/me/is-popular-investor
+ * Check if signed-in user is also a Popular Investor
+ */
+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 {
+        const rankEntry = await checkIfUserIsPI(db, userCid, config, logger);
+        
+        if (!rankEntry) {
+            return res.status(200).json({
+                isPopularInvestor: false,
+                rankingData: null
+            });
+        }
+        
+        // Check if this is a dev override
+        const { getDevOverride } = require('./dev_helpers');
+        const devOverride = await getDevOverride(db, userCid, config, logger);
+        const isDevOverride = devOverride && 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
+        });
+        
+    } catch (error) {
+        logger.log('ERROR', `[checkIfUserIsPopularInvestor] Error checking PI status for ${userCid}:`, error);
+        return res.status(500).json({ error: error.message });
+    }
+}
+
+/**
+ * Track profile page view for a Popular Investor
+ * Stores view data for analytics
+ */
+async function trackProfileView(req, res, dependencies, config) {
+    const { db, logger } = dependencies;
+    const { piCid } = req.params;
+    const { viewerCid, viewerType = 'anonymous' } = req.body; // viewerType: 'anonymous', 'signed_in', 'copier'
+    
+    if (!piCid) {
+        return res.status(400).json({ error: "Missing piCid" });
+    }
+    
+    try {
+        const profileViewsCollection = config.profileViewsCollection || 'profile_views';
+        const today = new Date().toISOString().split('T')[0];
+        
+        // Create/update daily view document
+        const viewDocId = `${piCid}_${today}`;
+        const viewRef = db.collection(profileViewsCollection).doc(viewDocId);
+        
+        // Get existing document to merge unique viewers properly
+        const existingDoc = await viewRef.get();
+        const existingData = existingDoc.exists ? existingDoc.data() : {};
+        const existingUniqueViewers = Array.isArray(existingData.uniqueViewers) ? existingData.uniqueViewers : [];
+        
+        // Add new viewer if provided and not already in list
+        const updatedUniqueViewers = viewerCid && !existingUniqueViewers.includes(String(viewerCid))
+            ? [...existingUniqueViewers, String(viewerCid)]
+            : existingUniqueViewers;
+        
+        const viewData = {
+            piCid: Number(piCid),
+            date: today,
+            totalViews: FieldValue.increment(1),
+            uniqueViewers: updatedUniqueViewers, // Store as array, not using arrayUnion to avoid duplicates
+            lastUpdated: FieldValue.serverTimestamp()
+        };
+        
+        // Set with merge to update if exists
+        await viewRef.set(viewData, { merge: true });
+        
+        // Also track individual view for detailed analytics (optional, lightweight)
+        if (viewerCid) {
+            const individualViewId = `${piCid}_${viewerCid}_${Date.now()}`;
+            await db.collection(profileViewsCollection)
+                .doc('individual_views')
+                .collection('views')
+                .doc(individualViewId)
+                .set({
+                    piCid: Number(piCid),
+                    viewerCid: Number(viewerCid),
+                    viewerType: viewerType,
+                    viewedAt: FieldValue.serverTimestamp(),
+                    date: today
+                }, { merge: 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" });
+    }
+}
+
+/**
+ * Generate sample PI personalized metrics data for dev testing
+ * Creates realistic sample data that matches the computation structure 1:1
+ */
+function generateSamplePIPersonalizedMetrics(userCid, rankEntry) {
+    const today = new Date().toISOString().split('T')[0];
+    const yesterday = new Date();
+    yesterday.setDate(yesterday.getDate() - 1);
+    const yesterdayStr = yesterday.toISOString().split('T')[0];
+    
+    // Generate sample base metrics (from PopularInvestorProfileMetrics)
+    const baseMetrics = {
+        socialEngagement: {
+            chartType: 'line',
+            data: Array.from({ length: 30 }, (_, i) => {
+                const date = new Date();
+                date.setDate(date.getDate() - (29 - i));
+                return {
+                    date: date.toISOString().split('T')[0],
+                    likes: Math.floor(Math.random() * 50) + 10,
+                    comments: Math.floor(Math.random() * 20) + 5
+                };
+            })
+        },
+        profitablePositions: {
+            chartType: 'bar',
+            data: Array.from({ length: 30 }, (_, i) => {
+                const date = new Date();
+                date.setDate(date.getDate() - (29 - i));
+                return {
+                    date: date.toISOString().split('T')[0],
+                    profitableCount: Math.floor(Math.random() * 10) + 5,
+                    totalCount: Math.floor(Math.random() * 15) + 10
+                };
+            })
+        },
+        topWinningPositions: {
+            chartType: 'table',
+            data: Array.from({ length: 10 }, (_, i) => ({
+                instrumentId: 1000 + i,
+                ticker: ['AAPL', 'MSFT', 'GOOGL', 'AMZN', 'TSLA', 'META', 'NVDA', 'NFLX', 'AMD', 'INTC'][i],
+                netProfit: Math.floor(Math.random() * 100) + 20,
+                invested: Math.floor(Math.random() * 5000) + 1000,
+                value: Math.floor(Math.random() * 6000) + 1000,
+                isCurrent: Math.random() > 0.5,
+                closeDate: Math.random() > 0.5 ? new Date().toISOString() : null
+            }))
+        },
+        sectorPerformance: {
+            bestSector: 'Technology',
+            worstSector: 'Energy',
+            bestSectorProfit: 15.5,
+            worstSectorProfit: -3.2
+        },
+        sectorExposure: {
+            chartType: 'pie',
+            data: {
+                'Technology': 35.5,
+                'Healthcare': 20.3,
+                'Finance': 15.2,
+                'Energy': 10.1,
+                'Consumer': 18.9
+            }
+        },
+        assetExposure: {
+            chartType: 'pie',
+            data: {
+                'AAPL': 12.5,
+                'MSFT': 10.3,
+                'GOOGL': 8.7,
+                'AMZN': 7.2,
+                'TSLA': 6.1
+            }
+        },
+        portfolioSummary: {
+            totalInvested: 850000,
+            totalProfit: 125000,
+            profitPercent: 14.7
+        },
+        rankingsData: {
+            aum: rankEntry.AUMValue || 0,
+            riskScore: rankEntry.RiskScore || 0,
+            gain: rankEntry.Gain || 0,
+            copiers: rankEntry.Copiers || 0,
+            winRatio: rankEntry.WinRatio || 0,
+            trades: rankEntry.Trades || 0
+        }
+    };
+    
+    // Generate sample review metrics
+    const reviewMetricsOverTime = Array.from({ length: 30 }, (_, i) => {
+        const date = new Date();
+        date.setDate(date.getDate() - (29 - i));
+        return {
+            date: date.toISOString().split('T')[0],
+            averageRating: Number((3.5 + Math.random() * 1.5).toFixed(2)),
+            count: Math.floor(Math.random() * 5) + 1
+        };
+    });
+    
+    const totalReviews = reviewMetricsOverTime.reduce((sum, r) => sum + r.count, 0);
+    const avgRating = reviewMetricsOverTime.reduce((sum, r) => sum + (r.averageRating * r.count), 0) / totalReviews;
+    
+    // Generate sample similar PIs
+    const similarPIs = Array.from({ length: 5 }, (_, i) => ({
+        cid: 1000000 + i,
+        username: `SimilarPI${i + 1}`,
+        similarityScore: Number((85 - (i * 5)).toFixed(2)),
+        aum: Math.floor(Math.random() * 500000) + 300000,
+        copiers: Math.floor(Math.random() * 200) + 100,
+        riskScore: Math.floor(Math.random() * 3) + 2,
+        gain: Number((20 + Math.random() * 30).toFixed(2))
+    }));
+    
+    // Calculate leaderboard position (sample)
+    const totalPIs = 1000;
+    const currentRank = Math.floor(Math.random() * 200) + 50; // Rank 50-250
+    const percentile = Number((100 - ((currentRank / totalPIs) * 100)).toFixed(2));
+    
+    // Generate sample asset investments
+    const topAssets = Array.from({ length: 10 }, (_, i) => ({
+        instrumentId: 1000 + i,
+        ticker: ['AAPL', 'MSFT', 'GOOGL', 'AMZN', 'TSLA', 'META', 'NVDA', 'NFLX', 'AMD', 'INTC'][i],
+        aum: Math.floor(Math.random() * 100000) + 50000,
+        percentage: Number((Math.random() * 15 + 5).toFixed(2))
+    }));
+    
+    // Generate sample profile views
+    const profileViewsOverTime = Array.from({ length: 30 }, (_, i) => {
+        const date = new Date();
+        date.setDate(date.getDate() - (29 - i));
+        return {
+            date: date.toISOString().split('T')[0],
+            views: Math.floor(Math.random() * 50) + 10,
+            uniqueViews: Math.floor(Math.random() * 30) + 5
+        };
+    });
+    
+    const totalViews = profileViewsOverTime.reduce((sum, v) => sum + v.views, 0);
+    const totalUniqueViews = new Set(profileViewsOverTime.flatMap(v => Array.from({ length: v.uniqueViews }, (_, i) => `viewer_${i}`))).size;
+    const averageDailyViews = Number((totalViews / 30).toFixed(2));
+    
+    // Calculate copier growth
+    const copiersToday = rankEntry.Copiers || 250;
+    const copiersYesterday = copiersToday - Math.floor(Math.random() * 20) + 5; // Random change
+    const diff = copiersToday - copiersYesterday;
+    const growthRate = copiersYesterday > 0 ? Number(((diff / copiersYesterday) * 100).toFixed(2)) : 0;
+    const trend = diff > 0 ? 'increasing' : diff < 0 ? 'decreasing' : 'stable';
+    
+    // Calculate engagement score
+    const reviewScore = avgRating * 20; // 0-100 scale
+    const viewScore = Math.min(100, (averageDailyViews / 10) * 100);
+    const copierScore = Math.min(100, (copiersToday / 1000) * 100);
+    const socialScore = Math.min(100, (baseMetrics.socialEngagement.data.length / 10) * 100);
+    const engagementScore = (reviewScore * 0.3 + viewScore * 0.2 + copierScore * 0.3 + socialScore * 0.2);
+    
+    return {
+        baseMetrics: baseMetrics,
+        reviewMetrics: {
+            overTime: reviewMetricsOverTime,
+            currentStats: {
+                averageRating: Number(avgRating.toFixed(2)),
+                totalReviews: totalReviews,
+                distribution: {
+                    1: Math.floor(totalReviews * 0.1),
+                    2: Math.floor(totalReviews * 0.15),
+                    3: Math.floor(totalReviews * 0.25),
+                    4: Math.floor(totalReviews * 0.3),
+                    5: Math.floor(totalReviews * 0.2)
+                }
+            },
+            sentimentTrend: []
+        },
+        similarPIs: similarPIs,
+        leaderboardPosition: {
+            currentRank: currentRank,
+            totalPIs: totalPIs,
+            percentile: percentile,
+            rankByAUM: currentRank + Math.floor(Math.random() * 50) - 25,
+            rankByCopiers: currentRank
+        },
+        assetInvestments: {
+            byAUM: topAssets.reduce((acc, asset) => {
+                acc[asset.instrumentId] = asset.aum;
+                return acc;
+            }, {}),
+            topAssets: topAssets
+        },
+        profileViews: {
+            overTime: profileViewsOverTime,
+            totalViews: totalViews,
+            totalUniqueViews: totalUniqueViews,
+            averageDailyViews: averageDailyViews
+        },
+        copierGrowth: {
+            overTime: [
+                { date: yesterdayStr, copiers: copiersYesterday },
+                { date: today, copiers: copiersToday }
+            ],
+            growthRate: growthRate,
+            diff: diff,
+            trend: trend
+        },
+        engagementScore: {
+            current: Number(engagementScore.toFixed(2)),
+            components: {
+                reviewScore: Number(reviewScore.toFixed(2)),
+                viewScore: Number(viewScore.toFixed(2)),
+                copierScore: Number(copierScore.toFixed(2)),
+                socialScore: Number(socialScore.toFixed(2))
+            }
+        }
+    };
+}
+
+/**
+ * GET /user/me/pi-personalized-metrics
+ * Get personalized metrics for signed-in user who is a Popular Investor
+ * Includes review metrics, page views, similar PIs, leaderboard position, etc.
+ */
+async function getSignedInUserPIPersonalizedMetrics(req, res, dependencies, config) {
+    const { db, logger } = dependencies;
+    const { userCid } = req.query;
+    
+    if (!userCid) {
+        return res.status(400).json({ error: "Missing userCid" });
+    }
+    
+    try {
+        // First, verify user is a PI (checks dev override)
+        const rankEntry = await checkIfUserIsPI(db, userCid, config, logger);
+        if (!rankEntry) {
+            return res.status(404).json({
+                error: "Not a Popular Investor",
+                message: "This endpoint is only available for users who are Popular Investors"
+            });
+        }
+        
+        // Check if this is a dev override
+        const { getDevOverride } = require('./dev_helpers');
+        const devOverride = await getDevOverride(db, userCid, config, logger);
+        const isDevOverride = devOverride && devOverride.pretendToBePI;
+        
+        // If dev override, generate sample data
+        if (isDevOverride) {
+            logger.log('INFO', `[getSignedInUserPIPersonalizedMetrics] DEV OVERRIDE: Generating sample PI metrics for user ${userCid}`);
+            const sampleData = generateSamplePIPersonalizedMetrics(userCid, rankEntry);
+            const today = new Date().toISOString().split('T')[0];
+            
+            return res.status(200).json({
+                status: 'success',
+                userCid: String(userCid),
+                data: sampleData,
+                dataDate: today,
+                requestedDate: today,
+                isFallback: false,
+                isDevOverride: true
+            });
+        }
+        
+        const insightsCollection = config.unifiedInsightsCollection || 'unified_insights';
+        const resultsSub = config.resultsSubcollection || 'results';
+        const compsSub = config.computationsSubcollection || 'computations';
+        const category = 'popular-investor';
+        const computationName = 'SignedInUserPIPersonalizedMetrics';
+        const today = new Date().toISOString().split('T')[0];
+        
+        // Try to find computation with user-specific fallback logic
+        let foundDate = null;
+        let metricsData = null;
+        let checkedDates = [];
+        
+        // Step 1: Try today, then look back 30 days for computation document
+        const latestComputationDate = await findLatestComputationDate(
+            db,
+            insightsCollection,
+            resultsSub,
+            compsSub,
+            category,
+            computationName,
+            null, // Don't check for specific user yet
+            30
+        );
+        
+        if (!latestComputationDate) {
+            // No computation exists at all - will fallback to frontend
+            logger.log('INFO', `[getSignedInUserPIPersonalizedMetrics] No computation document found, will use frontend fallback`);
+            return res.status(200).json({
+                status: 'fallback',
+                message: 'Computation not available, use frontend fallback',
+                data: null,
+                useFrontendFallback: true
+            });
+        }
+        
+        // Step 2: Check if user exists in latest computation, if not, look back 7 days
+        const latestDateObj = new Date(latestComputationDate + 'T00:00:00Z');
+        
+        for (let daysBack = 0; daysBack <= 7; daysBack++) {
+            const checkDate = new Date(latestDateObj);
+            checkDate.setUTCDate(latestDateObj.getUTCDate() - daysBack);
+            const dateStr = checkDate.toISOString().split('T')[0];
+            checkedDates.push(dateStr);
+            
+            const computationRef = db.collection(insightsCollection)
+                .doc(dateStr)
+                .collection(resultsSub)
+                .doc(category)
+                .collection(compsSub)
+                .doc(computationName);
+            
+            const computationDoc = await computationRef.get();
+            
+            if (computationDoc.exists) {
+                const rawData = computationDoc.data();
+                let computationData = tryDecompress(rawData);
+                
+                if (typeof computationData === 'string') {
+                    try {
+                        computationData = JSON.parse(computationData);
+                    } catch (e) {
+                        continue;
+                    }
+                }
+                
+                // Check if user exists in this computation
+                if (computationData && typeof computationData === 'object' && !Array.isArray(computationData)) {
+                    const userData = computationData[String(userCid)];
+                    if (userData) {
+                        foundDate = dateStr;
+                        metricsData = userData;
+                        logger.log('INFO', `[getSignedInUserPIPersonalizedMetrics] Found user ${userCid} in computation date ${dateStr}`);
+                        break;
+                    }
+                }
+            }
+        }
+        
+        // Step 3: If user not found in any computation, return fallback flag
+        if (!foundDate || !metricsData) {
+            logger.log('INFO', `[getSignedInUserPIPersonalizedMetrics] User ${userCid} not found in any computation, will use frontend fallback`);
+            return res.status(200).json({
+                status: 'fallback',
+                message: 'User not found in computation, use frontend fallback',
+                data: null,
+                useFrontendFallback: true,
+                checkedDates: checkedDates
+            });
+        }
+        
+        // Step 4: Enhance with review metrics and page views from Firestore
+        // These require cross-collection queries that aren't in computation
+        
+        // Fetch review metrics over time
+        const reviewsCollection = config.reviewsCollection || 'pi_reviews';
+        const reviewsSnapshot = await db.collection(reviewsCollection)
+            .where('piCid', '==', Number(userCid))
+            .orderBy('createdAt', 'desc')
+            .limit(1000) // Get enough for time series
+            .get();
+        
+        const reviewTimeMap = new Map();
+        let totalReviews = 0;
+        let totalRating = 0;
+        const ratingDistribution = { 1: 0, 2: 0, 3: 0, 4: 0, 5: 0 };
+        
+        reviewsSnapshot.forEach(doc => {
+            const review = doc.data();
+            const rating = review.rating || 0;
+            totalReviews++;
+            totalRating += rating;
+            ratingDistribution[rating] = (ratingDistribution[rating] || 0) + 1;
+            
+            if (review.createdAt) {
+                const reviewDate = review.createdAt.toDate ? review.createdAt.toDate().toISOString().split('T')[0] : review.createdAt;
+                const existing = reviewTimeMap.get(reviewDate) || { date: reviewDate, count: 0, totalRating: 0 };
+                existing.count++;
+                existing.totalRating += rating;
+                reviewTimeMap.set(reviewDate, existing);
+            }
+        });
+        
+        const reviewMetricsOverTime = Array.from(reviewTimeMap.values())
+            .map(entry => ({
+                date: entry.date,
+                averageRating: entry.count > 0 ? Number((entry.totalRating / entry.count).toFixed(2)) : 0,
+                count: entry.count
+            }))
+            .sort((a, b) => a.date.localeCompare(b.date));
+        
+        metricsData.reviewMetrics = {
+            overTime: reviewMetricsOverTime,
+            currentStats: {
+                averageRating: totalReviews > 0 ? Number((totalRating / totalReviews).toFixed(2)) : 0,
+                totalReviews: totalReviews,
+                distribution: ratingDistribution
+            },
+            sentimentTrend: [] // Could analyze review text sentiment if needed
+        };
+        
+        // Fetch profile views over time
+        const profileViewsCollection = config.profileViewsCollection || 'profile_views';
+        // Query without orderBy first, then sort in memory (to avoid index requirement)
+        const viewsSnapshot = await db.collection(profileViewsCollection)
+            .where('piCid', '==', Number(userCid))
+            .limit(90) // Last 90 days worth of documents
+            .get();
+        
+        const viewsOverTime = [];
+        let totalViews = 0;
+        let totalUniqueViews = 0;
+        const uniqueViewersSet = new Set();
+        const viewsByDate = new Map();
+        
+        viewsSnapshot.forEach(doc => {
+            const viewData = doc.data();
+            const date = viewData.date;
+            if (!date) return;
+            
+            const views = typeof viewData.totalViews === 'number' ? viewData.totalViews : 0;
+            const uniqueViewers = Array.isArray(viewData.uniqueViewers) ? viewData.uniqueViewers : [];
+            
+            // Aggregate by date (in case there are multiple docs per date)
+            const existing = viewsByDate.get(date) || { date, views: 0, uniqueViewers: [] };
+            existing.views += views;
+            existing.uniqueViewers = [...new Set([...existing.uniqueViewers, ...uniqueViewers])];
+            viewsByDate.set(date, existing);
+        });
+        
+        // Convert map to array and calculate totals
+        for (const [date, data] of viewsByDate.entries()) {
+            totalViews += data.views;
+            data.uniqueViewers.forEach(v => uniqueViewersSet.add(v));
+            
+            viewsOverTime.push({
+                date: date,
+                views: data.views,
+                uniqueViews: data.uniqueViewers.length
+            });
+        }
+        
+        totalUniqueViews = uniqueViewersSet.size;
+        const averageDailyViews = viewsOverTime.length > 0 ? Number((totalViews / viewsOverTime.length).toFixed(2)) : 0;
+        
+        metricsData.profileViews = {
+            overTime: viewsOverTime.sort((a, b) => a.date.localeCompare(b.date)),
+            totalViews: totalViews,
+            totalUniqueViews: totalUniqueViews,
+            averageDailyViews: averageDailyViews
+        };
+        
+        // Calculate engagement score
+        const reviewScore = metricsData.reviewMetrics.currentStats.averageRating * 20; // 0-100 scale
+        const viewScore = Math.min(100, (averageDailyViews / 10) * 100); // Cap at 100 for 10+ daily views
+        const copierScore = rankEntry.Copiers ? Math.min(100, (rankEntry.Copiers / 1000) * 100) : 0; // Cap at 100 for 1000+ copiers
+        const socialScore = metricsData.baseMetrics?.socialEngagement?.data?.length > 0 ? Math.min(100, (metricsData.baseMetrics.socialEngagement.data.length / 10) * 100) : 0;
+        
+        const engagementScore = (reviewScore * 0.3 + viewScore * 0.2 + copierScore * 0.3 + socialScore * 0.2);
+        
+        metricsData.engagementScore = {
+            current: Number(engagementScore.toFixed(2)),
+            components: {
+                reviewScore: Number(reviewScore.toFixed(2)),
+                viewScore: Number(viewScore.toFixed(2)),
+                copierScore: Number(copierScore.toFixed(2)),
+                socialScore: Number(socialScore.toFixed(2))
+            }
+        };
+        
+        logger.log('SUCCESS', `[getSignedInUserPIPersonalizedMetrics] Returning personalized metrics for user ${userCid} from date ${foundDate}`);
+        
+        return res.status(200).json({
+            status: 'success',
+            userCid: String(userCid),
+            data: metricsData,
+            dataDate: foundDate,
+            requestedDate: today,
+            isFallback: foundDate !== today,
+            daysBackFromLatest: checkedDates.indexOf(foundDate)
+        });
+        
+    } catch (error) {
+        logger.log('ERROR', `[getSignedInUserPIPersonalizedMetrics] Error fetching personalized metrics for ${userCid}:`, error);
+        return res.status(500).json({ error: error.message });
+    }
+}
+
 module.exports = { 
     getPiAnalytics, 
     getUserRecommendations, 
@@ -1635,5 +2358,8 @@ module.exports = {
     requestPiAddition,
     getWatchlistTriggerCounts,
     checkPisInRankings,
-    getPiProfile
+    getPiProfile,
+    checkIfUserIsPopularInvestor,
+    trackProfileView,
+    getSignedInUserPIPersonalizedMetrics
 };

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

@@ -21,7 +21,7 @@ function isDeveloperAccount(userCid) {
 /**
  * Get developer override data for a user
  * Auto-creates default document if it doesn't exist (for developer accounts only)
- * Returns null if not a developer
+ * Returns null if not a developerg,
  */
 async function getDevOverride(db, userCid, config, logger = null) {
     if (!isDeveloperAccount(userCid)) {
@@ -39,6 +39,7 @@ async function getDevOverride(db, userCid, config, logger = null) {
                 userCid: Number(userCid),
                 enabled: false,
                 fakeCopiedPIs: [],
+                pretendToBePI: false,
                 createdAt: FieldValue.serverTimestamp(),
                 lastUpdated: FieldValue.serverTimestamp()
             };
@@ -56,6 +57,7 @@ async function getDevOverride(db, userCid, config, logger = null) {
             return {
                 enabled: false,
                 fakeCopiedPIs: [],
+                pretendToBePI: false,
                 lastUpdated: null,
                 wasAutoCreated: true
             };
@@ -67,6 +69,7 @@ async function getDevOverride(db, userCid, config, logger = null) {
         return {
             enabled: data.enabled === true,
             fakeCopiedPIs: data.fakeCopiedPIs || [],
+            pretendToBePI: data.pretendToBePI === true,
             lastUpdated: data.lastUpdated,
             wasAutoCreated: false
         };
@@ -151,7 +154,7 @@ async function hasUserCopiedWithDevOverride(db, userCid, piCid, config, logger)
  */
 async function setDevOverride(req, res, dependencies, config) {
     const { db, logger } = dependencies;
-    const { userCid, enabled, fakeCopiedPIs } = req.body;
+    const { userCid, enabled, fakeCopiedPIs, pretendToBePI } = req.body;
     
     if (!userCid) {
         return res.status(400).json({ error: "Missing userCid" });
@@ -166,7 +169,7 @@ async function setDevOverride(req, res, dependencies, config) {
         });
     }
     
-    // Validate fakeCopiedPIs
+    // Validate fakeCopiedPIs (only required if enabled is true)
     if (enabled && (!Array.isArray(fakeCopiedPIs) || fakeCopiedPIs.length === 0)) {
         return res.status(400).json({ 
             error: "Invalid request",
@@ -181,16 +184,21 @@ async function setDevOverride(req, res, dependencies, config) {
         const devOverridesCollection = config.devOverridesCollection || 'dev_overrides';
         const overrideRef = db.collection(devOverridesCollection).doc(String(userCid));
         
+        // Get existing override to preserve values not being updated
+        const existingDoc = await overrideRef.get();
+        const existingData = existingDoc.exists ? existingDoc.data() : {};
+        
         const overrideData = {
             userCid: Number(userCid),
-            enabled: enabled === true,
-            fakeCopiedPIs: validatedPIs,
+            enabled: enabled !== undefined ? (enabled === true) : (existingData.enabled || false),
+            fakeCopiedPIs: enabled !== undefined ? validatedPIs : (existingData.fakeCopiedPIs || []),
+            pretendToBePI: pretendToBePI !== undefined ? (pretendToBePI === true) : (existingData.pretendToBePI || false),
             lastUpdated: FieldValue.serverTimestamp()
         };
         
         await overrideRef.set(overrideData, { merge: true });
         
-        logger.log('SUCCESS', `[setDevOverride] Updated dev override for user ${userCid}: enabled=${enabled}, ${validatedPIs.length} fake PIs`);
+        logger.log('SUCCESS', `[setDevOverride] Updated dev override for user ${userCid}: enabled=${overrideData.enabled}, pretendToBePI=${overrideData.pretendToBePI}, ${validatedPIs.length} fake PIs`);
         
         return res.status(200).json({
             success: true,
@@ -239,6 +247,7 @@ async function getDevOverrideStatus(req, res, dependencies, config) {
         return res.status(200).json({
             enabled: devOverride.enabled,
             fakeCopiedPIs: devOverride.fakeCopiedPIs,
+            pretendToBePI: devOverride.pretendToBePI || false,
             lastUpdated: devOverride.lastUpdated,
             wasAutoCreated: devOverride.wasAutoCreated || false
         });

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

@@ -4,7 +4,7 @@
  */
 const express = require('express');
 const { submitReview, getReviews, getUserReview, checkReviewEligibility } = require('./helpers/review_helpers');
-const { getPiAnalytics, getUserRecommendations, getWatchlist, updateWatchlist, autoGenerateWatchlist, getUserDataStatus, getUserPortfolio, getUserSocialPosts, getUserComputations, getUserVerification, getInstrumentMappings, searchPopularInvestors, requestPiAddition, getWatchlistTriggerCounts, checkPisInRankings, getPiProfile } = require('./helpers/data_helpers');
+const { getPiAnalytics, getUserRecommendations, getWatchlist, updateWatchlist, autoGenerateWatchlist, getUserDataStatus, getUserPortfolio, getUserSocialPosts, getUserComputations, getUserVerification, getInstrumentMappings, searchPopularInvestors, requestPiAddition, getWatchlistTriggerCounts, checkPisInRankings, getPiProfile, checkIfUserIsPopularInvestor, trackProfileView, getSignedInUserPIPersonalizedMetrics } = 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');
@@ -26,6 +26,7 @@ module.exports = (dependencies, config) => {
     // --- Data Serving ---
     router.get('/pi/:cid/analytics', (req, res) => getPiAnalytics(req, res, dependencies, config));
     router.get('/pi/:cid/profile', (req, res) => getPiProfile(req, res, dependencies, config));
+    router.post('/pi/:piCid/track-view', (req, res) => trackProfileView(req, res, dependencies, config));
     
     // Signed-In User Personalized Routes
     // Note: Router is mounted at /user, so these routes should be /me/* not /user/me/*
@@ -37,6 +38,8 @@ module.exports = (dependencies, config) => {
     router.get('/me/computations', (req, res) => getUserComputations(req, res, dependencies, config));
     router.get('/me/verification', (req, res) => getUserVerification(req, res, dependencies, config));
     router.get('/me/instrument-mappings', (req, res) => getInstrumentMappings(req, res, dependencies, config));
+    router.get('/me/is-popular-investor', (req, res) => checkIfUserIsPopularInvestor(req, res, dependencies, config));
+    router.get('/me/pi-personalized-metrics', (req, res) => getSignedInUserPIPersonalizedMetrics(req, res, dependencies, config));
 
     // --- Watchlist & Alerts ---
     // Legacy single watchlist endpoints (for backward compatibility)

package/package.json

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