bulltrackers-module 1.0.570 → 1.0.572

package/functions/computation-system/context/ManifestBuilder.js

@@ -250,6 +250,7 @@ function buildManifest(productLinesToRun = [], calculations) {
             category: folderName === 'core' && metadata.category ? metadata.category : folderName,     
             sourcePackage: folderName,   
             type: metadata.type,
+            isPage: metadata.isPage === true,
             isHistorical: metadata.isHistorical !== undefined ? metadata.isHistorical : false, 
             rootDataDependencies: metadata.rootDataDependencies || [],
             canHaveMissingRoots: metadata.canHaveMissingRoots || false,

package/functions/generic-api/user-api/helpers/data/portfolio_helpers.js

@@ -148,51 +148,70 @@ async function getUserDataStatus(req, res, dependencies, config) {
         const category = 'popular-investor';
         const computationName = 'SignedInUserProfileMetrics';
         
-        // Find latest computation date
-        const latestComputationDate = await findLatestComputationDate(
-            db,
-            insightsCollection,
-            resultsSub,
-            compsSub,
-            category,
-            computationName,
-            effectiveCid,
-            30
-        );
-        
         let computationAvailable = false;
         let computationDate = null;
         let isComputationFallback = false;
         
-        if (latestComputationDate) {
-            // Check if this specific user exists in the computation
-            const { found } = await checkPiInComputationDate(
-                db,
-                insightsCollection,
-                resultsSub,
-                compsSub,
-                category,
-                computationName,
-                latestComputationDate,
-                String(effectiveCid),
-                logger
-            );
+        // Search backwards from today to find the latest date where user exists in computation
+        // Priority: Today (T) -> Yesterday (T-1) -> Continue backwards up to 30 days
+        const maxDaysBack = 30;
+        let foundDate = null;
+        
+        for (let daysBack = 0; daysBack < maxDaysBack; daysBack++) {
+            const checkDate = new Date();
+            checkDate.setDate(checkDate.getDate() - daysBack);
+            const dateStr = checkDate.toISOString().split('T')[0];
             
-            if (found) {
-                computationAvailable = true;
-                computationDate = latestComputationDate;
-                isComputationFallback = latestComputationDate !== today;
+            try {
+                // Check if computation document exists for this date
+                const computationRef = db.collection(insightsCollection)
+                    .doc(dateStr)
+                    .collection(resultsSub)
+                    .doc(category)
+                    .collection(compsSub)
+                    .doc(computationName);
+                
+                const computationDoc = await computationRef.get();
                 
-                if (isComputationFallback) {
-                    logger.log('INFO', `[getUserDataStatus] Using fallback computation date ${computationDate} for user ${userCid} (today: ${today})`);
-                } else {
-                    logger.log('INFO', `[getUserDataStatus] Found computation for user ${userCid} on today's date`);
+                if (computationDoc.exists) {
+                    // Computation exists for this date, check if user is in it
+                    const { found } = await checkPiInComputationDate(
+                        db,
+                        insightsCollection,
+                        resultsSub,
+                        compsSub,
+                        category,
+                        computationName,
+                        dateStr,
+                        String(effectiveCid),
+                        logger
+                    );
+                    
+                    if (found) {
+                        foundDate = dateStr;
+                        computationAvailable = true;
+                        computationDate = dateStr;
+                        isComputationFallback = daysBack > 0;
+                        
+                        if (isComputationFallback) {
+                            logger.log('INFO', `[getUserDataStatus] Found computation for user ${userCid} on date ${computationDate} (${daysBack} days back from today: ${today})`);
+                        } else {
+                            logger.log('INFO', `[getUserDataStatus] Found computation for user ${userCid} on today's date`);
+                        }
+                        break; // Found user, stop searching
+                    } else {
+                        logger.log('DEBUG', `[getUserDataStatus] Computation exists for date ${dateStr} but user ${userCid} not found in it, continuing search...`);
+                    }
                 }
-            } else {
-                logger.log('INFO', `[getUserDataStatus] Computation exists for date ${latestComputationDate} but user ${userCid} not found in it`);
+            } catch (error) {
+                // Continue to next date if error
+                logger.log('DEBUG', `[getUserDataStatus] Error checking date ${dateStr}:`, error.message);
+                continue;
             }
-        } else {
-            logger.log('INFO', `[getUserDataStatus] No computation found for user ${userCid} in last 30 days`);
+        }
+        
+        if (!foundDate) {
+            logger.log('INFO', `[getUserDataStatus] No computation found for user ${userCid} in last ${maxDaysBack} days`);
         }
         
         // For backward compatibility, keep portfolioAvailable and historyAvailable
@@ -201,14 +220,22 @@ async function getUserDataStatus(req, res, dependencies, config) {
             portfolioAvailable: computationAvailable, // Profile page uses computation, not raw portfolio
             historyAvailable: computationAvailable,  // Profile page uses computation, not raw history
             computationAvailable: computationAvailable, // Explicit computation check
-            date: computationDate || today,
-            computationDate: computationDate,
-            isComputationFallback: isComputationFallback,
-            requestedDate: today,
+            date: computationDate || today, // Use found date or today as fallback
+            computationDate: computationDate, // The actual date where computation was found
+            isComputationFallback: isComputationFallback, // True if using T-1 or older date
+            requestedDate: today, // What date was requested (today)
             userCid: String(userCid),
             effectiveCid: String(effectiveCid)
         };
         
+        if (computationAvailable && isComputationFallback) {
+            logger.log('INFO', `[getUserDataStatus] Using fallback date ${computationDate} for CID ${userCid} (requested: ${today})`);
+        } else if (computationAvailable) {
+            logger.log('INFO', `[getUserDataStatus] Using today's date ${computationDate} for CID ${userCid}`);
+        } else {
+            logger.log('WARN', `[getUserDataStatus] No computation found for CID ${userCid} in last ${maxDaysBack} days`);
+        }
+        
         logger.log('INFO', `[getUserDataStatus] Result for CID ${userCid}:`, result);
         
         return res.status(200).json(result);

package/package.json

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