bulltrackers-module 1.0.435 → 1.0.437

package/functions/core/utils/firestore_utils.js

@@ -226,8 +226,38 @@ async function getSpeculatorsToUpdate(dependencies, config) {
     } catch (error) { logger.log('ERROR','[Core Utils] Error getting speculators to update', { errorMessage: error.message }); throw error; }
 }
 
+/**
+ * Helper function to find the latest available date for Popular Investor rankings
+ * Searches backwards from today up to 30 days
+ */
+async function findLatestRankingsDate(db, rankingsCollection, maxDaysBack = 30) {
+    const today = new Date();
+    
+    for (let i = 0; i < maxDaysBack; i++) {
+        const checkDate = new Date(today);
+        checkDate.setDate(checkDate.getDate() - i);
+        const dateStr = checkDate.toISOString().split('T')[0];
+        
+        try {
+            const rankingsRef = db.collection(rankingsCollection).doc(dateStr);
+            const rankingsDoc = await rankingsRef.get();
+            
+            if (rankingsDoc.exists) {
+                return dateStr; // Found rankings for this date
+            }
+        } catch (error) {
+            // Continue to next date if error
+            continue;
+        }
+    }
+    
+    return null; // No rankings found in the last maxDaysBack days
+}
+
 /**
  * [NEW] Fetches Popular Investors from the daily rankings document.
+ * UPDATED: Uses latest available rankings date if today's doesn't exist (fallback for edge cases).
+ * This ensures the dispatcher can still queue tasks even if today's rankings haven't been fetched yet.
  */
 async function getPopularInvestorsToUpdate(dependencies, config) {
     const { db, logger } = dependencies;
@@ -235,17 +265,32 @@ async function getPopularInvestorsToUpdate(dependencies, config) {
 
     logger.log('INFO', `[Core Utils] Getting Popular Investors to update from ${collectionName}...`);
     
-    // Construct today's document ID (YYYY-MM-DD)
+    // Try today's date first
     const today = new Date().toISOString().split('T')[0];
-    const docPath = `${collectionName}/${today}`;
-
+    let rankingsDate = today;
+    
     try {
-        const docRef = db.doc(docPath);
-        const docSnap = await docRef.get();
+        let docRef = db.collection(collectionName).doc(today);
+        let docSnap = await docRef.get();
 
+        // If today's rankings don't exist, fallback to latest available date
         if (!docSnap.exists) {
-            logger.log('WARN', `[Core Utils] No Popular Investor rankings found for date: ${today} at ${docPath}`);
-            return [];
+            logger.log('WARN', `[Core Utils] No Popular Investor rankings found for date: ${today}. Looking for latest available date...`);
+            rankingsDate = await findLatestRankingsDate(db, collectionName, 30);
+            
+            if (!rankingsDate) {
+                logger.log('WARN', `[Core Utils] No Popular Investor rankings found in last 30 days. Returning empty array.`);
+                return [];
+            }
+            
+            logger.log('INFO', `[Core Utils] Using fallback rankings date: ${rankingsDate} (today: ${today})`);
+            docRef = db.collection(collectionName).doc(rankingsDate);
+            docSnap = await docRef.get();
+            
+            if (!docSnap.exists) {
+                logger.log('WARN', `[Core Utils] Rankings doc does not exist for fallback date ${rankingsDate}`);
+                return [];
+            }
         }
 
         const data = docSnap.data();
@@ -261,7 +306,7 @@ async function getPopularInvestorsToUpdate(dependencies, config) {
             logger.log('INFO', `[Core Utils Debug] First PI Target Mapped: ${JSON.stringify(targets[0])}`);
         }
 
-        logger.log('INFO', `[Core Utils] Found ${targets.length} Popular Investors from ${today} ranking.`);
+        logger.log('INFO', `[Core Utils] Found ${targets.length} Popular Investors from ${rankingsDate} ranking${rankingsDate !== today ? ` (fallback from ${today})` : ''}.`);
         return targets;
 
     } catch (error) {

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

@@ -2465,7 +2465,7 @@ async function getSignedInUserPIPersonalizedMetrics(req, res, dependencies, conf
 
 module.exports = { 
     getPiAnalytics, 
-    getUserRecommendations, 
+    getUserRecommendations,
     getWatchlist,
     updateWatchlist,
     autoGenerateWatchlist,
@@ -2481,6 +2481,8 @@ module.exports = {
     checkPisInRankings,
     getPiProfile,
     checkIfUserIsPopularInvestor,
+    checkIfUserIsPI, // Export for use in review_helpers
+    findLatestRankingsDate, // Export for use in on_demand_fetch_helpers
     trackProfileView,
     getSignedInUserPIPersonalizedMetrics
 };

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

@@ -16,16 +16,27 @@ const RATE_LIMIT_MS = RATE_LIMIT_HOURS * 60 * 60 * 1000;
 async function requestPiFetch(req, res, dependencies, config) {
     const { db, logger, pubsub } = dependencies;
     const { piCid } = req.params;
-    const userCid = req.user?.etoroCID || req.query?.userCid;
+    
+    // Get userCid from query (same pattern as other endpoints)
+    const userCid = req.query?.userCid;
     
     if (!userCid) {
-        return res.status(401).json({ 
+        return res.status(400).json({ 
             success: false,
-            error: "Authentication required",
-            message: "You must be signed in to request data fetching"
+            error: "Missing userCid",
+            message: "Please provide userCid as a query parameter"
         });
     }
     
+    // Check for dev override impersonation (same pattern as other endpoints)
+    const { getEffectiveCid, getDevOverride } = require('./dev_helpers');
+    const effectiveCid = await getEffectiveCid(db, userCid, config, logger);
+    const devOverride = await getDevOverride(db, userCid, config, logger);
+    const isImpersonating = devOverride && devOverride.impersonateCid && effectiveCid !== Number(userCid);
+    
+    // Use effective CID for the request (impersonated or actual)
+    const requestUserCid = Number(effectiveCid);
+    
     const piCidNum = Number(piCid);
     if (isNaN(piCidNum) || piCidNum <= 0) {
         return res.status(400).json({
@@ -36,8 +47,8 @@ async function requestPiFetch(req, res, dependencies, config) {
     }
     
     try {
-        // Check rate limits
-        const rateLimitCheck = await checkRateLimits(db, userCid, piCidNum, logger);
+        // Check rate limits (use effective CID)
+        const rateLimitCheck = await checkRateLimits(db, requestUserCid, piCidNum, logger);
         
         if (!rateLimitCheck.allowed) {
             return res.status(429).json({
@@ -54,7 +65,7 @@ async function requestPiFetch(req, res, dependencies, config) {
         }
         
         // Get PI username from rankings (needed for task engine)
-        const piUsername = await getPiUsername(db, piCidNum, logger);
+        const piUsername = await getPiUsername(db, piCidNum, config, logger);
         if (!piUsername) {
             return res.status(404).json({
                 success: false,
@@ -75,22 +86,24 @@ async function requestPiFetch(req, res, dependencies, config) {
         
         await requestRef.set({
             requestId,
-            userCid: Number(userCid),
+            userCid: requestUserCid, // Use effective CID
+            actualUserCid: Number(userCid), // Track actual developer CID for audit
             piCid: piCidNum,
             piUsername,
             status: 'queued',
+            isImpersonating: isImpersonating || false,
             createdAt: FieldValue.serverTimestamp(),
             updatedAt: FieldValue.serverTimestamp()
         });
         
-        // Update user rate limit
+        // Update user rate limit (use effective CID)
         const userRequestRef = db.collection('pi_fetch_requests')
             .doc(String(piCidNum))
             .collection('user_requests')
-            .doc(String(userCid));
+            .doc(String(requestUserCid));
         
         await userRequestRef.set({
-            userCid: Number(userCid),
+            userCid: requestUserCid,
             piCid: piCidNum,
             lastRequestedAt: FieldValue.serverTimestamp(),
             requestCount: FieldValue.increment(1),
@@ -106,7 +119,7 @@ async function requestPiFetch(req, res, dependencies, config) {
         await globalRef.set({
             piCid: piCidNum,
             lastRequestedAt: FieldValue.serverTimestamp(),
-            lastRequestedBy: Number(userCid),
+            lastRequestedBy: requestUserCid, // Use effective CID
             totalRequests: FieldValue.increment(1),
             updatedAt: FieldValue.serverTimestamp()
         }, { merge: true });
@@ -122,10 +135,12 @@ async function requestPiFetch(req, res, dependencies, config) {
             priority: 'high',
             source: 'on_demand',
             requestId,
-            requestedBy: Number(userCid),
+            requestedBy: requestUserCid, // Use effective CID
+            actualRequestedBy: Number(userCid), // Track actual developer CID
             metadata: {
                 onDemand: true,
-                requestedAt: now.toISOString()
+                requestedAt: now.toISOString(),
+                isImpersonating: isImpersonating || false
             }
         };
         
@@ -139,7 +154,7 @@ async function requestPiFetch(req, res, dependencies, config) {
             updatedAt: FieldValue.serverTimestamp()
         });
         
-        logger.log('INFO', `[requestPiFetch] User ${userCid} requested fetch for PI ${piCidNum} (${piUsername}). Request ID: ${requestId}`);
+        logger.log('INFO', `[requestPiFetch] User ${userCid}${isImpersonating ? ` (impersonating ${requestUserCid})` : ''} requested fetch for PI ${piCidNum} (${piUsername}). Request ID: ${requestId}`);
         
         return res.status(200).json({
             success: true,
@@ -170,7 +185,7 @@ async function requestPiFetch(req, res, dependencies, config) {
 async function getPiFetchStatus(req, res, dependencies, config) {
     const { db, logger } = dependencies;
     const { piCid } = req.params;
-    const userCid = req.user?.etoroCID || req.query?.userCid;
+    const userCid = req.query?.userCid; // Optional - for rate limit info
     
     const piCidNum = Number(piCid);
     if (isNaN(piCidNum) || piCidNum <= 0) {
@@ -380,20 +395,46 @@ async function checkRateLimits(db, userCid, piCid, logger) {
 
 /**
  * Get PI username from rankings
+ * Uses latest available rankings date (with fallback)
  */
-async function getPiUsername(db, piCid, logger) {
+async function getPiUsername(db, piCid, config, logger) {
     try {
-        const rankingsRef = db.collection('rankings')
-            .doc('latest')
-            .collection('popular_investors')
-            .doc(String(piCid));
-        
-        const doc = await rankingsRef.get();
-        if (doc.exists) {
-            const data = doc.data();
-            return data.username || data.Username || null;
+        // Import the helper function from data_helpers
+        const { findLatestRankingsDate } = require('./data_helpers');
+        
+        const rankingsCollection = config.popularInvestorRankingsCollection || process.env.FIRESTORE_COLLECTION_PI_RANKINGS || 'popular_investor_rankings';
+        const rankingsDate = await findLatestRankingsDate(db, rankingsCollection, 30);
+        
+        if (!rankingsDate) {
+            logger.log('WARN', `[getPiUsername] No rankings data found (checked last 30 days) for PI ${piCid}`);
+            return null;
+        }
+        
+        // Fetch rankings document for the latest available date
+        const rankingsRef = db.collection(rankingsCollection).doc(rankingsDate);
+        const rankingsDoc = await rankingsRef.get();
+        
+        if (!rankingsDoc.exists) {
+            logger.log('WARN', `[getPiUsername] Rankings doc does not exist for date ${rankingsDate}`);
+            return null;
+        }
+        
+        const rankingsData = rankingsDoc.data();
+        const rankingsItems = rankingsData.Items || [];
+        
+        // Search for the PI in the rankings items
+        const piCidNum = Number(piCid);
+        const rankingEntry = rankingsItems.find(item => Number(item.CustomerId) === piCidNum);
+        
+        if (rankingEntry) {
+            const username = rankingEntry.UserName || rankingEntry.username || null;
+            if (username) {
+                logger.log('INFO', `[getPiUsername] Found username "${username}" for PI ${piCid} in rankings date ${rankingsDate}`);
+            }
+            return username;
         }
         
+        logger.log('WARN', `[getPiUsername] PI ${piCid} not found in rankings date ${rankingsDate}`);
         return null;
     } catch (error) {
         logger.log('ERROR', `[getPiUsername] Error fetching username for PI ${piCid}`, error);

package/package.json

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