bulltrackers-module 1.0.504 → 1.0.506

package/functions/generic-api/user-api/helpers/{review_helpers.js → reviews/review_helpers.js}

@@ -81,7 +81,7 @@ async function hasUserCopied(db, userCid, piCid, config) {
 
     try {
         // === DEV OVERRIDE CHECK (for developer accounts) ===
-        const { hasUserCopiedWithDevOverride } = require('./dev_helpers');
+        const { hasUserCopiedWithDevOverride } = require('../dev/dev_helpers');
         const devResult = await hasUserCopiedWithDevOverride(db, userCid, piCid, config, console);
         if (devResult !== null) {
             // devResult is true/false (not null), meaning dev override is active
@@ -143,7 +143,7 @@ async function hasUserCopied(db, userCid, piCid, config) {
                                         // If key exists, merge arrays or objects
                                         if (Array.isArray(mergedData[key]) && Array.isArray(value)) {
                                             mergedData[key] = [...mergedData[key], ...value];
-                                        } else if (typeof mergedData[key] === 'object' && typeof value === 'object' && mergedData[key] !== null && value !== null) {
+                                        } else if (typeof mergedData[key] === 'object' && typeof value === 'object') {
                                             mergedData[key] = { ...mergedData[key], ...value };
                                         } else {
                                             mergedData[key] = value;
@@ -156,7 +156,7 @@ async function hasUserCopied(db, userCid, piCid, config) {
                         }
                     } else {
                         // Data is in main document - decompress if needed
-                        const { tryDecompress } = require('./data_helpers');
+                        const { tryDecompress } = require('../data_helpers');
                         mergedData = tryDecompress(rawData);
                         
                         // Handle string decompression result
@@ -275,7 +275,7 @@ async function submitReview(req, res, dependencies, config) {
 
     try {
         // Check for dev override impersonation
-        const { getEffectiveCid, getDevOverride } = require('./dev_helpers');
+        const { getEffectiveCid, getDevOverride } = require('../dev/dev_helpers');
         const effectiveCid = await getEffectiveCid(db, userCid, config, logger);
         const devOverride = await getDevOverride(db, userCid, config, logger);
         const isImpersonating = devOverride && devOverride.enabled && devOverride.impersonateCid && effectiveCid !== Number(userCid);
@@ -289,7 +289,7 @@ async function submitReview(req, res, dependencies, config) {
         }
         
         // Check if the effective user is a Popular Investor
-        const { checkIfUserIsPI } = require('./data_helpers');
+        const { checkIfUserIsPI } = require('../data_helpers');
         const rankEntry = await checkIfUserIsPI(db, effectiveCid, config, logger);
         
         // Block Popular Investors from reviewing other Popular Investors
@@ -321,33 +321,8 @@ async function submitReview(req, res, dependencies, config) {
 
         // 3. Check if review already exists (for update) - use effective CID for review ID
         const reviewId = `${effectiveCid}_${piCid}`;
-        
-        const { getCollectionPath, writeDual, readWithFallback } = require('./collection_helpers');
-        const { collectionRegistry } = dependencies;
-        
-        // Check existing review in new or legacy structure
-        let existingReview = null;
-        let isUpdate = false;
-        
-        if (collectionRegistry) {
-            const newPath = getCollectionPath(collectionRegistry, 'popularInvestors', 'reviews', {
-                piCid: String(piCid)
-            }) + `/${reviewId}`;
-            
-            const legacyPath = `${reviewsCollection}/${reviewId}`;
-            
-            const result = await readWithFallback(db, newPath, legacyPath);
-            if (result && result.data) {
-                existingReview = { exists: true, data: () => result.data };
-                isUpdate = true;
-            }
-        }
-        
-        // Fallback to legacy check
-        if (!existingReview) {
-            existingReview = await db.collection(reviewsCollection).doc(reviewId).get();
-            isUpdate = existingReview.exists;
-        }
+        const existingReview = await db.collection(reviewsCollection).doc(reviewId).get();
+        const isUpdate = existingReview.exists;
 
         // 4. Store/Update Review (store effective CID, but track actual CID for audit)
         const reviewData = {
@@ -366,18 +341,7 @@ async function submitReview(req, res, dependencies, config) {
             reviewData.createdAt = FieldValue.serverTimestamp();
         }
 
-        // Write to both new and legacy structures
-        if (collectionRegistry) {
-            const newPath = getCollectionPath(collectionRegistry, 'popularInvestors', 'reviews', {
-                piCid: String(piCid)
-            }) + `/${reviewId}`;
-            
-            const legacyPath = `${reviewsCollection}/${reviewId}`;
-            
-            await writeDual(db, newPath, legacyPath, reviewData, { isCollection: false, merge: true });
-        } else {
-            await db.collection(reviewsCollection).doc(reviewId).set(reviewData, { merge: true });
-        }
+        await db.collection(reviewsCollection).doc(reviewId).set(reviewData, { merge: true });
 
         logger.log('INFO', `[Review] User ${userCid} ${isUpdate ? 'updated' : 'submitted'} review for PI ${piCid}`);
         return res.status(200).json({ 
@@ -404,39 +368,13 @@ async function getReviews(req, res, dependencies, config) {
 
     try {
         const piCidNum = Number(piCid);
-        const { getCollectionPath, extractCollectionName } = require('./collection_helpers');
-        const { collectionRegistry } = dependencies;
         
-        let snapshot = null;
-        
-        // Try new structure first
-        if (collectionRegistry) {
-            try {
-                const newPath = getCollectionPath(collectionRegistry, 'popularInvestors', 'reviews', {
-                    piCid: String(piCidNum)
-                });
-                const collectionName = extractCollectionName(newPath);
-                
-                const reviewsRef = db.collection(collectionName)
-                    .doc(String(piCidNum))
-                    .collection('reviews')
-                    .orderBy('createdAt', 'desc')
-                    .limit(100);
-                
-                snapshot = await reviewsRef.get();
-            } catch (newError) {
-                logger.log('WARN', `[getReviews] New structure failed, trying legacy: ${newError.message}`);
-            }
-        }
-        
-        // Fallback to legacy structure
-        if (!snapshot || snapshot.empty) {
-            snapshot = await db.collection(reviewsCollection)
-                .where('piCid', '==', piCidNum)
-                .orderBy('createdAt', 'desc')
-                .limit(100)
-                .get();
-        }
+        // Query reviews for this PI
+        const snapshot = await db.collection(reviewsCollection)
+            .where('piCid', '==', piCidNum)
+            .orderBy('createdAt', 'desc')
+            .limit(100) // Increased limit
+            .get();
 
         const reviews = [];
         let totalStars = 0;
@@ -510,38 +448,16 @@ async function getUserReview(req, res, dependencies, config) {
     }
 
     try {
-        const { getCollectionPath, readWithFallback } = require('./collection_helpers');
-        const { collectionRegistry } = dependencies;
         const reviewId = `${userCid}_${piCid}`;
-        
-        let reviewData = null;
-        
-        // Try new structure first
-        if (collectionRegistry) {
-            const newPath = getCollectionPath(collectionRegistry, 'popularInvestors', 'reviews', {
-                piCid: String(piCid)
-            }) + `/${reviewId}`;
-            
-            const legacyPath = `${reviewsCollection}/${reviewId}`;
-            
-            const result = await readWithFallback(db, newPath, legacyPath);
-            if (result && result.data) {
-                reviewData = result.data;
-            }
-        }
-        
-        // Fallback to legacy
-        if (!reviewData) {
-            const reviewDoc = await db.collection(reviewsCollection).doc(reviewId).get();
-            if (!reviewDoc.exists) {
-                return res.status(200).json({ exists: false, review: null });
-            }
-            reviewData = reviewDoc.data();
+        const reviewDoc = await db.collection(reviewsCollection).doc(reviewId).get();
+
+        if (!reviewDoc.exists) {
+            return res.status(200).json({ exists: false, review: null });
         }
-        
-        const data = reviewData;
+
+        const data = reviewDoc.data();
         const review = {
-            id: reviewId, // Use reviewId which is already defined
+            id: reviewDoc.id,
             rating: data.rating,
             comment: data.comment || "",
             isAnonymous: data.isAnonymous || false,
@@ -573,7 +489,7 @@ async function checkReviewEligibility(req, res, dependencies, config) {
 
     try {
         // Check for dev override impersonation
-        const { getEffectiveCid, getDevOverride } = require('./dev_helpers');
+        const { getEffectiveCid, getDevOverride } = require('../dev/dev_helpers');
         const effectiveCid = await getEffectiveCid(db, userCid, config, logger);
         const devOverride = await getDevOverride(db, userCid, config, logger);
         const isImpersonating = devOverride && devOverride.enabled && devOverride.impersonateCid && effectiveCid !== Number(userCid);
@@ -589,7 +505,7 @@ async function checkReviewEligibility(req, res, dependencies, config) {
         }
         
         // Check if the effective user is a Popular Investor
-        const { checkIfUserIsPI } = require('./data_helpers');
+        const { checkIfUserIsPI } = require('../data_helpers');
         const rankEntry = await checkIfUserIsPI(db, effectiveCid, config, logger);
         
         // Block Popular Investors from reviewing other Popular Investors

package/functions/generic-api/user-api/helpers/search/pi_request_helpers.js

@@ -0,0 +1,177 @@
+/**
+ * @fileoverview Popular Investor Request Helpers
+ * Handles PI addition requests and rankings checks
+ */
+
+const { FieldValue } = require('@google-cloud/firestore');
+const { findLatestRankingsDate } = require('../core/data_lookup_helpers');
+
+/**
+ * POST /user/requests/pi-addition
+ * Request to add a Popular Investor to the database
+ */
+async function requestPiAddition(req, res, dependencies, config) {
+    const { db, logger } = dependencies;
+    const { userCid, username, piUsername, piCid } = req.body;
+    
+    if (!userCid || !username || !piUsername) {
+        return res.status(400).json({ error: "Missing required fields: userCid, username, piUsername" });
+    }
+    
+    try {
+        const requestsCollection = config.requestsCollection || 'requests';
+        const requestId = `pi_add_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        
+        const requestData = {
+            id: requestId,
+            type: 'popular_investor_addition',
+            requestedBy: {
+                userCid: Number(userCid),
+                username: username
+            },
+            popularInvestor: {
+                username: piUsername,
+                cid: piCid || null
+            },
+            status: 'pending',
+            requestedAt: FieldValue.serverTimestamp(),
+            processedAt: null,
+            notes: null
+        };
+        
+        const requestRef = db.collection(requestsCollection)
+            .doc('popular_investor_copy_additions')
+            .collection('requests')
+            .doc(requestId);
+        
+        await requestRef.set(requestData);
+        
+        logger.log('SUCCESS', `[requestPiAddition] User ${userCid} requested addition of PI ${piUsername} (CID: ${piCid || 'unknown'})`);
+        
+        return res.status(201).json({
+            success: true,
+            requestId: requestId,
+            message: "Request submitted successfully"
+        });
+        
+    } catch (error) {
+        logger.log('ERROR', `[requestPiAddition] Error submitting request`, error);
+        return res.status(500).json({ error: error.message });
+    }
+}
+
+/**
+ * GET /user/me/watchlists/:id/rankings-check
+ * Check which PIs in a watchlist are in the latest available rankings
+ */
+async function checkPisInRankings(req, res, dependencies, config) {
+    const { db, logger } = dependencies;
+    const { userCid } = req.query;
+    const { id } = req.params;
+    
+    if (!userCid || !id) {
+        return res.status(400).json({ error: "Missing userCid or watchlist id" });
+    }
+    
+    try {
+        // Read watchlist from new path with migration
+        const { readWithMigration } = require('../core/path_resolution_helpers');
+        const watchlistResult = await readWithMigration(
+            db,
+            'signedInUsers',
+            'watchlists',
+            { cid: userCid },
+            {
+                isCollection: false,
+                dataType: 'watchlists',
+                config,
+                logger,
+                documentId: id
+            }
+        );
+        
+        let items = [];
+        if (watchlistResult && watchlistResult.data) {
+            items = watchlistResult.data.items || [];
+        } else {
+            // Fallback to legacy path
+            const watchlistsCollection = config.watchlistsCollection || 'watchlists';
+            const watchlistRef = db.collection(watchlistsCollection)
+                .doc(String(userCid))
+                .collection('lists')
+                .doc(id);
+            
+            const watchlistDoc = await watchlistRef.get();
+            
+            if (!watchlistDoc.exists) {
+                return res.status(404).json({ error: "Watchlist not found" });
+            }
+            
+            const watchlistData = watchlistDoc.data();
+            items = watchlistData.items || [];
+        }
+        
+        // Find latest available rankings date
+        const rankingsCollection = config.popularInvestorRankingsCollection || process.env.FIRESTORE_COLLECTION_PI_RANKINGS || 'popular_investor_rankings';
+        const rankingsDate = await findLatestRankingsDate(db, rankingsCollection, 30);
+        
+        if (!rankingsDate) {
+            const notInRankings = items.map(item => item.cid);
+            return res.status(200).json({
+                notInRankings,
+                rankingsDate: null,
+                message: "No rankings data available"
+            });
+        }
+        
+        // Fetch rankings data
+        const rankingsRef = db.collection(rankingsCollection).doc(rankingsDate);
+        const rankingsDoc = await rankingsRef.get();
+        
+        if (!rankingsDoc.exists) {
+            const notInRankings = items.map(item => item.cid);
+            return res.status(200).json({
+                notInRankings,
+                rankingsDate: null,
+                message: "Rankings document not found"
+            });
+        }
+        
+        const rankingsData = rankingsDoc.data();
+        const rankingsItems = rankingsData.Items || [];
+        
+        // Create a set of CIDs that exist in rankings
+        const rankingsCIDs = new Set();
+        for (const item of rankingsItems) {
+            if (item.CustomerId) {
+                rankingsCIDs.add(String(item.CustomerId));
+            }
+        }
+        
+        // Check which watchlist PIs are NOT in rankings
+        const notInRankings = [];
+        for (const item of items) {
+            const cidStr = String(item.cid);
+            if (!rankingsCIDs.has(cidStr)) {
+                notInRankings.push(item.cid);
+            }
+        }
+        
+        return res.status(200).json({
+            notInRankings,
+            rankingsDate: rankingsDate,
+            totalChecked: items.length,
+            inRankings: items.length - notInRankings.length
+        });
+        
+    } catch (error) {
+        logger.log('ERROR', `[checkPisInRankings] Error checking PIs in rankings`, error);
+        return res.status(500).json({ error: error.message });
+    }
+}
+
+module.exports = {
+    requestPiAddition,
+    checkPisInRankings
+};
+

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

@@ -0,0 +1,70 @@
+/**
+ * @fileoverview Popular Investor Search Helpers
+ * Handles PI search endpoints
+ */
+
+const { findLatestRankingsDate } = require('../core/data_lookup_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 {
+        const rankingsCollection = config.popularInvestorRankingsCollection || process.env.FIRESTORE_COLLECTION_PI_RANKINGS || 'popular_investor_rankings';
+        const rankingsDate = await findLatestRankingsDate(db, rankingsCollection, 30);
+        
+        if (!rankingsDate) {
+            return res.status(404).json({ error: "Rankings data not available" });
+        }
+        
+        const rankingsRef = db.collection(rankingsCollection).doc(rankingsDate);
+        const rankingsDoc = await rankingsRef.get();
+        
+        if (!rankingsDoc.exists) {
+            return res.status(404).json({ error: "Rankings data not available" });
+        }
+        
+        const rankingsData = rankingsDoc.data();
+        const rankingsItems = rankingsData.Items || [];
+        
+        // Search by username (case-insensitive, partial match)
+        const searchQuery = query.toLowerCase().trim();
+        const matches = rankingsItems
+            .filter(item => {
+                const username = (item.UserName || '').toLowerCase();
+                return username.includes(searchQuery);
+            })
+            .slice(0, parseInt(limit))
+            .map(item => ({
+                cid: item.CustomerId,
+                username: item.UserName,
+                aum: item.AUMValue,
+                riskScore: item.RiskScore,
+                gain: item.Gain,
+                copiers: item.Copiers
+            }));
+        
+        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
+};
+