bulltrackers-module 1.0.592 → 1.0.593

package/functions/old-generic-api/user-api/helpers/search/pi_search_helpers.js

@@ -0,0 +1,162 @@
+/**
+ * @fileoverview Popular Investor Search Helpers
+ * Handles PI search endpoints
+ */
+
+const { getPIMasterList } = require('../core/user_status_helpers');
+const { tryDecompress } = require('../core/compression_helpers');
+
+/**
+ * GET /user/search/pis
+ * Search for Popular Investors by username
+ */
+async function searchPopularInvestors(req, res, dependencies, config) {
+    const { db, logger } = dependencies;
+    const { query, limit = 20 } = req.query;
+    
+    if (!query || query.trim().length < 2) {
+        return res.status(400).json({ error: "Query must be at least 2 characters" });
+    }
+    
+    try {
+        // Use master list instead of rankings (single source of truth)
+        const collectionRegistry = dependencies.collectionRegistry || null;
+        const investors = await getPIMasterList(db, collectionRegistry, logger);
+        
+        if (Object.keys(investors).length === 0) {
+            return res.status(404).json({ error: "Popular investor data not available" });
+        }
+        
+        // Search by username (case-insensitive, partial match)
+        const searchQuery = query.toLowerCase().trim();
+        const matches = [];
+        const rankingsCollection = config.popularInvestorRankingsCollection || process.env.FIRESTORE_COLLECTION_PI_RANKINGS || 'popular_investor_rankings';
+        
+        // Cache rankings data by date to avoid fetching the same date multiple times
+        const rankingsCache = new Map();
+        
+        /**
+         * Helper to get rankings data for a specific date
+         */
+        const getRankingsForDate = async (dateStr) => {
+            if (rankingsCache.has(dateStr)) {
+                return rankingsCache.get(dateStr);
+            }
+            
+            try {
+                const rankingsRef = db.collection(rankingsCollection).doc(dateStr);
+                const rankingsDoc = await rankingsRef.get();
+                
+                if (!rankingsDoc.exists) {
+                    rankingsCache.set(dateStr, null);
+                    return null;
+                }
+                
+                const rawRankingsData = rankingsDoc.data();
+                const rankingsData = tryDecompress(rawRankingsData);
+                const rankingsItems = rankingsData.Items || [];
+                
+                // Create a map for quick lookup by CID
+                const rankingsMap = new Map();
+                for (const item of rankingsItems) {
+                    if (item.CustomerId) {
+                        rankingsMap.set(String(item.CustomerId), item);
+                    }
+                }
+                
+                rankingsCache.set(dateStr, rankingsMap);
+                return rankingsMap;
+            } catch (error) {
+                if (logger) {
+                    logger.log('WARN', `[searchPopularInvestors] Failed to fetch rankings for date ${dateStr}: ${error.message}`);
+                }
+                rankingsCache.set(dateStr, null);
+                return null;
+            }
+        };
+        
+        /**
+         * Convert timestamp to date string (YYYY-MM-DD)
+         */
+        const timestampToDateStr = (timestamp) => {
+            if (!timestamp) return null;
+            
+            // Handle Firestore Timestamp
+            if (timestamp.toDate && typeof timestamp.toDate === 'function') {
+                return timestamp.toDate().toISOString().split('T')[0];
+            }
+            
+            // Handle Date object
+            if (timestamp instanceof Date) {
+                return timestamp.toISOString().split('T')[0];
+            }
+            
+            // Handle number (milliseconds since epoch)
+            if (typeof timestamp === 'number') {
+                return new Date(timestamp).toISOString().split('T')[0];
+            }
+            
+            return null;
+        };
+        
+        for (const [cid, investor] of Object.entries(investors)) {
+            if (investor.username) {
+                const username = investor.username.toLowerCase();
+                if (username.includes(searchQuery)) {
+                    // Get ranking metrics from rankings collection using lastSeenAt
+                    let aum = null;
+                    let riskScore = null;
+                    let gain = null;
+                    let copiers = null;
+                    
+                    if (investor.lastSeenAt) {
+                        const rankingsDate = timestampToDateStr(investor.lastSeenAt);
+                        
+                        if (rankingsDate) {
+                            const rankingsMap = await getRankingsForDate(rankingsDate);
+                            
+                            if (rankingsMap) {
+                                const rankingEntry = rankingsMap.get(cid);
+                                
+                                if (rankingEntry) {
+                                    aum = rankingEntry.AUMValue || null;
+                                    riskScore = rankingEntry.RiskScore || null;
+                                    gain = rankingEntry.Gain || null;
+                                    copiers = rankingEntry.Copiers || null;
+                                }
+                            }
+                        }
+                    }
+                    
+                    matches.push({
+                        cid: Number(cid),
+                        username: investor.username,
+                        aum: aum,
+                        riskScore: riskScore,
+                        gain: gain,
+                        copiers: copiers
+                    });
+                    
+                    if (matches.length >= parseInt(limit)) {
+                        break;
+                    }
+                }
+            }
+        }
+        
+        return res.status(200).json({
+            results: matches,
+            count: matches.length,
+            query: query
+        });
+        
+    } catch (error) {
+        logger.log('ERROR', `[searchPopularInvestors] Error searching PIs`, error);
+        return res.status(500).json({ error: error.message });
+    }
+}
+
+module.exports = {
+    searchPopularInvestors
+};
+