bulltrackers-module 1.0.561 → 1.0.563

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/core/data_lookup_helpers.js

@@ -6,6 +6,7 @@
 /**
  * Find the latest available date for signed-in user portfolio data
  * Searches backwards from today up to maxDaysBack days
+ * Checks both new root data path and legacy path for compatibility
  * @param {Firestore} db - Firestore instance
  * @param {string} signedInUsersCollection - Collection name (legacy)
  * @param {string|number} userCid - User CID
@@ -13,9 +14,51 @@
  * @returns {Promise<string|null>} - Date string (YYYY-MM-DD) or null if not found
  */
 async function findLatestPortfolioDate(db, signedInUsersCollection, userCid, maxDaysBack = 30) {
-    const CANARY_BLOCK_ID = '19M';
     const today = new Date();
+    const userCidStr = String(userCid);
+    
+    // First, check the user-centric latest snapshot (fastest check)
+    try {
+        const latestRef = db.collection('SignedInUsers')
+            .doc(userCidStr)
+            .collection('portfolio')
+            .doc('latest');
+        
+        const latestDoc = await latestRef.get();
+        if (latestDoc.exists) {
+            const data = latestDoc.data();
+            if (data && data.date) {
+                return data.date; // Found in latest snapshot
+            }
+        }
+    } catch (error) {
+        // Continue to other checks if this fails
+    }
+    
+    // Second, check the new root data path: SignedInUserPortfolioData/{date}/{cid}/{cid}
+    for (let i = 0; i < maxDaysBack; i++) {
+        const checkDate = new Date(today);
+        checkDate.setDate(checkDate.getDate() - i);
+        const dateStr = checkDate.toISOString().split('T')[0];
+        
+        try {
+            const rootDataRef = db.collection('SignedInUserPortfolioData')
+                .doc(dateStr)
+                .collection(userCidStr)
+                .doc(userCidStr);
+            
+            const rootDataDoc = await rootDataRef.get();
+            if (rootDataDoc.exists) {
+                return dateStr; // Found data in root data collection
+            }
+        } catch (error) {
+            // Continue to next date if error
+            continue;
+        }
+    }
     
+    // Third, check legacy path for backward compatibility: {signedInUsersCollection}/19M/snapshots/{date}/parts
+    const CANARY_BLOCK_ID = '19M';
     for (let i = 0; i < maxDaysBack; i++) {
         const checkDate = new Date(today);
         checkDate.setDate(checkDate.getDate() - i);
@@ -33,8 +76,8 @@ async function findLatestPortfolioDate(db, signedInUsersCollection, userCid, max
             // Check if user's CID exists in any part document
             for (const partDoc of partsSnapshot.docs) {
                 const partData = partDoc.data();
-                if (partData && partData[String(userCid)]) {
-                    return dateStr; // Found data for this date
+                if (partData && partData[userCidStr]) {
+                    return dateStr; // Found data for this date in legacy path
                 }
             }
         } catch (error) {

package/functions/generic-api/user-api/helpers/data/portfolio_helpers.js

@@ -147,64 +147,115 @@ async function getUserDataStatus(req, res, dependencies, config) {
         }
         
         // Check history data with fallback
+        // Check new root data path first: SignedInUsers/{cid}/tradeHistory/latest
         let historyExists = false;
         let historyDate = null;
         let isHistoryFallback = false;
         
-        const historyCollection = signedInHistoryCollection || 'signed_in_user_history';
-        
-        // Check today first
-        const todayHistoryRef = db.collection(historyCollection)
-            .doc(CANARY_BLOCK_ID)
-            .collection('snapshots')
-            .doc(today)
-            .collection('parts');
-        
-        const todayHistorySnapshot = await todayHistoryRef.get();
-        
-        if (!todayHistorySnapshot.empty) {
-            for (const partDoc of todayHistorySnapshot.docs) {
-                const partData = partDoc.data();
-                if (partData && partData[String(userCid)]) {
+        try {
+            const latestHistoryRef = db.collection('SignedInUsers')
+                .doc(String(userCid))
+                .collection('tradeHistory')
+                .doc('latest');
+            
+            const latestHistoryDoc = await latestHistoryRef.get();
+            if (latestHistoryDoc.exists) {
+                const data = latestHistoryDoc.data();
+                if (data && data.date) {
                     historyExists = true;
-                    historyDate = today;
-                    break;
+                    historyDate = data.date;
+                    isHistoryFallback = data.date !== today;
+                    logger.log('INFO', `[getUserDataStatus] Found history data in latest snapshot: ${historyDate}`);
                 }
             }
+        } catch (error) {
+            // Continue to other checks if this fails
         }
         
-        // If not found today, search backwards
+        // If not found in latest snapshot, check new root data path: SignedInUserTradeHistoryData/{date}/{cid}/{cid}
         if (!historyExists) {
-            for (let i = 1; i <= 30; i++) {
+            for (let i = 0; i <= 30; i++) {
                 const checkDate = new Date();
                 checkDate.setDate(checkDate.getDate() - i);
                 const dateStr = checkDate.toISOString().split('T')[0];
                 
                 try {
-                    const historyPartsRef = db.collection(historyCollection)
-                        .doc(CANARY_BLOCK_ID)
-                        .collection('snapshots')
+                    const rootHistoryRef = db.collection('SignedInUserTradeHistoryData')
                         .doc(dateStr)
-                        .collection('parts');
+                        .collection(String(userCid))
+                        .doc(String(userCid));
                     
-                    const historyPartsSnapshot = await historyPartsRef.get();
+                    const rootHistoryDoc = await rootHistoryRef.get();
+                    if (rootHistoryDoc.exists) {
+                        historyExists = true;
+                        historyDate = dateStr;
+                        isHistoryFallback = dateStr !== today;
+                        logger.log('INFO', `[getUserDataStatus] Found history data in root data collection: ${historyDate}`);
+                        break;
+                    }
+                } catch (error) {
+                    continue;
+                }
+            }
+        }
+        
+        // If still not found, check legacy path for backward compatibility
+        if (!historyExists) {
+            const historyCollection = signedInHistoryCollection || 'signed_in_user_history';
+            
+            // Check today first
+            const todayHistoryRef = db.collection(historyCollection)
+                .doc(CANARY_BLOCK_ID)
+                .collection('snapshots')
+                .doc(today)
+                .collection('parts');
+            
+            const todayHistorySnapshot = await todayHistoryRef.get();
+            
+            if (!todayHistorySnapshot.empty) {
+                for (const partDoc of todayHistorySnapshot.docs) {
+                    const partData = partDoc.data();
+                    if (partData && partData[String(userCid)]) {
+                        historyExists = true;
+                        historyDate = today;
+                        break;
+                    }
+                }
+            }
+            
+            // If not found today, search backwards
+            if (!historyExists) {
+                for (let i = 1; i <= 30; i++) {
+                    const checkDate = new Date();
+                    checkDate.setDate(checkDate.getDate() - i);
+                    const dateStr = checkDate.toISOString().split('T')[0];
                     
-                    if (!historyPartsSnapshot.empty) {
-                        for (const partDoc of historyPartsSnapshot.docs) {
-                            const partData = partDoc.data();
-                            if (partData && partData[String(userCid)]) {
-                                historyExists = true;
-                                historyDate = dateStr;
-                                isHistoryFallback = true;
-                                logger.log('INFO', `[getUserDataStatus] Found history data in fallback date ${dateStr}`);
-                                break;
+                    try {
+                        const historyPartsRef = db.collection(historyCollection)
+                            .doc(CANARY_BLOCK_ID)
+                            .collection('snapshots')
+                            .doc(dateStr)
+                            .collection('parts');
+                        
+                        const historyPartsSnapshot = await historyPartsRef.get();
+                        
+                        if (!historyPartsSnapshot.empty) {
+                            for (const partDoc of historyPartsSnapshot.docs) {
+                                const partData = partDoc.data();
+                                if (partData && partData[String(userCid)]) {
+                                    historyExists = true;
+                                    historyDate = dateStr;
+                                    isHistoryFallback = true;
+                                    logger.log('INFO', `[getUserDataStatus] Found history data in legacy fallback date ${dateStr}`);
+                                    break;
+                                }
                             }
                         }
+                        
+                        if (historyExists) break;
+                    } catch (error) {
+                        continue;
                     }
-                    
-                    if (historyExists) break;
-                } catch (error) {
-                    continue;
                 }
             }
         }

package/package.json

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