bulltrackers-module 1.0.592 → 1.0.593

package/functions/old-generic-api/user-api/helpers/core/data_lookup_helpers.js

@@ -0,0 +1,256 @@
+/**
+ * @fileoverview Data Lookup Utilities
+ * Functions to find latest available data dates for various collections
+ */
+
+/**
+ * Find the latest available date for signed-in user portfolio data
+ * Searches backwards from today up to maxDaysBack days
+ * Checks both new root data path and legacy path for compatibility
+ * @param {Firestore} db - Firestore instance
+ * @param {string} signedInUsersCollection - Collection name (legacy)
+ * @param {string|number} userCid - User CID
+ * @param {number} maxDaysBack - Maximum days to search backwards (default: 30)
+ * @returns {Promise<string|null>} - Date string (YYYY-MM-DD) or null if not found
+ */
+async function findLatestPortfolioDate(db, signedInUsersCollection, userCid, maxDaysBack = 30) {
+    const today = new Date();
+    const userCidStr = String(userCid);
+    
+    // First, check the user-centric latest snapshot (fastest check)
+    try {
+        const latestRef = db.collection('SignedInUsers')
+            .doc(userCidStr)
+            .collection('portfolio')
+            .doc('latest');
+        
+        const latestDoc = await latestRef.get();
+        if (latestDoc.exists) {
+            const data = latestDoc.data();
+            if (data && data.date) {
+                return data.date; // Found in latest snapshot
+            }
+        }
+    } catch (error) {
+        // Continue to other checks if this fails
+    }
+    
+    // Second, check the new root data path: SignedInUserPortfolioData/{date}/{cid}/{cid}
+    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 rootDataRef = db.collection('SignedInUserPortfolioData')
+                .doc(dateStr)
+                .collection(userCidStr)
+                .doc(userCidStr);
+            
+            const rootDataDoc = await rootDataRef.get();
+            if (rootDataDoc.exists) {
+                return dateStr; // Found data in root data collection
+            }
+        } catch (error) {
+            // Continue to next date if error
+            continue;
+        }
+    }
+    
+    // Third, check legacy path for backward compatibility: {signedInUsersCollection}/19M/snapshots/{date}/parts
+    const CANARY_BLOCK_ID = '19M';
+    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 partsRef = db.collection(signedInUsersCollection)
+                .doc(CANARY_BLOCK_ID)
+                .collection('snapshots')
+                .doc(dateStr)
+                .collection('parts');
+            
+            const partsSnapshot = await partsRef.get();
+            
+            // Check if user's CID exists in any part document
+            for (const partDoc of partsSnapshot.docs) {
+                const partData = partDoc.data();
+                if (partData && partData[userCidStr]) {
+                    return dateStr; // Found data for this date in legacy path
+                }
+            }
+        } catch (error) {
+            // Continue to next date if error
+            continue;
+        }
+    }
+    
+    return null; // No data found in the last maxDaysBack days
+}
+
+/**
+ * Find the latest available date for computation results
+ * Searches backwards from today up to maxDaysBack days
+ * @param {Firestore} db - Firestore instance
+ * @param {string} insightsCollection - Insights collection name
+ * @param {string} resultsSub - Results subcollection name
+ * @param {string} compsSub - Computations subcollection name
+ * @param {string} category - Category name
+ * @param {string} computationName - Computation name
+ * @param {string|number} userCid - User CID (for logging)
+ * @param {number} maxDaysBack - Maximum days to search backwards (default: 30)
+ * @returns {Promise<string|null>} - Date string (YYYY-MM-DD) or null if not found
+ */
+async function findLatestComputationDate(db, insightsCollection, resultsSub, compsSub, category, computationName, userCid, 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 computationRef = db.collection(insightsCollection)
+                .doc(dateStr)
+                .collection(resultsSub)
+                .doc(category)
+                .collection(compsSub)
+                .doc(computationName);
+            
+            const computationDoc = await computationRef.get();
+            
+            // Just check if document exists - don't check for CID here
+            // We'll check for CID in the calling function after decompression
+            if (computationDoc.exists) {
+                return dateStr; // Found document for this date
+            }
+        } catch (error) {
+            // Continue to next date if error
+            continue;
+        }
+    }
+    
+    return null; // No document found in the last maxDaysBack days
+}
+
+/**
+ * Find the latest available date for Popular Investor rankings
+ * Searches backwards from today up to maxDaysBack days
+ * @param {Firestore} db - Firestore instance
+ * @param {string} rankingsCollection - Rankings collection name
+ * @param {number} maxDaysBack - Maximum days to search backwards (default: 30)
+ * @returns {Promise<string|null>} - Date string (YYYY-MM-DD) or null if not found
+ */
+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
+}
+
+/**
+ * Find the latest available date for Popular Investor portfolio data
+ * Searches backwards from today up to maxDaysBack days
+ * @param {Firestore} db - Firestore instance
+ * @param {string} piPortfoliosCollection - PI portfolios collection name
+ * @param {string|number} userCid - User CID
+ * @param {number} maxDaysBack - Maximum days to search backwards (default: 30)
+ * @returns {Promise<string|null>} - Date string (YYYY-MM-DD) or null if not found
+ */
+async function findLatestPiPortfolioDate(db, piPortfoliosCollection, userCid, maxDaysBack = 30) {
+    const CANARY_BLOCK_ID = '19M';
+    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 partsRef = db.collection(piPortfoliosCollection)
+                .doc(CANARY_BLOCK_ID)
+                .collection('snapshots')
+                .doc(dateStr)
+                .collection('parts');
+            
+            const partsSnapshot = await partsRef.get();
+            
+            // Check if user's CID exists in any part document
+            for (const partDoc of partsSnapshot.docs) {
+                const partData = partDoc.data();
+                if (partData && partData[String(userCid)]) {
+                    return dateStr; // Found data for this date
+                }
+            }
+        } catch (error) {
+            // Continue to next date if error
+            continue;
+        }
+    }
+    
+    return null; // No data found in the last maxDaysBack days
+}
+
+/**
+ * Find the latest available date for Popular Investor history data
+ * Searches backwards from today up to maxDaysBack days
+ * @param {Firestore} db - Firestore instance
+ * @param {string} piHistoryCollection - PI history collection name
+ * @param {string|number} userCid - User CID
+ * @param {number} maxDaysBack - Maximum days to search backwards (default: 30)
+ * @returns {Promise<string|null>} - Date string (YYYY-MM-DD) or null if not found
+ */
+async function findLatestPiHistoryDate(db, piHistoryCollection, userCid, 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 historyRef = db.collection(piHistoryCollection)
+                .doc(String(userCid))
+                .collection('history')
+                .doc(dateStr);
+            
+            const historyDoc = await historyRef.get();
+            
+            if (historyDoc.exists) {
+                return dateStr; // Found history for this date
+            }
+        } catch (error) {
+            // Continue to next date if error
+            continue;
+        }
+    }
+    
+    return null; // No data found in the last maxDaysBack days
+}
+
+module.exports = {
+    findLatestPortfolioDate,
+    findLatestComputationDate,
+    findLatestRankingsDate,
+    findLatestPiPortfolioDate,
+    findLatestPiHistoryDate
+};
+