bulltrackers-module 1.0.504 → 1.0.506

package/functions/generic-api/user-api/helpers/core/path_resolution_helpers.js

@@ -0,0 +1,486 @@
+/**
+ * @fileoverview Path Resolution with Migration Support
+ * Enhanced path resolution using collection registry with auto-migration
+ * Supports both new CID-based paths and legacy paths with automatic migration
+ */
+
+const { FieldValue } = require('@google-cloud/firestore');
+const { getCollectionPath, resolvePath, getCollectionMetadata } = require('../../../../../../config/collection_registry');
+
+/**
+ * Get eToro CID from Firebase UID
+ * @param {object} db - Firestore instance
+ * @param {string} firebaseUid - Firebase authentication UID
+ * @returns {Promise<number|null>} - eToro CID or null if not found
+ */
+async function getCidFromFirebaseUid(db, firebaseUid) {
+    try {
+        const userDoc = await db.collection('signedInUsers').doc(firebaseUid).get();
+        if (!userDoc.exists) return null;
+        const data = userDoc.data();
+        return data.etoroCID || data.cid || null;
+    } catch (error) {
+        console.error('[getCidFromFirebaseUid] Error fetching CID:', error);
+        return null;
+    }
+}
+
+/**
+ * Get new path from collection registry
+ * @param {string} category - Registry category (e.g., 'signedInUsers')
+ * @param {string} subcategory - Subcategory name (e.g., 'notifications')
+ * @param {object} params - Dynamic segment values (e.g., { cid: '123' })
+ * @returns {string} - Resolved path
+ */
+function getNewPath(category, subcategory, params = {}) {
+    try {
+        return getCollectionPath(category, subcategory, params);
+    } catch (error) {
+        console.error(`[getNewPath] Error resolving path for ${category}/${subcategory}:`, error.message);
+        throw error;
+    }
+}
+
+/**
+ * Get legacy path mapping for a collection type
+ * Maps new collection types to their legacy paths
+ * @param {string} dataType - Data type (e.g., 'notifications', 'alerts', 'watchlists')
+ * @param {string|number} userCid - User CID
+ * @param {object} config - Configuration object
+ * @returns {string|null} - Legacy path or null if no legacy path exists
+ */
+/**
+ * Get legacy path mapping for a collection type
+ * Maps new collection types to their legacy paths based on user requirements
+ * 
+ * This function first tries to get legacy paths from the collection registry,
+ * then falls back to the hardcoded legacyPathMap for backward compatibility.
+ * 
+ * @param {string} dataType - Data type (e.g., 'notifications', 'alerts', 'watchlists')
+ * @param {string|number} userCid - User CID (or piCid for PI-specific data)
+ * @param {object} config - Configuration object
+ * @param {object} params - Additional parameters (e.g., { firebaseUid, username, date, requestId, etc. })
+ * @param {string} category - Registry category (e.g., 'signedInUsers', 'popularInvestors') - optional
+ * @param {string} subcategory - Registry subcategory (e.g., 'notifications', 'alerts') - optional
+ * @returns {string|null} - Legacy path template or null if no legacy path exists
+ */
+function getLegacyPath(dataType, userCid, config = {}, params = {}, category = null, subcategory = null) {
+    // Try to get legacy paths from collection registry first
+    if (category && subcategory) {
+        try {
+            const metadata = getCollectionMetadata(category, subcategory);
+            if (metadata && metadata.legacyPaths && metadata.legacyPaths.length > 0) {
+                // Use first legacy path from registry (can be enhanced to try multiple)
+                let legacyPathTemplate = metadata.legacyPaths[0];
+                
+                // Resolve dynamic segments in the legacy path
+                const cid = String(userCid);
+                const resolvedParams = {
+                    cid: cid,
+                    userCid: cid,
+                    firebaseUid: params.firebaseUid || '',
+                    username: params.username || '',
+                    date: params.date || '{date}',
+                    requestId: params.requestId || '{requestId}',
+                    piCid: params.piCid || cid,
+                    reviewId: params.reviewId || `{piCid}_{userCid}`,
+                    postId: params.postId || '{postId}',
+                    viewId: params.viewId || `{piCid}_{viewerCid}_{timestamp}`,
+                    watchlistId: params.watchlistId || '{watchlistId}',
+                    version: params.version || '{version}',
+                    ...params // Allow params to override defaults
+                };
+                
+                // Resolve path template
+                legacyPathTemplate = resolvePath(legacyPathTemplate, resolvedParams);
+                
+                // Replace any remaining placeholders
+                for (const [key, value] of Object.entries(resolvedParams)) {
+                    legacyPathTemplate = legacyPathTemplate.replace(`{${key}}`, String(value));
+                }
+                
+                return legacyPathTemplate;
+            }
+        } catch (error) {
+            // Fall through to hardcoded map if registry lookup fails
+            console.warn(`[getLegacyPath] Could not get legacy path from registry for ${category}/${subcategory}:`, error.message);
+        }
+    }
+    
+    // Fallback to hardcoded legacy path map (for backward compatibility)
+    const cid = String(userCid);
+    const firebaseUid = params.firebaseUid || '';
+    const username = params.username || '';
+    const date = params.date || '{date}';
+    const requestId = params.requestId || '{requestId}';
+    const piCid = params.piCid || cid;
+    const reviewId = params.reviewId || `{piCid}_{userCid}`;
+    const postId = params.postId || '{postId}';
+    const viewId = params.viewId || `{piCid}_{viewerCid}_{timestamp}`;
+    const watchlistId = params.watchlistId || '{watchlistId}';
+    const version = params.version || '{version}';
+    
+    const legacyPathMap = {
+        // Signed-in user data (CID-based)
+        notifications: firebaseUid ? `user_notifications/${firebaseUid}/notifications` : `user_notifications/${cid}/notifications`,
+        notificationsCounters: firebaseUid ? `user_notifications/${firebaseUid}/counters` : `user_notifications/${cid}/counters`,
+        alerts: `user_alerts/${cid}/alerts`,
+        alertsCounters: `user_alerts/${cid}/counters`,
+        watchlists: `user_watchlists/${cid}/lists`,
+        subscriptions: `watchlist_subscriptions/${cid}/alerts`,
+        verification: config.verificationsCollection ? `${config.verificationsCollection}/${username}` : `user_verifications/${username}`,
+        syncRequests: `user_sync_requests/${cid}/requests`,
+        syncStatus: `user_sync_requests/${cid}/global/latest`,
+        portfolio: config.signedInUsersCollection ? `${config.signedInUsersCollection}/19M/snapshots/${date}/parts` : `signed_in_users/19M/snapshots/${date}/parts`,
+        tradeHistory: config.signedInHistoryCollection ? `${config.signedInHistoryCollection}/19M/snapshots/${date}/parts` : `signed_in_user_history/19M/snapshots/${date}/parts`,
+        socialPosts: `signed_in_users_social/${cid}/posts`,
+        
+        // Popular Investor data (PI CID-based)
+        piFetchRequests: `pi_fetch_requests/${piCid}/requests/${requestId}`,
+        piFetchStatus: `pi_fetch_requests/${piCid}/global/latest`,
+        piUserFetchRequests: `pi_fetch_requests/${piCid}/user_requests/${cid}`,
+        piReviews: `pi_reviews/${reviewId}`,
+        piSocialPosts: `pi_social_posts/${piCid}/posts/${postId}`,
+        piProfileViews: `profile_views/${piCid}_${date}`,
+        piIndividualViews: `profile_views/individual_views/views/${viewId}`,
+        
+        // Public/system data (no migration needed, but documented)
+        publicWatchlists: `public_watchlists/${watchlistId}/versions/${version}`,
+        userGcidMappings: `user_gcid_mappings/${cid}`,
+        
+        // Root data collections (no migration - these are date-based and stay as-is)
+        // These are populated by task engines and should remain in their current format
+        signedInUserPortfolioRoot: `SignedInUserPortfolioData/${date}/${cid}`,
+        signedInUserTradeHistoryRoot: `SignedInUserTradeHistoryData/${date}/${cid}`,
+        signedInUserSocialRoot: `SignedInUserSocialPostData/${date}/${cid}`,
+        popularInvestorPortfolioRoot: `PopularInvestorPortfolioData/${date}/${piCid}`,
+        popularInvestorTradeHistoryRoot: `PopularInvestorTradeHistoryData/${date}/${piCid}`,
+        popularInvestorSocialRoot: `PopularInvestorSocialPostData/${date}/${piCid}`,
+        piPortfoliosDeep: `pi_portfolios_deep/19M/snapshots/${date}/parts`,
+        piPortfoliosOverall: `pi_portfolios_overall/19M/snapshots/${date}/parts`
+    };
+    
+    return legacyPathMap[dataType] || null;
+}
+
+/**
+ * Read with migration - tries new path first, falls back to legacy, auto-migrates if found
+ * @param {object} db - Firestore instance
+ * @param {string} category - Registry category
+ * @param {string} subcategory - Subcategory name
+ * @param {object} params - Path parameters
+ * @param {object} options - Read options
+ * @param {boolean} options.isCollection - If true, reads as collection; if false, reads as document
+ * @param {string} options.dataType - Data type for legacy path lookup
+ * @param {object} options.config - Configuration object
+ * @param {object} options.logger - Logger instance
+ * @param {string} options.documentId - Document ID (for collections)
+ * @returns {Promise<object|null>} - Document data or snapshot, with migration info
+ */
+async function readWithMigration(db, category, subcategory, params, options = {}) {
+    const { 
+        isCollection = false, 
+        dataType = null, 
+        config = {}, 
+        logger = null,
+        documentId = null 
+    } = options;
+    
+    const userCid = params.cid || params.userCid;
+    
+    // Get new path from registry
+    let newPath;
+    try {
+        newPath = getNewPath(category, subcategory, params);
+    } catch (error) {
+        if (logger) logger.log('WARN', `[readWithMigration] Could not resolve new path for ${category}/${subcategory}: ${error.message}`);
+        newPath = null;
+    }
+    
+        // Try new path first
+    if (newPath) {
+        try {
+            if (isCollection) {
+                const collectionRef = db.collection(newPath);
+                const snapshot = await collectionRef.get();
+                if (!snapshot.empty) {
+                    if (logger) logger.log('INFO', `[readWithMigration] Found data in new path: ${newPath}`);
+                    return { snapshot, source: 'new', path: newPath };
+                }
+            } else {
+                const docRef = documentId 
+                    ? db.collection(newPath).doc(documentId)
+                    : db.doc(newPath);
+                const doc = await docRef.get();
+                if (doc.exists) {
+                    if (logger) logger.log('INFO', `[readWithMigration] Found data in new path: ${docRef.path}`);
+                    return { data: doc.data(), source: 'new', path: docRef.path };
+                }
+            }
+        } catch (newError) {
+            if (logger) logger.log('WARN', `[readWithMigration] Error reading from new path ${newPath}: ${newError.message}`);
+        }
+    }
+    
+    // Fallback to legacy path
+    if (dataType && userCid) {
+        const legacyPathTemplate = getLegacyPath(dataType, userCid, config, params);
+        if (legacyPathTemplate) {
+            try {
+                // Resolve legacy path (may have additional params like date, username)
+                // Replace placeholders in legacy path template
+                let legacyPath = legacyPathTemplate;
+                for (const [key, value] of Object.entries(params)) {
+                    legacyPath = legacyPath.replace(`{${key}}`, String(value));
+                }
+                // Also replace common placeholders
+                legacyPath = legacyPath.replace(/{date}/g, params.date || '{date}');
+                legacyPath = legacyPath.replace(/{requestId}/g, params.requestId || documentId || '{requestId}');
+                legacyPath = legacyPath.replace(/{username}/g, params.username || '{username}');
+                legacyPath = legacyPath.replace(/{piCid}/g, params.piCid || userCid);
+                legacyPath = legacyPath.replace(/{userCid}/g, String(userCid));
+                legacyPath = legacyPath.replace(/{cid}/g, String(userCid));
+                legacyPath = legacyPath.replace(/{viewerCid}/g, params.viewerCid || '{viewerCid}');
+                legacyPath = legacyPath.replace(/{timestamp}/g, params.timestamp || Date.now().toString());
+                legacyPath = legacyPath.replace(/{viewId}/g, params.viewId || documentId || '{viewId}');
+                legacyPath = legacyPath.replace(/{reviewId}/g, params.reviewId || documentId || `{piCid}_{userCid}`);
+                legacyPath = legacyPath.replace(/{postId}/g, params.postId || documentId || '{postId}');
+                legacyPath = legacyPath.replace(/{watchlistId}/g, params.watchlistId || '{watchlistId}');
+                legacyPath = legacyPath.replace(/{version}/g, params.version || '{version}');
+                
+                if (isCollection) {
+                    const legacyCollectionRef = db.collection(legacyPath);
+                    const legacySnapshot = await legacyCollectionRef.get();
+                    if (!legacySnapshot.empty) {
+                        if (logger) logger.log('INFO', `[readWithMigration] Found data in legacy path: ${legacyPath}, will migrate`);
+                        
+                        // Auto-migrate if new path is available
+                        if (newPath) {
+                            await migrateCollectionData(db, legacySnapshot, newPath, dataType, logger);
+                        }
+                        
+                        return { snapshot: legacySnapshot, source: 'legacy', path: legacyPath, migrated: !!newPath };
+                    }
+                } else {
+                    const legacyDocRef = documentId
+                        ? db.collection(legacyPath).doc(documentId)
+                        : db.doc(legacyPath);
+                    const legacyDoc = await legacyDocRef.get();
+                    if (legacyDoc.exists) {
+                        if (logger) logger.log('INFO', `[readWithMigration] Found data in legacy path: ${legacyDocRef.path}, will migrate`);
+                        
+                        // Auto-migrate if new path is available
+                        if (newPath) {
+                            await migrateDocumentData(db, legacyDoc, newPath, documentId, logger);
+                        }
+                        
+                        return { data: legacyDoc.data(), source: 'legacy', path: legacyDocRef.path, migrated: !!newPath };
+                    }
+                }
+            } catch (legacyError) {
+                if (logger) logger.log('WARN', `[readWithMigration] Error reading from legacy path: ${legacyError.message}`);
+            }
+        }
+    }
+    
+    return null;
+}
+
+/**
+ * Migrate document data from legacy to new path
+ * @param {object} db - Firestore instance
+ * @param {object} legacyDoc - Legacy document snapshot
+ * @param {string} newPath - New path (collection path, not full document path)
+ * @param {string} documentId - Document ID
+ * @param {object} logger - Logger instance
+ * @returns {Promise<void>}
+ */
+async function migrateDocumentData(db, legacyDoc, newPath, documentId, logger) {
+    try {
+        const data = legacyDoc.data();
+        const newDocRef = documentId 
+            ? db.collection(newPath).doc(documentId)
+            : db.doc(newPath);
+        
+        // Check if already migrated
+        const existingDoc = await newDocRef.get();
+        if (existingDoc.exists) {
+            if (logger) logger.log('INFO', `[migrateDocumentData] Data already exists in new path: ${newDocRef.path}`);
+            return;
+        }
+        
+        // Migrate data
+        await newDocRef.set({
+            ...data,
+            _migratedAt: FieldValue.serverTimestamp(),
+            _migratedFrom: legacyDoc.ref.path
+        });
+        
+        if (logger) logger.log('SUCCESS', `[migrateDocumentData] Migrated document from ${legacyDoc.ref.path} to ${newDocRef.path}`);
+    } catch (error) {
+        if (logger) logger.log('ERROR', `[migrateDocumentData] Migration failed: ${error.message}`);
+        // Don't throw - migration failures shouldn't break reads
+    }
+}
+
+/**
+ * Migrate collection data from legacy to new path
+ * @param {object} db - Firestore instance
+ * @param {object} legacySnapshot - Legacy collection snapshot
+ * @param {string} newPath - New collection path
+ * @param {string} dataType - Data type
+ * @param {object} logger - Logger instance
+ * @returns {Promise<void>}
+ */
+async function migrateCollectionData(db, legacySnapshot, newPath, dataType, logger) {
+    try {
+        const batch = db.batch();
+        let migratedCount = 0;
+        
+        for (const doc of legacySnapshot.docs) {
+            const newDocRef = db.collection(newPath).doc(doc.id);
+            
+            // Check if already migrated
+            const existingDoc = await newDocRef.get();
+            if (existingDoc.exists) {
+                continue; // Skip if already migrated
+            }
+            
+            // Add to batch
+            batch.set(newDocRef, {
+                ...doc.data(),
+                _migratedAt: FieldValue.serverTimestamp(),
+                _migratedFrom: doc.ref.path
+            });
+            migratedCount++;
+        }
+        
+        if (migratedCount > 0) {
+            await batch.commit();
+            if (logger) logger.log('SUCCESS', `[migrateCollectionData] Migrated ${migratedCount} documents from legacy to ${newPath}`);
+        }
+    } catch (error) {
+        if (logger) logger.log('ERROR', `[migrateCollectionData] Migration failed: ${error.message}`);
+        // Don't throw - migration failures shouldn't break reads
+    }
+}
+
+/**
+ * Write with dual write support (writes to both new and legacy during migration)
+ * @param {object} db - Firestore instance
+ * @param {string} category - Registry category
+ * @param {string} subcategory - Subcategory name
+ * @param {object} params - Path parameters
+ * @param {object} data - Data to write
+ * @param {object} options - Write options
+ * @param {boolean} options.isCollection - If true, writes as collection; if false, writes as document
+ * @param {boolean} options.merge - If true, merges data instead of overwriting
+ * @param {string} options.dataType - Data type for legacy path lookup
+ * @param {object} options.config - Configuration object
+ * @param {string} options.documentId - Document ID (required for collections)
+ * @param {boolean} options.dualWrite - If true, writes to both paths (default: true during migration)
+ * @returns {Promise<void>}
+ */
+async function writeWithMigration(db, category, subcategory, params, data, options = {}) {
+    const {
+        isCollection = false,
+        merge = false,
+        dataType = null,
+        config = {},
+        documentId = null,
+        dualWrite = true // Default to dual write during migration period
+    } = options;
+    
+    const userCid = params.cid || params.userCid;
+    
+    // Get new path
+    const newPath = getNewPath(category, subcategory, params);
+    
+    // Get legacy path if dual write is enabled
+    let legacyPath = null;
+    if (dualWrite && dataType && userCid) {
+        legacyPath = getLegacyPath(dataType, userCid, config);
+        if (legacyPath) {
+            legacyPath = resolvePath(legacyPath, params);
+        }
+    }
+    
+    const batch = db.batch();
+    
+    try {
+        // Write to new path
+        if (isCollection) {
+            if (!documentId) {
+                throw new Error('Collection writes require documentId');
+            }
+            const newRef = db.collection(newPath).doc(documentId);
+            if (merge) {
+                batch.set(newRef, data, { merge: true });
+            } else {
+                batch.set(newRef, data);
+            }
+        } else {
+            const newRef = documentId 
+                ? db.collection(newPath).doc(documentId)
+                : db.doc(newPath);
+            if (merge) {
+                batch.set(newRef, data, { merge: true });
+            } else {
+                batch.set(newRef, data);
+            }
+        }
+        
+        // Write to legacy path if dual write is enabled
+        if (legacyPath) {
+            if (isCollection) {
+                if (!documentId) {
+                    throw new Error('Collection writes require documentId');
+                }
+                const legacyRef = db.collection(legacyPath).doc(documentId);
+                if (merge) {
+                    batch.set(legacyRef, data, { merge: true });
+                } else {
+                    batch.set(legacyRef, data);
+                }
+            } else {
+                const legacyRef = documentId
+                    ? db.collection(legacyPath).doc(documentId)
+                    : db.doc(legacyPath);
+                if (merge) {
+                    batch.set(legacyRef, data, { merge: true });
+                } else {
+                    batch.set(legacyRef, data);
+                }
+            }
+        }
+        
+        await batch.commit();
+    } catch (error) {
+        console.error('[writeWithMigration] Error writing data:', error);
+        throw error;
+    }
+}
+
+/**
+ * Get collection path helper (for backward compatibility)
+ * @param {object} collectionRegistry - Collection registry (not used, kept for compatibility)
+ * @param {string} category - Registry category
+ * @param {string} subcategory - Subcategory name
+ * @param {object} params - Path parameters
+ * @returns {string} - Resolved path
+ */
+function getCollectionPathHelper(collectionRegistry, category, subcategory, params = {}) {
+    return getNewPath(category, subcategory, params);
+}
+
+module.exports = {
+    getCidFromFirebaseUid,
+    getNewPath,
+    getLegacyPath,
+    readWithMigration,
+    writeWithMigration,
+    migrateDocumentData,
+    migrateCollectionData,
+    getCollectionPath: getCollectionPathHelper // For backward compatibility
+};
+

package/functions/generic-api/user-api/helpers/core/user_status_helpers.js

@@ -0,0 +1,77 @@
+/**
+ * @fileoverview User Status Helpers
+ * Functions to check user status (PI, signed-in, etc.)
+ */
+
+const { findLatestRankingsDate } = require('./data_lookup_helpers');
+
+/**
+ * Check if a signed-in user is also a Popular Investor
+ * Returns ranking entry if found, null otherwise
+ * Checks dev overrides first for pretendToBePI flag
+ * @param {Firestore} db - Firestore instance
+ * @param {string|number} userCid - User CID
+ * @param {object} config - Configuration object
+ * @param {object} logger - Logger instance (optional)
+ * @returns {Promise<object|null>} - Ranking entry or null
+ */
+async function checkIfUserIsPI(db, userCid, config, logger = null) {
+    try {
+        // Check dev override first (for developer accounts)
+        const { getDevOverride } = require('../dev_helpers');
+        const devOverride = await getDevOverride(db, userCid, config, logger);
+        
+        if (devOverride && devOverride.enabled && devOverride.pretendToBePI) {
+            // Generate fake ranking entry for dev testing
+            const fakeRankEntry = {
+                CustomerId: Number(userCid),
+                UserName: 'Dev Test PI',
+                AUMValue: 500000 + Math.floor(Math.random() * 1000000), // Random AUM between 500k-1.5M
+                Copiers: 150 + Math.floor(Math.random() * 200), // Random copiers between 150-350
+                RiskScore: 3 + Math.floor(Math.random() * 3), // Random risk score 3-5
+                Gain: 25 + Math.floor(Math.random() * 50), // Random gain 25-75%
+                WinRatio: 50 + Math.floor(Math.random() * 20), // Random win ratio 50-70%
+                Trades: 500 + Math.floor(Math.random() * 1000) // Random trades 500-1500
+            };
+            
+            if (logger && logger.log) {
+                logger.log('INFO', `[checkIfUserIsPI] DEV OVERRIDE: User ${userCid} pretending to be PI with fake ranking data`);
+            } else {
+                console.log(`[checkIfUserIsPI] DEV OVERRIDE: User ${userCid} pretending to be PI with fake ranking data`);
+            }
+            
+            return fakeRankEntry;
+        }
+        
+        // Otherwise, check real rankings
+        const rankingsCollection = config.popularInvestorRankingsCollection || process.env.FIRESTORE_COLLECTION_PI_RANKINGS || 'popular_investor_rankings';
+        const rankingsDate = await findLatestRankingsDate(db, rankingsCollection, 30);
+        
+        if (!rankingsDate) {
+            return null;
+        }
+        
+        const rankingsRef = db.collection(rankingsCollection).doc(rankingsDate);
+        const rankingsDoc = await rankingsRef.get();
+        
+        if (!rankingsDoc.exists) {
+            return null;
+        }
+        
+        const rankingsData = rankingsDoc.data();
+        const rankingsItems = rankingsData.Items || [];
+        
+        // Find user in rankings
+        const userRankEntry = rankingsItems.find(item => String(item.CustomerId) === String(userCid));
+        
+        return userRankEntry || null;
+    } catch (error) {
+        console.error('[checkIfUserIsPI] Error checking if user is PI:', error);
+        return null;
+    }
+}
+
+module.exports = {
+    checkIfUserIsPI
+};
+