bulltrackers-module 1.0.559 → 1.0.561

package/functions/generic-api/user-api/helpers/metrics/personalized_metrics_helpers.js

@@ -98,18 +98,60 @@ async function getSignedInUserPIPersonalizedMetrics(req, res, dependencies, conf
     try {
         const devOverride = await getDevOverride(db, userCid, config, logger);
         
+        // Also read raw Firestore data to check pretendToBePI value directly (in case of normalization issues)
+        let rawPretendToBePI = null;
+        if (devOverride && devOverride.enabled) {
+            try {
+                const devOverridesCollection = config.devOverridesCollection || 'dev_overrides';
+                const overrideDoc = await db.collection(devOverridesCollection).doc(String(userCid)).get();
+                if (overrideDoc.exists) {
+                    const rawData = overrideDoc.data();
+                    rawPretendToBePI = rawData.pretendToBePI; // Get raw value (could be false, true, undefined, etc.)
+                }
+            } catch (err) {
+                logger.log('WARN', `[getSignedInUserPIPersonalizedMetrics] Error reading raw dev override: ${err.message}`);
+            }
+        }
+        
         // For PI-related checks, respect pretendToBePI flag
-        // If pretendToBePI is false, use actual userCid even if impersonateCid is set
+        // If pretendToBePI is false (either normalized or raw), use actual userCid even if impersonateCid is set
         let effectiveCid;
-        if (devOverride && devOverride.enabled && devOverride.pretendToBePI === false) {
-            // User explicitly doesn't want to pretend to be a PI, use actual CID
+        let shouldCheckPI = true;
+        
+        // Check if user explicitly doesn't want to pretend to be a PI
+        // Check both normalized value and raw value to be safe
+        const pretendToBePIValue = rawPretendToBePI !== undefined ? rawPretendToBePI : (devOverride ? devOverride.pretendToBePI : false);
+        const explicitlyNotPretending = pretendToBePIValue === false;
+        
+        if (devOverride && devOverride.enabled && explicitlyNotPretending) {
+            // User explicitly doesn't want to pretend to be a PI
+            // Use actual CID and don't check PI status (user doesn't want to be treated as PI)
             effectiveCid = Number(userCid);
+            shouldCheckPI = false; // Skip PI check since user doesn't want to pretend to be PI
+            
+            logger.log('INFO', `[getSignedInUserPIPersonalizedMetrics] DEV OVERRIDE: User ${userCid} has pretendToBePI=false (raw: ${rawPretendToBePI}, normalized: ${devOverride.pretendToBePI}), skipping PI check and returning 404`);
         } else {
             // Use normal effective CID logic (may use impersonateCid if set)
             effectiveCid = await getEffectiveCid(db, userCid, config, logger);
         }
         
-        const isImpersonating = devOverride && devOverride.enabled && devOverride.impersonateCid && effectiveCid !== Number(userCid);
+        // Calculate isImpersonating based on whether we're actually using impersonation
+        // If pretendToBePI is false, we're not impersonating for PI purposes
+        // Only consider it impersonating if pretendToBePI is not explicitly false AND effectiveCid differs from userCid
+        const isImpersonating = shouldCheckPI && 
+                                devOverride && devOverride.enabled && devOverride.impersonateCid && 
+                                !explicitlyNotPretending && effectiveCid !== Number(userCid);
+        
+        // If user explicitly doesn't want to pretend to be a PI, return 404 immediately
+        if (!shouldCheckPI) {
+            return res.status(404).json({
+                error: "Not a Popular Investor",
+                message: "This endpoint is only available for users who are Popular Investors",
+                effectiveCid: effectiveCid,
+                isImpersonating: false, // Not impersonating if pretendToBePI is false
+                actualCid: Number(userCid)
+            });
+        }
         
         // Check if user is a PI
         const rankEntry = await checkIfUserIsPI(db, effectiveCid, config, logger);
@@ -118,7 +160,8 @@ async function getSignedInUserPIPersonalizedMetrics(req, res, dependencies, conf
                 error: "Not a Popular Investor",
                 message: "This endpoint is only available for users who are Popular Investors",
                 effectiveCid: effectiveCid,
-                isImpersonating: isImpersonating || false
+                isImpersonating: isImpersonating || false,
+                actualCid: Number(userCid)
             });
         }
         
@@ -355,7 +398,8 @@ async function getSignedInUserPIPersonalizedMetrics(req, res, dependencies, conf
             isFallback: foundDate !== today,
             daysBackFromLatest: checkedDates.indexOf(foundDate),
             isImpersonating: isImpersonating || false,
-            actualCid: Number(userCid)
+            actualCid: Number(userCid),
+            pretendToBePI: devOverride && devOverride.enabled ? (devOverride.pretendToBePI || false) : false
         });
         
     } catch (error) {

package/functions/generic-api/user-api/helpers/verification/verification_helpers.js

@@ -170,14 +170,48 @@ async function finalizeVerification(req, res, dependencies, config) {
         // Send unified request to task engine that handles both portfolio/history AND social data
         const pubsubUtils = new PubSubUtils(dependencies);
         
+        // Generate a requestId for tracking and to ensure finalizeOnDemandRequest runs
+        // This is critical - without requestId, the root data indexer and computations won't be triggered
+        const requestId = `signup-${realCID}-${Date.now()}`;
+        const { signedInUsersCollection } = config;
+        
+        // Create request tracking document (similar to user sync requests)
+        try {
+            const requestRef = db.collection('user_sync_requests')
+                .doc(String(realCID))
+                .collection('requests')
+                .doc(requestId);
+            
+            await requestRef.set({
+                targetUserCid: realCID,
+                username: profileData.username,
+                status: 'pending',
+                source: 'user_signup',
+                requestedAt: FieldValue.serverTimestamp(),
+                createdAt: FieldValue.serverTimestamp(),
+                metadata: {
+                    isNewUser: true,
+                    verificationSource: 'otp_verification'
+                }
+            });
+            
+            logger.log('INFO', `[Verification] Created request tracking document for ${username} (${realCID}): ${requestId}`);
+        } catch (reqError) {
+            logger.log('WARN', `[Verification] Failed to create request tracking document: ${reqError.message}`);
+            // Continue anyway - the requestId is still set
+        }
+        
         // Create a unified on-demand request that includes both portfolio and social
         // The task engine will process both, update root data, then trigger computations
         const unifiedTask = {
             type: 'ON_DEMAND_USER_UPDATE', // Matches Task Engine handler
+            cid: realCID, // Top-level CID for handler
+            username: profileData.username, // Top-level username for handler
+            requestId: requestId, // CRITICAL: Required for finalizeOnDemandRequest to run
+            source: 'user_signup', // Mark as signup to ensure computations are triggered
             data: {
                 cid: realCID,
                 username: profileData.username,
-                source: 'user_signup', // Mark as signup to ensure computations are triggered
                 includeSocial: true, // Flag to include social data fetch
                 since: new Date(Date.now() - (7 * 24 * 60 * 60 * 1000)).toISOString() // Last 7 days for social
             },
@@ -185,22 +219,26 @@ async function finalizeVerification(req, res, dependencies, config) {
                 onDemand: true,
                 targetCid: realCID, // Optimization: only process this user
                 isNewUser: true, // Flag to add to daily update queue
-                requestedAt: new Date().toISOString()
+                requestedAt: new Date().toISOString(),
+                userType: 'SIGNED_IN_USER' // Explicitly set userType for computation selection
             }
         };
         
         // Only trigger if user is public (has portfolio data)
         if (!isOptOut) {
             await pubsubUtils.publish(taskEngineTopic, unifiedTask);
-            logger.log('INFO', `[Verification] Triggered unified data fetch (portfolio + social) for ${username} (${realCID}) via on-demand topic`);
+            logger.log('INFO', `[Verification] Triggered unified data fetch (portfolio + social) for ${username} (${realCID}) via on-demand topic with requestId: ${requestId}`);
         } else {
             // For private users, still fetch social data but no portfolio
             const socialOnlyTask = {
                 type: 'ON_DEMAND_USER_UPDATE',
+                cid: realCID,
+                username: profileData.username,
+                requestId: requestId, // CRITICAL: Required for finalizeOnDemandRequest to run
+                source: 'user_signup',
                 data: {
                     cid: realCID,
                     username: profileData.username,
-                    source: 'user_signup',
                     includeSocial: true,
                     portfolioOnly: false, // Skip portfolio for private users
                     since: new Date(Date.now() - (7 * 24 * 60 * 60 * 1000)).toISOString()
@@ -209,11 +247,12 @@ async function finalizeVerification(req, res, dependencies, config) {
                     onDemand: true,
                     targetCid: realCID,
                     isNewUser: true,
-                    requestedAt: new Date().toISOString()
+                    requestedAt: new Date().toISOString(),
+                    userType: 'SIGNED_IN_USER' // Explicitly set userType for computation selection
                 }
             };
             await pubsubUtils.publish(taskEngineTopic, socialOnlyTask);
-            logger.log('INFO', `[Verification] Triggered social-only fetch for private user ${username} (${realCID}) via on-demand topic`);
+            logger.log('INFO', `[Verification] Triggered social-only fetch for private user ${username} (${realCID}) via on-demand topic with requestId: ${requestId}`);
         }
 
         return res.status(200).json({ 

package/package.json

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