bulltrackers-module 1.0.629 → 1.0.631

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

@@ -1,182 +0,0 @@
-/**
- * @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),
-                collectionRegistry: dependencies.collectionRegistry
-            }
-        );
-        
-        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(', ')}`);
-            
-            // Note: With the new pages subcollection structure, we can't enumerate all available CIDs
-            // from a single document, so we skip that debug information
-            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,
-                    latestDate: latestDate
-                }
-            });
-        }
-        
-        // Get username from rankings
-        const { getPiUsername } = require('../fetch/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/old-generic-api/user-api/helpers/profile/profile_view_helpers.js

@@ -1,137 +0,0 @@
-/**
- * @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');
-const { updatePageViewsRootData } = require('../rootdata/rootdata_aggregation_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
-            // Note: date is already in path params, so don't provide documentId
-            const existingResult = await readWithMigration(
-                db,
-                'popularInvestors',
-                'profileViews',
-                { piCid, date: today },
-                {
-                    isCollection: false,
-                    dataType: 'piProfileViews',
-                    config,
-                    // documentId not needed - date is already in path params
-                    collectionRegistry: dependencies.collectionRegistry
-                }
-            );
-            
-            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)
-        // Note: date is already in path params, so don't provide documentId
-        await writeWithMigration(
-            db,
-            'popularInvestors',
-            'profileViews',
-            { piCid, date: today },
-            viewData,
-            {
-                isCollection: false,
-                merge: true,
-                dataType: 'piProfileViews',
-                config,
-                // documentId not needed - date is already in path params
-                dualWrite: true,
-                collectionRegistry: dependencies.collectionRegistry
-            }
-        );
-        
-        // 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)
-            // Note: viewId is already in path params, so don't provide documentId
-            await writeWithMigration(
-                db,
-                'popularInvestors',
-                'individualViews',
-                { piCid, viewId },
-                individualViewData,
-                {
-                    isCollection: false,
-                    merge: true,
-                    dataType: 'piIndividualViews',
-                    config,
-                    // documentId not needed - viewId is already in path params
-                    dualWrite: true,
-                    collectionRegistry: dependencies.collectionRegistry
-                }
-            );
-        }
-        
-        // Update global rootdata collection for computation system
-        if (effectiveViewerCid) {
-            await updatePageViewsRootData(db, logger, piCid, effectiveViewerCid, today);
-        }
-        
-        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/old-generic-api/user-api/helpers/profile/user_profile_helpers.js

@@ -1,190 +0,0 @@
-/**
- * @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/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 },
-            {
-                collectionRegistry: dependencies.collectionRegistry,
-                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 devOverride = await getDevOverride(db, userCid, config, logger);
-        
-        // For PI-related checks, respect pretendToBePI flag
-        // If pretendToBePI is false, use actual userCid even if impersonateCid is set
-        let effectiveCid;
-        if (devOverride && devOverride.enabled && devOverride.pretendToBePI === false) {
-            // User explicitly doesn't want to pretend to be a PI, use actual CID
-            effectiveCid = Number(userCid);
-        } else {
-            // Use normal effective CID logic (may use impersonateCid if set)
-            effectiveCid = await getEffectiveCid(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/old-generic-api/user-api/helpers/recommendations/recommendation_helpers.js

@@ -1,66 +0,0 @@
-/**
- * @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,
-                collectionRegistry: dependencies.collectionRegistry
-            }
-        );
-        
-        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
-};
-