bulltrackers-module 1.0.594 → 1.0.596

package/functions/api-v2/helpers/data-fetchers/firestore.js

@@ -1517,7 +1517,7 @@ const finalizeVerification = async (db, pubsub, userId, username) => {
         isOptOut
     });
 
-    // 2. Create/Update User Doc in SignedInUsers
+    // 2. Create/Update User Doc in SignedInUsers (legacy location - for backward compatibility)
     // Note: We use the realCID as the document ID, matching the generic-api logic
     await db.collection(signedInUsersCollection).doc(String(realCID)).set({
         username: profileData.username,
@@ -1529,7 +1529,30 @@ const finalizeVerification = async (db, pubsub, userId, username) => {
         lastLogin: FieldValue.serverTimestamp()
     }, { merge: true });
 
-    // 3. Trigger Downstream Systems via Task Engine
+    // 3. Create/Update verification data in new format location: /SignedInUsers/{cid}/verification/data
+    const verificationDataRef = db.collection('SignedInUsers').doc(String(realCID)).collection('verification').doc('data');
+    const existingVerificationDoc = await verificationDataRef.get();
+    
+    let emails = [];
+    if (existingVerificationDoc.exists()) {
+        const existingData = existingVerificationDoc.data();
+        // Preserve existing email array if present
+        emails = Array.isArray(existingData.email) ? existingData.email : (existingData.email ? [existingData.email] : []);
+    }
+    // Note: Email will be added by frontend completeAccountSetup when Firebase Auth email is available
+    
+    await verificationDataRef.set({
+        etoroUsername: profileData.username,
+        etoroCID: realCID,
+        email: emails, // Array - will be populated by frontend
+        displayName: `${profileData.firstName || ''} ${profileData.lastName || ''}`.trim(),
+        photoURL: profileData.avatars?.find(a => a.type === 'Original')?.url || null,
+        verifiedAt: FieldValue.serverTimestamp(),
+        accountSetupComplete: false, // Will be set to true by frontend completeAccountSetup
+        createdAt: FieldValue.serverTimestamp(),
+    }, { merge: true });
+
+    // 4. Trigger Downstream Systems via Task Engine
     if (pubsub) {
         try {
             // Replicating the 'unifiedTask' payload from generic-api
@@ -1875,10 +1898,82 @@ const checkDataStatus = async (db, userId) => {
         const snap = await db.collection('SignedInUsers').doc(userId).collection(type).doc('latest').get();
         status[type] = {
             exists: snap.exists,
-            updatedAt: snap.exists ? snap.updateTime.toDate() : null
+            updatedAt: snap.exists ? snap.updateTime.toDate() : null,
+            // Frontend-compatible fields
+            available: snap.exists,
+            lastUpdated: snap.exists ? snap.updateTime.toDate().toISOString() : null
         };
     }
-    return status;
+    
+    // Find the latest computation date for profile metrics (7-day lookback)
+    const lookbackDays = 7;
+    const today = new Date();
+    let computationDate = null;
+    let fallbackWindowExhausted = false;
+    
+    // Determine which computation to check based on user type
+    let computationName = 'SignedInUserProfileMetrics';
+    try {
+        await fetchPopularInvestorMasterList(db, userId);
+        computationName = 'SignedInUserPIPersonalizedMetrics';
+    } catch (e) {
+        // User is not a PI, use default
+    }
+    
+    // Check for computation results in the last 7 days
+    for (let i = 0; i < lookbackDays; i++) {
+        const checkDate = new Date(today);
+        checkDate.setDate(checkDate.getDate() - i);
+        const dateStr = checkDate.toISOString().split('T')[0];
+        
+        try {
+            const pageRef = db.collection('unified_insights')
+                .doc(dateStr)
+                .collection('results')
+                .doc('popular-investor')
+                .collection('computations')
+                .doc(computationName)
+                .collection('pages')
+                .doc(String(userId));
+            
+            const pageSnap = await pageRef.get();
+            if (pageSnap.exists) {
+                computationDate = dateStr;
+                break;
+            }
+        } catch (error) {
+            // Continue checking other dates
+            console.error(`Error checking computation for ${dateStr}:`, error);
+        }
+    }
+    
+    // If no computation found in 7 days, mark fallback window as exhausted
+    if (!computationDate) {
+        fallbackWindowExhausted = true;
+    }
+    
+    // Return frontend-compatible format
+    return {
+        portfolio: {
+            ...status.portfolio,
+            available: status.portfolio?.exists || false,
+            lastUpdated: status.portfolio?.updatedAt ? status.portfolio.updatedAt.toISOString() : null
+        },
+        tradeHistory: {
+            ...status.tradeHistory,
+            available: status.tradeHistory?.exists || false,
+            lastUpdated: status.tradeHistory?.updatedAt ? status.tradeHistory.updatedAt.toISOString() : null
+        },
+        posts: {
+            ...status.posts,
+            available: status.posts?.exists || false,
+            lastUpdated: status.posts?.updatedAt ? status.posts.updatedAt.toISOString() : null
+        },
+        // Top-level fields for frontend
+        portfolioAvailable: status.portfolio?.exists || false,
+        computationDate: computationDate,
+        fallbackWindowExhausted: fallbackWindowExhausted
+    };
 };
 
 const sendTestAlert = async (db, userId, payload) => {

package/functions/api-v2/middleware/identity_middleware.js

@@ -1,18 +1,52 @@
 /**
  * Middleware to resolve the effective user ID, handling Developer Impersonation.
  * Sets req.targetUserId, req.isImpersonating, and req.actualUserId.
+ * 
+ * Public routes (that don't require authentication):
+ * - /watchlists/public
+ * - /popular-investors/trending
+ * - /popular-investors/categories
+ * - /popular-investors/master-list
+ * - /popular-investors/search
  */
 const { isDeveloper } = require('../helpers/data-fetchers/firestore.js'); // Using your provided helper
 
+// List of public routes that don't require userCid
+const PUBLIC_ROUTES = [
+    '/watchlists/public',
+    '/popular-investors/trending',
+    '/popular-investors/categories',
+    '/popular-investors/master-list',
+    '/popular-investors/search'
+];
+
+const isPublicRoute = (path, originalUrl) => {
+    // Check both the path and originalUrl to handle Express routing
+    const fullPath = originalUrl || path;
+    return PUBLIC_ROUTES.some(route => fullPath.includes(route));
+};
+
 const resolveUserIdentity = async (req, res, next) => {
     try {
+        // Check if this is a public route (check both path and originalUrl for Express routing)
+        const isPublic = isPublicRoute(req.path, req.originalUrl);
+        
         // 1. Identify the actual authenticated user (from Auth middleware or params)
         const actualUserId = req.query.userCid || req.body.userCid || req.headers['x-user-cid'];
         
-        if (!actualUserId) {
+        // For public routes, userCid is optional
+        if (!actualUserId && !isPublic) {
             return res.status(400).json({ error: "Missing user identification (userCid)" });
         }
 
+        // If no user ID provided and it's a public route, skip identity resolution
+        if (!actualUserId && isPublic) {
+            req.actualUserId = null;
+            req.targetUserId = null;
+            req.isImpersonating = false;
+            return next();
+        }
+
         // 2. Check for Impersonation Request (Headers or Query)
         const impersonateId = req.headers['x-impersonate-cid'] || req.query.impersonateCid;
 

package/package.json

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