bulltrackers-module 1.0.458 → 1.0.460

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

@@ -135,12 +135,34 @@ async function hasUserCopied(db, userCid, piCid, config) {
         const userDoc = await db.collection(signedInUsersCollection).doc(String(userCid)).get();
         if (userDoc.exists) {
             const data = userDoc.data();
+            
+            // Check AggregatedMirrors (current copies)
             if (data.AggregatedMirrors && Array.isArray(data.AggregatedMirrors)) {
                 const isCopying = data.AggregatedMirrors.some(m => Number(m.ParentCID) === piCidNum);
-                if (isCopying) return true;
+                if (isCopying) {
+                    console.log(`[hasUserCopied] Found PI ${piCidNum} in AggregatedMirrors for user ${userCid}`);
+                    return true;
+                }
+            }
+            
+            // Also check historical mirrors if available
+            if (data.snapshots && typeof data.snapshots === 'object') {
+                // Check recent snapshots for any copy history
+                const snapshotDates = Object.keys(data.snapshots).sort().reverse().slice(0, 30); // Last 30 days
+                for (const date of snapshotDates) {
+                    const snapshot = data.snapshots[date];
+                    if (snapshot && snapshot.AggregatedMirrors && Array.isArray(snapshot.AggregatedMirrors)) {
+                        const wasCopying = snapshot.AggregatedMirrors.some(m => Number(m.ParentCID) === piCidNum);
+                        if (wasCopying) {
+                            console.log(`[hasUserCopied] Found PI ${piCidNum} in historical snapshot ${date} for user ${userCid}`);
+                            return true;
+                        }
+                    }
+                }
             }
         }
 
+        console.log(`[hasUserCopied] User ${userCid} has not copied PI ${piCidNum} (checked computation and portfolio)`);
         return false;
     } catch (error) {
         console.error('[hasUserCopied] Error checking copy status:', error);
@@ -435,6 +457,8 @@ async function checkReviewEligibility(req, res, dependencies, config) {
         
         const canReview = await hasUserCopied(db, effectiveCid, piCid, config);
         
+        logger.log('INFO', `[checkReviewEligibility] User ${effectiveCid} eligibility for PI ${piCid}: ${canReview}`);
+        
         return res.status(200).json({
             piCid: Number(piCid),
             eligible: canReview,

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

@@ -233,6 +233,86 @@ async function getUserSyncStatus(req, res, dependencies, config) {
         if (!requestsSnapshot.empty) {
             const latestRequest = requestsSnapshot.docs[0].data();
             let status = latestRequest.status || 'queued';
+            const userType = latestRequest.userType || 'SIGNED_IN_USER'; // Default to signed-in user
+            
+            // If status is 'indexing' or 'computing', check if computation results are now available
+            if (status === 'indexing' || status === 'computing') {
+                const insightsCollection = config.unifiedInsightsCollection || 'unified_insights';
+                const resultsSub = config.resultsSubcollection || 'results';
+                const compsSub = config.computationsSubcollection || 'computations';
+                
+                // Determine category and computation name based on user type
+                let category, computationName;
+                if (userType === 'POPULAR_INVESTOR') {
+                    category = 'popular-investor';
+                    computationName = 'PopularInvestorProfileMetrics';
+                } else {
+                    category = 'signed_in_user';
+                    computationName = 'SignedInUserProfileMetrics';
+                }
+                
+                // Check today and yesterday for computation results
+                const checkDate = new Date();
+                for (let i = 0; i < 2; i++) {
+                    const dateStr = new Date(checkDate);
+                    dateStr.setDate(checkDate.getDate() - i);
+                    const dateStrFormatted = dateStr.toISOString().split('T')[0];
+                    
+                    const docRef = db.collection(insightsCollection)
+                        .doc(dateStrFormatted)
+                        .collection(resultsSub)
+                        .doc(category)
+                        .collection(compsSub)
+                        .doc(computationName);
+                    
+                    const doc = await docRef.get();
+                    if (doc.exists) {
+                        const docData = doc.data();
+                        let mergedData = null;
+                        
+                        // Check if data is sharded
+                        if (docData._sharded === true && docData._shardCount) {
+                            // Data is stored in shards - read all shards and merge
+                            const shardsCol = docRef.collection('_shards');
+                            const shardsSnapshot = await shardsCol.get();
+                            
+                            if (!shardsSnapshot.empty) {
+                                mergedData = {};
+                                for (const shardDoc of shardsSnapshot.docs) {
+                                    const shardData = shardDoc.data();
+                                    Object.assign(mergedData, shardData);
+                                }
+                            }
+                        } else {
+                            // Data is in the main document (compressed or not)
+                            const { tryDecompress } = require('./data_helpers');
+                            mergedData = tryDecompress(docData);
+                            
+                            // Handle string decompression result
+                            if (typeof mergedData === 'string') {
+                                try {
+                                    mergedData = JSON.parse(mergedData);
+                                } catch (e) {
+                                    logger.log('WARN', `[getUserSyncStatus] Failed to parse decompressed string for date ${dateStrFormatted}:`, e.message);
+                                    mergedData = null;
+                                }
+                            }
+                        }
+                        
+                        if (mergedData && typeof mergedData === 'object' && mergedData[String(targetCidNum)]) {
+                            // Computation completed! Update status
+                            status = 'completed';
+                            await requestsSnapshot.docs[0].ref.update({
+                                status: 'completed',
+                                completedAt: FieldValue.serverTimestamp(),
+                                updatedAt: FieldValue.serverTimestamp()
+                            });
+                            logger.log('INFO', `[getUserSyncStatus] Computation completed for user ${targetCidNum} (${userType}). Found results in date ${dateStrFormatted}`);
+                            break;
+                        }
+                    }
+                }
+            }
             
             // Check if request is stale (stuck in processing state for too long)
             const STALE_THRESHOLD_MS = 5 * 60 * 1000; // 5 minutes
@@ -275,6 +355,17 @@ async function getUserSyncStatus(req, res, dependencies, config) {
                 }
             }
             
+            // Re-fetch request if we updated it to get the latest completedAt
+            let completedAt = latestRequest.completedAt?.toDate?.()?.toISOString() || null;
+            if (status === 'completed' && !completedAt) {
+                // If we just updated to completed, re-fetch to get the server timestamp
+                const updatedDoc = await requestsSnapshot.docs[0].ref.get();
+                if (updatedDoc.exists) {
+                    const updatedData = updatedDoc.data();
+                    completedAt = updatedData.completedAt?.toDate?.()?.toISOString() || null;
+                }
+            }
+            
             const response = {
                 success: true,
                 status,
@@ -282,7 +373,7 @@ async function getUserSyncStatus(req, res, dependencies, config) {
                 startedAt: latestRequest.startedAt?.toDate?.()?.toISOString() || null,
                 createdAt: latestRequest.createdAt?.toDate?.()?.toISOString() || null,
                 dispatchedAt: latestRequest.dispatchedAt?.toDate?.()?.toISOString() || null,
-                completedAt: latestRequest.completedAt?.toDate?.()?.toISOString() || null,
+                completedAt: completedAt,
                 estimatedCompletion: latestRequest.dispatchedAt 
                     ? new Date(new Date(latestRequest.dispatchedAt.toDate()).getTime() + 5 * 60 * 1000).toISOString() // 5 min estimate
                     : null

package/package.json

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