bulltrackers-module 1.0.561 → 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/package.json

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