bulltrackers-module 1.0.418 → 1.0.419

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

@@ -1422,6 +1422,55 @@ async function checkPisInRankings(req, res, dependencies, config) {
  * Fetches Popular Investor profile data from computation
  * Falls back to latest available date if today's data doesn't exist
  */
+/**
+ * Helper function to fetch and check if a specific CID exists in a computation document for a given date
+ * Returns { found: boolean, profileData: object | null, computationData: object | null }
+ */
+async function checkPiInComputationDate(db, insightsCollection, resultsSub, compsSub, category, computationName, dateStr, cidStr, logger) {
+    try {
+        const computationRef = db.collection(insightsCollection)
+            .doc(dateStr)
+            .collection(resultsSub)
+            .doc(category)
+            .collection(compsSub)
+            .doc(computationName);
+        
+        const computationDoc = await computationRef.get();
+        
+        if (!computationDoc.exists) {
+            return { found: false, profileData: null, computationData: null };
+        }
+        
+        // Decompress if needed
+        const rawData = computationDoc.data();
+        let computationData = tryDecompress(rawData);
+        
+        // Handle string decompression result
+        if (typeof computationData === 'string') {
+            try {
+                computationData = JSON.parse(computationData);
+            } catch (e) {
+                logger.log('WARN', `[checkPiInComputationDate] Failed to parse decompressed string for date ${dateStr}:`, e.message);
+                return { found: false, profileData: null, computationData: null };
+            }
+        }
+        
+        // Check if CID exists in the computation data
+        if (computationData && typeof computationData === 'object' && !Array.isArray(computationData)) {
+            const profileData = computationData[cidStr];
+            if (profileData) {
+                return { found: true, profileData, computationData };
+            }
+        }
+        
+        return { found: false, profileData: null, computationData };
+        
+    } catch (error) {
+        logger.log('WARN', `[checkPiInComputationDate] Error checking date ${dateStr}:`, error.message);
+        return { found: false, profileData: null, computationData: null };
+    }
+}
+
 async function getPiProfile(req, res, dependencies, config) {
     const { db, logger } = dependencies;
     const { cid } = req.params;
@@ -1437,6 +1486,8 @@ async function getPiProfile(req, res, dependencies, config) {
         const computationName = 'PopularInvestorProfileMetrics';
         const category = 'popular-investor'; // Use hyphen to match Firestore path
         const today = new Date().toISOString().split('T')[0];
+        const cidStr = String(cid);
+        const maxDaysBackForPi = 7; // Maximum days to search back for a specific PI
         
         logger.log('INFO', `[getPiProfile] Starting search for PI CID: ${cid}`);
         
@@ -1462,114 +1513,89 @@ async function getPiProfile(req, res, dependencies, config) {
             });
         }
         
-        // Fetch computation result
-        const computationRef = db.collection(insightsCollection)
-            .doc(latestDate)
-            .collection(resultsSub)
-            .doc(category)
-            .collection(compsSub)
-            .doc(computationName);
-        
-        logger.log('INFO', `[getPiProfile] Fetching document at path: ${insightsCollection}/${latestDate}/${resultsSub}/${category}/${compsSub}/${computationName}`);
-        
-        const computationDoc = await computationRef.get();
-        
-        if (!computationDoc.exists) {
-            logger.log('WARN', `[getPiProfile] Document does not exist at expected path`);
-            return res.status(404).json({ 
-                error: "Profile data not found",
-                message: "Computation document does not exist"
-            });
-        }
-        
-        // Decompress if needed (handles byte string storage)
-        const rawData = computationDoc.data();
-        const wasCompressed = rawData && rawData._compressed === true;
-        logger.log('INFO', `[getPiProfile] Document exists. Was compressed: ${wasCompressed}, CID being searched: ${cid}`);
-        logger.log('INFO', `[getPiProfile] Raw data keys:`, rawData ? Object.keys(rawData).slice(0, 10) : 'NO DATA');
-        
-        if (wasCompressed && rawData.payload) {
-            logger.log('INFO', `[getPiProfile] Payload type: ${typeof rawData.payload}, isBuffer: ${Buffer.isBuffer(rawData.payload)}`);
-        }
+        // Try to find the PI starting from the latest date, then going back up to 7 days
+        let foundDate = null;
+        let profileData = null;
+        let checkedDates = [];
         
-        let computationData = tryDecompress(rawData);
+        // Parse the latest date to calculate earlier dates
+        const latestDateObj = new Date(latestDate + 'T00:00:00Z');
         
-        // Check if decompression returned a string (which would indicate a problem)
-        if (typeof computationData === 'string') {
-            logger.log('WARN', `[getPiProfile] Decompression returned a STRING instead of an object. Length: ${computationData.length}`);
-            logger.log('WARN', `[getPiProfile] First 500 chars of decompressed string:`, computationData.substring(0, 500));
-            // Try to parse it as JSON
-            try {
-                computationData = JSON.parse(computationData);
-                logger.log('INFO', `[getPiProfile] Successfully parsed string as JSON`);
-            } catch (e) {
-                logger.log('ERROR', `[getPiProfile] Failed to parse decompressed string as JSON:`, e.message);
-                return res.status(500).json({ 
-                    error: "Data parsing failed",
-                    message: "Failed to parse decompressed computation data"
-                });
+        for (let daysBack = 0; daysBack <= maxDaysBackForPi; daysBack++) {
+            const checkDate = new Date(latestDateObj);
+            checkDate.setUTCDate(latestDateObj.getUTCDate() - daysBack);
+            const dateStr = checkDate.toISOString().split('T')[0];
+            checkedDates.push(dateStr);
+            
+            logger.log('INFO', `[getPiProfile] Checking date ${dateStr} for CID ${cid} (${daysBack} days back from latest)`);
+            
+            const result = await checkPiInComputationDate(
+                db,
+                insightsCollection,
+                resultsSub,
+                compsSub,
+                category,
+                computationName,
+                dateStr,
+                cidStr,
+                logger
+            );
+            
+            if (result.found) {
+                foundDate = dateStr;
+                profileData = result.profileData;
+                logger.log('SUCCESS', `[getPiProfile] Found profile data for CID ${cid} in date ${dateStr} (${daysBack} days back from latest)`);
+                break;
+            } else {
+                logger.log('INFO', `[getPiProfile] CID ${cid} not found in date ${dateStr}`);
             }
         }
         
-        // Debug logging: Show full decompressed document structure
-        logger.log('INFO', `[getPiProfile] Decompressed data structure:`, {
-            hasData: !!computationData,
-            dataType: typeof computationData,
-            isArray: Array.isArray(computationData),
-            isString: typeof computationData === 'string',
-            keys: computationData && typeof computationData === 'object' && !Array.isArray(computationData) ? Object.keys(computationData).slice(0, 50) : 'N/A', // First 50 keys
-            totalKeys: computationData && typeof computationData === 'object' && !Array.isArray(computationData) ? Object.keys(computationData).length : 0,
-            searchingForCid: String(cid),
-            cidExists: computationData && typeof computationData === 'object' && !Array.isArray(computationData) ? computationData[String(cid)] !== undefined : false,
-            sampleCids: computationData && typeof computationData === 'object' && !Array.isArray(computationData) ? Object.keys(computationData).slice(0, 10) : []
-        });
-        
-        // Log full decompressed data (will be large but needed for debugging)
-        // Only stringify if it's an object, not a string
-        if (typeof computationData === 'object' && !Array.isArray(computationData)) {
-            logger.log('INFO', `[getPiProfile] FULL DECOMPRESSED DOCUMENT CONTENTS (first 2000 chars):`, JSON.stringify(computationData, null, 2).substring(0, 2000));
-        } else {
-            logger.log('INFO', `[getPiProfile] FULL DECOMPRESSED DOCUMENT CONTENTS (first 2000 chars):`, String(computationData).substring(0, 2000));
-        }
-        
-        const cidStr = String(cid);
-        const profileData = computationData && typeof computationData === 'object' && !Array.isArray(computationData) ? computationData[cidStr] : undefined;
-        
-        if (!profileData) {
-            // Get ALL available CIDs (not just a sample)
-            const allAvailableCids = computationData && typeof computationData === 'object' && !Array.isArray(computationData) ? Object.keys(computationData).sort() : [];
-            const totalCids = allAvailableCids.length;
-            const cidExists = allAvailableCids.includes(cidStr);
+        // If not found in any checked date, return 404
+        if (!foundDate || !profileData) {
+            logger.log('WARN', `[getPiProfile] CID ${cid} not found in any checked dates: ${checkedDates.join(', ')}`);
+            
+            // Try to get sample data from the latest date to show what CIDs are available
+            const latestResult = await checkPiInComputationDate(
+                db,
+                insightsCollection,
+                resultsSub,
+                compsSub,
+                category,
+                computationName,
+                latestDate,
+                cidStr,
+                logger
+            );
             
-            logger.log('WARN', `[getPiProfile] CID ${cid} (as string: "${cidStr}") NOT FOUND in computation data.`);
-            logger.log('WARN', `[getPiProfile] Total CIDs in document: ${totalCids}`);
-            logger.log('WARN', `[getPiProfile] ALL Available CIDs:`, allAvailableCids);
-            logger.log('WARN', `[getPiProfile] CID exists check: ${cidExists}`);
+            const allAvailableCids = latestResult.computationData && typeof latestResult.computationData === 'object' && !Array.isArray(latestResult.computationData)
+                ? Object.keys(latestResult.computationData).sort()
+                : [];
             
             return res.status(404).json({ 
                 error: "Profile data not found",
-                message: `Popular Investor ${cid} does not exist in computation results for ${latestDate}. This PI may not have been processed on this date.`,
+                message: `Popular Investor ${cid} does not exist in computation results for the last ${maxDaysBackForPi + 1} days. This PI may not have been processed recently.`,
                 debug: {
                     searchedCid: cidStr,
-                    wasCompressed: wasCompressed,
-                    totalCidsInDocument: totalCids,
-                    allAvailableCids: allAvailableCids,
-                    cidExists: cidExists,
-                    dataDate: latestDate,
-                    documentPath: `${insightsCollection}/${latestDate}/${resultsSub}/${category}/${compsSub}/${computationName}`
+                    checkedDates: checkedDates,
+                    totalCidsInLatestDocument: allAvailableCids.length,
+                    sampleAvailableCids: allAvailableCids.slice(0, 20), // First 20 for reference
+                    latestDate: latestDate
                 }
             });
         }
         
-        logger.log('SUCCESS', `[getPiProfile] Found profile data for CID ${cid} from date ${latestDate}`);
+        logger.log('SUCCESS', `[getPiProfile] Returning profile data for CID ${cid} from date ${foundDate} (requested: ${today}, latest available: ${latestDate})`);
         
         return res.status(200).json({
             status: 'success',
-            cid: String(cid),
+            cid: cidStr,
             data: profileData,
-            isFallback: latestDate !== today,
-            dataDate: latestDate,
-            requestedDate: today
+            isFallback: foundDate !== latestDate || foundDate !== today,
+            dataDate: foundDate,
+            latestComputationDate: latestDate,
+            requestedDate: today,
+            daysBackFromLatest: checkedDates.indexOf(foundDate)
         });
 
     } catch (error) {

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

@@ -4,38 +4,161 @@
  */
 
 const { FieldValue } = require('@google-cloud/firestore');
+const zlib = require('zlib');
+
+/**
+ * Helper to decompress computation results
+ */
+function tryDecompress(data) {
+    if (data && data._compressed === true && data.payload) {
+        try {
+            let buffer;
+            if (Buffer.isBuffer(data.payload)) {
+                buffer = data.payload;
+            } else if (typeof data.payload === 'string') {
+                try {
+                    buffer = Buffer.from(data.payload, 'base64');
+                } catch (e) {
+                    try {
+                        return JSON.parse(data.payload);
+                    } catch (e2) {
+                        buffer = Buffer.from(data.payload);
+                    }
+                }
+            } else {
+                buffer = Buffer.from(data.payload);
+            }
+            const decompressed = zlib.gunzipSync(buffer);
+            const jsonString = decompressed.toString('utf8');
+            const parsed = JSON.parse(jsonString);
+            if (typeof parsed === 'string') {
+                return JSON.parse(parsed);
+            }
+            return parsed;
+        } catch (e) {
+            console.error('[ReviewHelpers] Decompression failed:', e.message);
+            return {};
+        }
+    }
+    return data;
+}
+
+/**
+ * Finds the latest computation date for a given computation
+ */
+async function findLatestComputationDate(db, insightsCollection, resultsSub, compsSub, category, computationName, userCid, maxDays = 30) {
+    const today = new Date();
+    for (let i = 0; i < maxDays; i++) {
+        const checkDate = new Date(today);
+        checkDate.setDate(today.getDate() - i);
+        const dateStr = checkDate.toISOString().split('T')[0];
+        
+        const computationRef = db.collection(insightsCollection)
+            .doc(dateStr)
+            .collection(resultsSub)
+            .doc(category)
+            .collection(compsSub)
+            .doc(computationName);
+        
+        const doc = await computationRef.get();
+        if (doc.exists) {
+            return dateStr;
+        }
+    }
+    return null;
+}
 
 /**
  * Checks if a Signed-In User has ever copied a specific PI.
- * Checks both active portfolio (AggregatedMirrors) and Trade History.
+ * Uses SignedInUserCopiedPIs computation (primary) with fallback to direct portfolio check.
  */
 async function hasUserCopied(db, userCid, piCid, config) {
-    const { signedInUsersCollection, signedInHistoryCollection } = config;
-
-    // 1. Check Active Mirrors (Portfolio)
-    const userDoc = await db.collection(signedInUsersCollection).doc(String(userCid)).get();
-    if (userDoc.exists) {
-        const data = userDoc.data();
-        if (data.AggregatedMirrors && Array.isArray(data.AggregatedMirrors)) {
-            const isCopying = data.AggregatedMirrors.some(m => String(m.ParentCID) === String(piCid));
-            if (isCopying) return true;
+    const { signedInUsersCollection } = config;
+    const piCidNum = Number(piCid);
+    const userCidNum = Number(userCid);
+
+    try {
+        // === PRIMARY: Try to fetch from SignedInUserCopiedPIs computation ===
+        const insightsCollection = config.unifiedInsightsCollection || 'unified_insights';
+        const category = 'signed_in_user';
+        const computationName = 'SignedInUserCopiedPIs';
+        const resultsSub = config.resultsSubcollection || 'results';
+        const compsSub = config.computationsSubcollection || 'computations';
+        
+        const computationDate = await findLatestComputationDate(
+            db, 
+            insightsCollection,
+            resultsSub,
+            compsSub,
+            category, 
+            computationName, 
+            userCidNum, 
+            30
+        );
+        
+        if (computationDate) {
+            const computationRef = db.collection(insightsCollection)
+                .doc(computationDate)
+                .collection(resultsSub)
+                .doc(category)
+                .collection(compsSub)
+                .doc(computationName);
+            
+            const computationDoc = await computationRef.get();
+            
+            if (computationDoc.exists) {
+                const rawData = computationDoc.data();
+                const decompressed = tryDecompress(rawData);
+                
+                // Check if user's data exists in computation results
+                if (decompressed && decompressed[String(userCidNum)]) {
+                    const userData = decompressed[String(userCidNum)];
+                    // Check if PI is in current, past, or all arrays
+                    const allCopied = userData.all || [];
+                    if (allCopied.includes(piCidNum)) {
+                        return true;
+                    }
+                }
+            }
         }
-    }
 
-    // 2. Check Trade History (Past Copies)
-    // Assuming history is stored as subcollection or separate collection sharded by user
-    // We check the separate collection defined for signed-in history
-    const historySnapshot = await db.collection(signedInHistoryCollection) // e.g., 'signed_in_users_history'
-        .where('CID', '==', Number(userCid)) // Filter by User
-        .where('ParentCID', '==', Number(piCid)) // Filter by PI
-        .limit(1)
-        .get();
+        // === FALLBACK: Check Active Mirrors (Portfolio) directly ===
+        const userDoc = await db.collection(signedInUsersCollection).doc(String(userCid)).get();
+        if (userDoc.exists) {
+            const data = userDoc.data();
+            if (data.AggregatedMirrors && Array.isArray(data.AggregatedMirrors)) {
+                const isCopying = data.AggregatedMirrors.some(m => Number(m.ParentCID) === piCidNum);
+                if (isCopying) return true;
+            }
+        }
 
-    return !historySnapshot.empty;
+        return false;
+    } catch (error) {
+        console.error('[hasUserCopied] Error checking copy status:', error);
+        // Fallback to false on error
+        return false;
+    }
+}
+
+/**
+ * Gets username for a user CID
+ */
+async function getUsername(db, userCid, config) {
+    try {
+        const userDoc = await db.collection(config.signedInUsersCollection).doc(String(userCid)).get();
+        if (userDoc.exists) {
+            const data = userDoc.data();
+            return data.username || null;
+        }
+    } catch (error) {
+        console.error('[getUsername] Error fetching username:', error);
+    }
+    return null;
 }
 
 /**
  * POST /review
+ * Submit or update a review for a Popular Investor
  */
 async function submitReview(req, res, dependencies, config) {
     const { db, logger } = dependencies;
@@ -46,6 +169,12 @@ async function submitReview(req, res, dependencies, config) {
         return res.status(400).json({ error: "Missing required fields (userCid, piCid, rating)." });
     }
 
+    // Validate rating
+    const ratingNum = Number(rating);
+    if (isNaN(ratingNum) || ratingNum < 1 || ratingNum > 5) {
+        return res.status(400).json({ error: "Rating must be between 1 and 5." });
+    }
+
     try {
         // 1. Validate "Verified Copier" Status
         const canReview = await hasUserCopied(db, userCid, piCid, config);
@@ -57,20 +186,40 @@ async function submitReview(req, res, dependencies, config) {
             });
         }
 
-        // 2. Store Review
+        // 2. Get username if not anonymous
+        let reviewerUsername = null;
+        if (!isAnonymous) {
+            reviewerUsername = await getUsername(db, userCid, config);
+        }
+
+        // 3. Check if review already exists (for update)
         const reviewId = `${userCid}_${piCid}`;
-        await db.collection(reviewsCollection).doc(reviewId).set({
-            userCid,
-            piCid,
-            rating: Math.max(1, Math.min(5, Number(rating))), // Clamp 1-5
-            comment: comment || "",
+        const existingReview = await db.collection(reviewsCollection).doc(reviewId).get();
+        const isUpdate = existingReview.exists;
+
+        // 4. Store/Update Review
+        const reviewData = {
+            userCid: Number(userCid),
+            piCid: Number(piCid),
+            rating: Math.max(1, Math.min(5, ratingNum)),
+            comment: (comment || "").trim(),
             isAnonymous: !!isAnonymous,
-            createdAt: FieldValue.serverTimestamp(),
+            reviewerUsername: reviewerUsername,
             updatedAt: FieldValue.serverTimestamp()
-        });
+        };
+
+        if (!isUpdate) {
+            reviewData.createdAt = FieldValue.serverTimestamp();
+        }
 
-        logger.log('INFO', `[Review] User ${userCid} reviewed PI ${piCid}`);
-        return res.status(200).json({ success: true, message: "Review submitted." });
+        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({ 
+            success: true, 
+            message: isUpdate ? "Review updated." : "Review submitted.",
+            reviewId 
+        });
 
     } catch (error) {
         logger.log('ERROR', '[Review] Submit failed', error);
@@ -80,45 +229,150 @@ async function submitReview(req, res, dependencies, config) {
 
 /**
  * GET /reviews/{piCid}
+ * Get all reviews for a Popular Investor with stats
  */
 async function getReviews(req, res, dependencies, config) {
-    const { db } = dependencies;
+    const { db, logger } = dependencies;
     const { piCid } = req.params;
     const { reviewsCollection } = config;
+    const { userCid } = req.query; // Optional: to check if current user has reviewed
 
     try {
+        const piCidNum = Number(piCid);
+        
+        // Query reviews for this PI
         const snapshot = await db.collection(reviewsCollection)
-            .where('piCid', '==', piCid) // Or Number(piCid) depending on storage
+            .where('piCid', '==', piCidNum)
             .orderBy('createdAt', 'desc')
-            .limit(50)
+            .limit(100) // Increased limit
             .get();
 
         const reviews = [];
         let totalStars = 0;
+        const ratingDistribution = { 1: 0, 2: 0, 3: 0, 4: 0, 5: 0 };
+        let currentUserReview = null;
 
         snapshot.forEach(doc => {
             const data = doc.data();
-            totalStars += data.rating;
-            reviews.push({
-                rating: data.rating,
-                comment: data.comment,
-                date: data.createdAt ? data.createdAt.toDate() : null,
-                user: data.isAnonymous ? "Verified Copier" : `User ${data.userCid}` // We could look up username if needed
-            });
+            const rating = data.rating || 0;
+            totalStars += rating;
+            ratingDistribution[rating] = (ratingDistribution[rating] || 0) + 1;
+
+            const review = {
+                id: doc.id,
+                rating: rating,
+                comment: data.comment || "",
+                isAnonymous: data.isAnonymous || false,
+                reviewerUsername: data.isAnonymous ? null : (data.reviewerUsername || null),
+                userCid: data.userCid || null,
+                createdAt: data.createdAt ? (data.createdAt.toDate ? data.createdAt.toDate().toISOString() : data.createdAt) : null,
+                updatedAt: data.updatedAt ? (data.updatedAt.toDate ? data.updatedAt.toDate().toISOString() : data.updatedAt) : null
+            };
+
+            reviews.push(review);
+
+            // Check if this is the current user's review
+            if (userCid && Number(data.userCid) === Number(userCid)) {
+                currentUserReview = review;
+            }
         });
 
-        const avgRating = reviews.length > 0 ? (totalStars / reviews.length).toFixed(1) : 0;
+        const count = reviews.length;
+        const averageRating = count > 0 ? Number((totalStars / count).toFixed(2)) : 0;
+
+        // Calculate percentage distribution
+        const ratingPercentages = {};
+        for (let i = 1; i <= 5; i++) {
+            ratingPercentages[i] = count > 0 ? Number(((ratingDistribution[i] / count) * 100).toFixed(1)) : 0;
+        }
+
+        return res.status(200).json({
+            piCid: piCidNum,
+            count,
+            averageRating,
+            ratingDistribution: {
+                counts: ratingDistribution,
+                percentages: ratingPercentages
+            },
+            reviews,
+            currentUserReview // Include if userCid was provided
+        });
+
+    } catch (error) {
+        logger.log('ERROR', `[getReviews] Error fetching reviews for PI ${piCid}:`, error);
+        return res.status(500).json({ error: error.message });
+    }
+}
+
+/**
+ * GET /me/review/{piCid}
+ * Get current user's review for a specific PI (if exists)
+ */
+async function getUserReview(req, res, dependencies, config) {
+    const { db, logger } = dependencies;
+    const { piCid } = req.params;
+    const { userCid } = req.query;
+    const { reviewsCollection } = config;
 
+    if (!userCid) {
+        return res.status(400).json({ error: "Missing userCid" });
+    }
+
+    try {
+        const reviewId = `${userCid}_${piCid}`;
+        const reviewDoc = await db.collection(reviewsCollection).doc(reviewId).get();
+
+        if (!reviewDoc.exists) {
+            return res.status(200).json({ exists: false, review: null });
+        }
+
+        const data = reviewDoc.data();
+        const review = {
+            id: reviewDoc.id,
+            rating: data.rating,
+            comment: data.comment || "",
+            isAnonymous: data.isAnonymous || false,
+            reviewerUsername: data.reviewerUsername || null,
+            createdAt: data.createdAt ? (data.createdAt.toDate ? data.createdAt.toDate().toISOString() : data.createdAt) : null,
+            updatedAt: data.updatedAt ? (data.updatedAt.toDate ? data.updatedAt.toDate().toISOString() : data.updatedAt) : null
+        };
+
+        return res.status(200).json({ exists: true, review });
+
+    } catch (error) {
+        logger.log('ERROR', `[getUserReview] Error fetching user review:`, error);
+        return res.status(500).json({ error: error.message });
+    }
+}
+
+/**
+ * GET /me/review-eligibility/{piCid}
+ * Check if current user can review a PI
+ */
+async function checkReviewEligibility(req, res, dependencies, config) {
+    const { db, logger } = dependencies;
+    const { piCid } = req.params;
+    const { userCid } = req.query;
+
+    if (!userCid) {
+        return res.status(400).json({ error: "Missing userCid" });
+    }
+
+    try {
+        const canReview = await hasUserCopied(db, userCid, piCid, config);
+        
         return res.status(200).json({
-            piCid,
-            count: reviews.length,
-            averageRating: avgRating,
-            reviews
+            piCid: Number(piCid),
+            eligible: canReview,
+            message: canReview 
+                ? "You are eligible to review this Popular Investor." 
+                : "You must have copied this Popular Investor to submit a review."
         });
 
     } catch (error) {
+        logger.log('ERROR', `[checkReviewEligibility] Error checking eligibility:`, error);
         return res.status(500).json({ error: error.message });
     }
 }
 
-module.exports = { submitReview, getReviews };
+module.exports = { submitReview, getReviews, getUserReview, checkReviewEligibility };

package/functions/generic-api/user-api/index.js

@@ -3,7 +3,7 @@
  * Handles Reviews, Watchlists, User Analytics, and Verification.
  */
 const express = require('express');
-const { submitReview, getReviews } = require('./helpers/review_helpers');
+const { submitReview, getReviews, getUserReview, checkReviewEligibility } = require('./helpers/review_helpers');
 const { getPiAnalytics, getUserRecommendations, getWatchlist, updateWatchlist, autoGenerateWatchlist, getUserDataStatus, getUserPortfolio, getUserSocialPosts, getUserComputations, getUserVerification, getInstrumentMappings, searchPopularInvestors, requestPiAddition, getWatchlistTriggerCounts, checkPisInRankings, getPiProfile } = require('./helpers/data_helpers');
 const { initiateVerification, finalizeVerification } = require('./helpers/verification_helpers');
 const { getUserWatchlists, getWatchlist: getWatchlistById, createWatchlist, updateWatchlist: updateWatchlistById, deleteWatchlist, copyWatchlist, getPublicWatchlists } = require('./helpers/watchlist_helpers');
@@ -19,6 +19,8 @@ module.exports = (dependencies, config) => {
     // --- Reviews ---
     router.post('/review', (req, res) => submitReview(req, res, dependencies, config));
     router.get('/reviews/:piCid', (req, res) => getReviews(req, res, dependencies, config));
+    router.get('/me/review/:piCid', (req, res) => getUserReview(req, res, dependencies, config));
+    router.get('/me/review-eligibility/:piCid', (req, res) => checkReviewEligibility(req, res, dependencies, config));
 
     // --- Data Serving ---
     router.get('/pi/:cid/analytics', (req, res) => getPiAnalytics(req, res, dependencies, config));

package/package.json

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