bulltrackers-module 1.0.560 → 1.0.562

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

@@ -628,6 +628,267 @@ const createAdminRouter = (config, dependencies, unifiedCalculations) => {
         }
     });
 
+    // --- 10. DEVELOPER USER MANAGEMENT (Force Sync & Lookup) ---
+    // Only accessible to developer accounts
+    
+    /**
+     * POST /admin/users/:cid/sync
+     * Force sync a signed-in user (developer only)
+     * Allows developers to trigger sync for any user to fix stuck accounts
+     */
+    router.post('/users/:cid/sync', async (req, res) => {
+        const { cid } = req.params;
+        const { userCid: developerCid } = req.query; // Developer's CID
+        
+        if (!developerCid) {
+            return res.status(400).json({ 
+                success: false,
+                error: "Missing userCid",
+                message: "Please provide userCid query parameter (your developer CID)"
+            });
+        }
+        
+        // SECURITY: Only allow developer accounts
+        const { isDeveloperAccount } = require('../user-api/helpers/dev/dev_helpers');
+        if (!isDeveloperAccount(Number(developerCid))) {
+            logger.log('WARN', `[AdminAPI] Unauthorized sync attempt by non-developer ${developerCid}`);
+            return res.status(403).json({ 
+                success: false,
+                error: "Forbidden",
+                message: "This endpoint is only available for developer accounts"
+            });
+        }
+        
+        const targetCidNum = Number(cid);
+        if (isNaN(targetCidNum) || targetCidNum <= 0) {
+            return res.status(400).json({
+                success: false,
+                error: "Invalid CID",
+                message: "Please provide a valid user CID"
+            });
+        }
+        
+        try {
+            // Import sync helper
+            const { requestUserSync } = require('../user-api/helpers/sync/user_sync_helpers');
+            
+            // Create a mock request object with the target CID
+            const mockReq = {
+                params: { userCid: String(targetCidNum) },
+                query: { userCid: String(developerCid), sourcePage: 'admin' },
+                headers: {},
+                body: {}
+            };
+            
+            // Call the sync function
+            await requestUserSync(mockReq, res, dependencies, config);
+            
+            logger.log('INFO', `[AdminAPI] Developer ${developerCid} force-synced user ${targetCidNum}`);
+            
+        } catch (error) {
+            logger.log('ERROR', `[AdminAPI] Error force-syncing user ${targetCidNum}`, error);
+            return res.status(500).json({
+                success: false,
+                error: "Internal server error",
+                message: error.message
+            });
+        }
+    });
+    
+    /**
+     * GET /admin/users/:cid/lookup
+     * Look up user information by CID (developer only)
+     * Helps developers find users to sync
+     */
+    router.get('/users/:cid/lookup', async (req, res) => {
+        const { cid } = req.params;
+        const { userCid: developerCid } = req.query; // Developer's CID
+        
+        if (!developerCid) {
+            return res.status(400).json({ 
+                success: false,
+                error: "Missing userCid",
+                message: "Please provide userCid query parameter (your developer CID)"
+            });
+        }
+        
+        // SECURITY: Only allow developer accounts
+        const { isDeveloperAccount } = require('../user-api/helpers/dev/dev_helpers');
+        if (!isDeveloperAccount(Number(developerCid))) {
+            logger.log('WARN', `[AdminAPI] Unauthorized lookup attempt by non-developer ${developerCid}`);
+            return res.status(403).json({ 
+                success: false,
+                error: "Forbidden",
+                message: "This endpoint is only available for developer accounts"
+            });
+        }
+        
+        const targetCidNum = Number(cid);
+        if (isNaN(targetCidNum) || targetCidNum <= 0) {
+            return res.status(400).json({
+                success: false,
+                error: "Invalid CID",
+                message: "Please provide a valid user CID"
+            });
+        }
+        
+        try {
+            const signedInUsersCollection = config.signedInUsersCollection || 'signed_in_users';
+            const { checkIfUserIsPI } = require('../user-api/helpers/core/user_status_helpers');
+            
+            // Check if user is a PI
+            const rankEntry = await checkIfUserIsPI(db, targetCidNum, config, logger);
+            const isPI = !!rankEntry;
+            
+            // Get signed-in user data
+            const userDoc = await db.collection(signedInUsersCollection).doc(String(targetCidNum)).get();
+            const userData = userDoc.exists ? userDoc.data() : null;
+            
+            // Get verification data
+            const verificationsCollection = config.verificationsCollection || 'verifications';
+            let verificationData = null;
+            if (userData && userData.username) {
+                const verificationDoc = await db.collection(verificationsCollection)
+                    .doc(userData.username.toLowerCase())
+                    .get();
+                if (verificationDoc.exists) {
+                    verificationData = verificationDoc.data();
+                }
+            }
+            
+            // Get latest sync request status
+            const syncRequestsRef = db.collection('user_sync_requests')
+                .doc(String(targetCidNum))
+                .collection('requests')
+                .orderBy('createdAt', 'desc')
+                .limit(1);
+            
+            const latestSyncSnapshot = await syncRequestsRef.get();
+            let latestSync = null;
+            if (!latestSyncSnapshot.empty) {
+                latestSync = {
+                    requestId: latestSyncSnapshot.docs[0].id,
+                    ...latestSyncSnapshot.docs[0].data()
+                };
+            }
+            
+            // Get data status directly (don't use the endpoint wrapper)
+            let dataStatus = null;
+            try {
+                const { signedInUsersCollection, signedInHistoryCollection } = config;
+                const { findLatestPortfolioDate } = require('../user-api/helpers/core/data_lookup_helpers');
+                const CANARY_BLOCK_ID = '19M';
+                const today = new Date().toISOString().split('T')[0];
+                
+                // Check portfolio
+                const portfolioDate = await findLatestPortfolioDate(db, signedInUsersCollection, targetCidNum, 30);
+                const portfolioExists = !!portfolioDate;
+                const isPortfolioFallback = portfolioDate && portfolioDate !== today;
+                
+                // Check history
+                let historyExists = false;
+                let historyDate = null;
+                let isHistoryFallback = false;
+                
+                const historyCollection = signedInHistoryCollection || 'signed_in_user_history';
+                const todayHistoryRef = db.collection(historyCollection)
+                    .doc(CANARY_BLOCK_ID)
+                    .collection('snapshots')
+                    .doc(today)
+                    .collection('parts');
+                
+                const todayHistorySnapshot = await todayHistoryRef.get();
+                
+                if (!todayHistorySnapshot.empty) {
+                    historyExists = true;
+                    historyDate = today;
+                } else {
+                    // Check fallback dates
+                    for (let i = 1; i <= 30; i++) {
+                        const checkDate = new Date(today);
+                        checkDate.setDate(checkDate.getDate() - i);
+                        const dateStr = checkDate.toISOString().split('T')[0];
+                        
+                        const historyRef = db.collection(historyCollection)
+                            .doc(CANARY_BLOCK_ID)
+                            .collection('snapshots')
+                            .doc(dateStr)
+                            .collection('parts');
+                        
+                        const snapshot = await historyRef.get();
+                        if (!snapshot.empty) {
+                            // Check if this user's data exists in any part
+                            for (const partDoc of snapshot.docs) {
+                                const partData = partDoc.data();
+                                if (partData.users && partData.users[String(targetCidNum)]) {
+                                    historyExists = true;
+                                    historyDate = dateStr;
+                                    isHistoryFallback = true;
+                                    break;
+                                }
+                            }
+                            if (historyExists) break;
+                        }
+                    }
+                }
+                
+                dataStatus = {
+                    portfolioAvailable: portfolioExists,
+                    historyAvailable: historyExists,
+                    date: portfolioDate || today,
+                    portfolioDate: portfolioDate,
+                    historyDate: historyDate,
+                    isPortfolioFallback: isPortfolioFallback,
+                    isHistoryFallback: isHistoryFallback,
+                    requestedDate: today,
+                    userCid: String(targetCidNum)
+                };
+            } catch (e) {
+                logger.log('WARN', `[AdminAPI] Error getting data status: ${e.message}`);
+            }
+            
+            const result = {
+                success: true,
+                cid: targetCidNum,
+                isPI: isPI,
+                userData: userData ? {
+                    username: userData.username,
+                    fullName: userData.fullName,
+                    avatar: userData.avatar,
+                    verifiedAt: userData.verifiedAt,
+                    lastLogin: userData.lastLogin,
+                    isOptOut: userData.isOptOut
+                } : null,
+                piData: rankEntry ? {
+                    username: rankEntry.UserName || rankEntry.username,
+                    aum: rankEntry.AUMValue,
+                    copiers: rankEntry.Copiers,
+                    riskScore: rankEntry.RiskScore,
+                    gain: rankEntry.Gain
+                } : null,
+                verification: verificationData ? {
+                    status: verificationData.status,
+                    verifiedAt: verificationData.verifiedAt,
+                    isOptOut: verificationData.isOptOut
+                } : null,
+                latestSync: latestSync,
+                dataStatus: dataStatus
+            };
+            
+            logger.log('INFO', `[AdminAPI] Developer ${developerCid} looked up user ${targetCidNum}`);
+            
+            return res.status(200).json(result);
+            
+        } catch (error) {
+            logger.log('ERROR', `[AdminAPI] Error looking up user ${targetCidNum}`, error);
+            return res.status(500).json({
+                success: false,
+                error: "Internal server error",
+                message: error.message
+            });
+        }
+    });
+
     return router;
 };
 

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.560",
+  "version": "1.0.562",
   "description": "Helper Functions for Bulltrackers.",
   "main": "index.js",
   "files": [