bulltrackers-module 1.0.419 → 1.0.421

package/functions/generic-api/user-api/helpers/data_helpers.js

@@ -835,55 +835,70 @@ async function autoGenerateWatchlist(req, res, dependencies, config) {
     try {
         let copiedPIs = [];
         let dataSource = 'unknown';
+        let isDevOverride = false;
         const today = new Date().toISOString().split('T')[0];
         
-        // === PRIMARY: Try to fetch from computation (cheaper/faster) ===
-        const insightsCollection = config.unifiedInsightsCollection || 'unified_insights';
-        const category = 'signed_in_user';
-        const computationName = 'SignedInUserCopiedPIs';
-        
-        // Try to find latest computation date (with fallback)
-        const resultsSub = config.resultsSubcollection || 'results';
-        const compsSub = config.computationsSubcollection || 'computations';
-        const computationDate = await findLatestComputationDate(
-            db, 
-            insightsCollection,
-            resultsSub,
-            compsSub,
-            category, 
-            computationName, 
-            userCid, 
-            30
-        );
+        // === DEV OVERRIDE CHECK (for developer accounts) ===
+        const { getCopiedPIsWithDevOverride } = require('./dev_helpers');
+        const devResult = await getCopiedPIsWithDevOverride(db, userCid, config, logger);
+        if (devResult.isDevOverride) {
+            copiedPIs = devResult.copiedPIs;
+            dataSource = devResult.dataSource;
+            isDevOverride = true;
+            logger.log('INFO', `[autoGenerateWatchlist] Using DEV OVERRIDE for user ${userCid}, found ${copiedPIs.length} fake copied PIs`);
+        }
         
-        if (computationDate) {
-            const computationRef = db.collection(insightsCollection)
-                .doc(computationDate)
-                .collection('results')
-                .doc(category)
-                .collection('computations')
-                .doc(computationName);
+        // === PRIMARY: Try to fetch from computation (cheaper/faster) ===
+        // Only if dev override is not active
+        if (!isDevOverride) {
+            const insightsCollection = config.unifiedInsightsCollection || 'unified_insights';
+            const category = 'signed_in_user';
+            const computationName = 'SignedInUserCopiedPIs';
             
-            const computationDoc = await computationRef.get();
+            // Try to find latest computation date (with fallback)
+            const resultsSub = config.resultsSubcollection || 'results';
+            const compsSub = config.computationsSubcollection || 'computations';
+            const computationDate = await findLatestComputationDate(
+                db, 
+                insightsCollection,
+                resultsSub,
+                compsSub,
+                category, 
+                computationName, 
+                userCid, 
+                30
+            );
             
-            if (computationDoc.exists) {
-                const computationData = computationDoc.data();
-                const userResult = computationData[String(userCid)];
+            if (computationDate) {
+                const computationRef = db.collection(insightsCollection)
+                    .doc(computationDate)
+                    .collection('results')
+                    .doc(category)
+                    .collection('computations')
+                    .doc(computationName);
                 
-                if (userResult && userResult.current && userResult.current.length > 0) {
-                    // Convert computation result to our format
-                    copiedPIs = userResult.current.map(cid => ({
-                        cid: Number(cid),
-                        username: 'Unknown' // Username not in computation, will get from rankings
-                    }));
-                    dataSource = 'computation';
-                    logger.log('INFO', `[autoGenerateWatchlist] Using computation data (date: ${computationDate}) for user ${userCid}, found ${copiedPIs.length} copied PIs`);
+                const computationDoc = await computationRef.get();
+                
+                if (computationDoc.exists) {
+                    const computationData = computationDoc.data();
+                    const userResult = computationData[String(userCid)];
+                    
+                    if (userResult && userResult.current && userResult.current.length > 0) {
+                        // Convert computation result to our format
+                        copiedPIs = userResult.current.map(cid => ({
+                            cid: Number(cid),
+                            username: 'Unknown' // Username not in computation, will get from rankings
+                        }));
+                        dataSource = 'computation';
+                        logger.log('INFO', `[autoGenerateWatchlist] Using computation data (date: ${computationDate}) for user ${userCid}, found ${copiedPIs.length} copied PIs`);
+                    }
                 }
             }
         }
         
         // === FALLBACK: Read portfolio data directly if computation not available ===
-        if (copiedPIs.length === 0) {
+        // Only if dev override is not active and no computation data found
+        if (!isDevOverride && copiedPIs.length === 0) {
             logger.log('INFO', `[autoGenerateWatchlist] Computation not available, falling back to direct portfolio read for user ${userCid}`);
             
             const { signedInUsersCollection } = config;

package/functions/generic-api/user-api/helpers/dev_helpers.js

@@ -0,0 +1,260 @@
+/**
+ * @fileoverview Developer Mode Helpers
+ * Allows specific developer accounts to override copied PI data for testing
+ * SECURITY: Only works for whitelisted developer CIDs
+ */
+
+const { FieldValue } = require('@google-cloud/firestore');
+
+// Whitelist of developer account CIDs that can use dev mode
+const DEVELOPER_CIDS = [
+    29312236 // Aiden Hawkins - marau2021
+];
+
+/**
+ * Check if a user CID is a developer account
+ */
+function isDeveloperAccount(userCid) {
+    return DEVELOPER_CIDS.includes(Number(userCid));
+}
+
+/**
+ * Get developer override data for a user
+ * Auto-creates default document if it doesn't exist (for developer accounts only)
+ * Returns null if not a developer
+ */
+async function getDevOverride(db, userCid, config, logger = null) {
+    if (!isDeveloperAccount(userCid)) {
+        return null;
+    }
+
+    try {
+        const devOverridesCollection = config.devOverridesCollection || 'dev_overrides';
+        const overrideRef = db.collection(devOverridesCollection).doc(String(userCid));
+        const overrideDoc = await overrideRef.get();
+        
+        // Auto-create default document if it doesn't exist
+        if (!overrideDoc.exists) {
+            const defaultData = {
+                userCid: Number(userCid),
+                enabled: false,
+                fakeCopiedPIs: [],
+                createdAt: FieldValue.serverTimestamp(),
+                lastUpdated: FieldValue.serverTimestamp()
+            };
+            
+            await overrideRef.set(defaultData);
+            
+            const logMsg = `[getDevOverride] Auto-created default dev override document for developer account ${userCid}`;
+            if (logger && logger.log) {
+                logger.log('INFO', logMsg);
+            } else {
+                console.log(logMsg);
+            }
+            
+            // Return the default (disabled) override
+            return {
+                enabled: false,
+                fakeCopiedPIs: [],
+                lastUpdated: null,
+                wasAutoCreated: true
+            };
+        }
+        
+        const data = overrideDoc.data();
+        
+        // Return override data (even if disabled, so caller knows it exists)
+        return {
+            enabled: data.enabled === true,
+            fakeCopiedPIs: data.fakeCopiedPIs || [],
+            lastUpdated: data.lastUpdated,
+            wasAutoCreated: false
+        };
+    } catch (error) {
+        console.error('[getDevOverride] Error fetching/creating dev override:', error);
+        return null;
+    }
+}
+
+/**
+ * Get the list of copied PIs for a user, with dev override support
+ * Returns { copiedPIs: Array, isDevOverride: boolean, dataSource: string }
+ */
+async function getCopiedPIsWithDevOverride(db, userCid, config, logger) {
+    const userCidNum = Number(userCid);
+    
+    // Check for dev override first (this will auto-create default if needed)
+    const devOverride = await getDevOverride(db, userCid, config, logger);
+    
+    if (devOverride && devOverride.enabled && devOverride.fakeCopiedPIs.length > 0) {
+        if (logger && logger.log) {
+            logger.log('INFO', `[getCopiedPIsWithDevOverride] Using DEV OVERRIDE for user ${userCid}: ${devOverride.fakeCopiedPIs.length} fake copied PIs`);
+        } else {
+            console.log(`[getCopiedPIsWithDevOverride] Using DEV OVERRIDE for user ${userCid}: ${devOverride.fakeCopiedPIs.length} fake copied PIs`);
+        }
+        
+        return {
+            copiedPIs: devOverride.fakeCopiedPIs.map(cid => ({
+                cid: Number(cid),
+                username: 'Dev Override' // Will be resolved from rankings later
+            })),
+            isDevOverride: true,
+            dataSource: 'dev_override'
+        };
+    }
+    
+    // Otherwise, use normal logic (computation or portfolio)
+    // This will be handled by the calling function
+    return {
+        copiedPIs: [],
+        isDevOverride: false,
+        dataSource: 'normal'
+    };
+}
+
+/**
+ * Check if a user has copied a specific PI, with dev override support
+ */
+async function hasUserCopiedWithDevOverride(db, userCid, piCid, config, logger) {
+    const userCidNum = Number(userCid);
+    const piCidNum = Number(piCid);
+    
+    // Check for dev override first (this will auto-create default if needed)
+    const devOverride = await getDevOverride(db, userCid, config, logger);
+    
+    if (devOverride && devOverride.enabled) {
+        const hasCopied = devOverride.fakeCopiedPIs.includes(piCidNum);
+        if (hasCopied) {
+            if (logger && logger.log) {
+                logger.log('INFO', `[hasUserCopiedWithDevOverride] DEV OVERRIDE: User ${userCid} "copies" PI ${piCid}`);
+            } else {
+                console.log(`[hasUserCopiedWithDevOverride] DEV OVERRIDE: User ${userCid} "copies" PI ${piCid}`);
+            }
+            return true;
+        }
+        // If dev override is enabled but PI not in list, return false (don't check real data)
+        if (logger && logger.log) {
+            logger.log('INFO', `[hasUserCopiedWithDevOverride] DEV OVERRIDE: User ${userCid} does NOT "copy" PI ${piCid} (override enabled, PI not in fake list)`);
+        } else {
+            console.log(`[hasUserCopiedWithDevOverride] DEV OVERRIDE: User ${userCid} does NOT "copy" PI ${piCid} (override enabled, PI not in fake list)`);
+        }
+        return false;
+    }
+    
+    // Otherwise, use normal logic (will be handled by calling function)
+    return null; // null means "not a dev override, use normal logic"
+}
+
+/**
+ * Create or update dev override for a developer account
+ * SECURITY: Only works for whitelisted developer CIDs
+ */
+async function setDevOverride(req, res, dependencies, config) {
+    const { db, logger } = dependencies;
+    const { userCid, enabled, fakeCopiedPIs } = req.body;
+    
+    if (!userCid) {
+        return res.status(400).json({ error: "Missing userCid" });
+    }
+    
+    // SECURITY CHECK: Only allow whitelisted developer accounts
+    if (!isDeveloperAccount(userCid)) {
+        logger.log('WARN', `[setDevOverride] Unauthorized attempt to set dev override for user ${userCid}`);
+        return res.status(403).json({ 
+            error: "Forbidden",
+            message: "Developer mode is only available for authorized developer accounts"
+        });
+    }
+    
+    // Validate fakeCopiedPIs
+    if (enabled && (!Array.isArray(fakeCopiedPIs) || fakeCopiedPIs.length === 0)) {
+        return res.status(400).json({ 
+            error: "Invalid request",
+            message: "When enabled, fakeCopiedPIs must be a non-empty array"
+        });
+    }
+    
+    // Ensure all CIDs are numbers
+    const validatedPIs = enabled ? fakeCopiedPIs.map(cid => Number(cid)).filter(cid => !isNaN(cid) && cid > 0) : [];
+    
+    try {
+        const devOverridesCollection = config.devOverridesCollection || 'dev_overrides';
+        const overrideRef = db.collection(devOverridesCollection).doc(String(userCid));
+        
+        const overrideData = {
+            userCid: Number(userCid),
+            enabled: enabled === true,
+            fakeCopiedPIs: validatedPIs,
+            lastUpdated: FieldValue.serverTimestamp()
+        };
+        
+        await overrideRef.set(overrideData, { merge: true });
+        
+        logger.log('SUCCESS', `[setDevOverride] Updated dev override for user ${userCid}: enabled=${enabled}, ${validatedPIs.length} fake PIs`);
+        
+        return res.status(200).json({
+            success: true,
+            message: "Developer override updated",
+            override: overrideData
+        });
+        
+    } catch (error) {
+        logger.log('ERROR', `[setDevOverride] Error updating dev override:`, error);
+        return res.status(500).json({ error: error.message });
+    }
+}
+
+/**
+ * Get current dev override status for a developer account
+ */
+async function getDevOverrideStatus(req, res, dependencies, config) {
+    const { db, logger } = dependencies;
+    const { userCid } = req.query;
+    
+    if (!userCid) {
+        return res.status(400).json({ error: "Missing userCid" });
+    }
+    
+    // SECURITY CHECK: Only allow whitelisted developer accounts
+    if (!isDeveloperAccount(userCid)) {
+        return res.status(403).json({ 
+            error: "Forbidden",
+            message: "Developer mode is only available for authorized developer accounts"
+        });
+    }
+    
+    try {
+        // This will auto-create default document if it doesn't exist
+        const devOverride = await getDevOverride(db, userCid, config, logger);
+        
+        if (!devOverride) {
+            // Should not happen for developer accounts, but handle gracefully
+            return res.status(200).json({
+                enabled: false,
+                fakeCopiedPIs: [],
+                message: "No dev override configured"
+            });
+        }
+        
+        return res.status(200).json({
+            enabled: devOverride.enabled,
+            fakeCopiedPIs: devOverride.fakeCopiedPIs,
+            lastUpdated: devOverride.lastUpdated,
+            wasAutoCreated: devOverride.wasAutoCreated || false
+        });
+        
+    } catch (error) {
+        logger.log('ERROR', `[getDevOverrideStatus] Error fetching dev override:`, error);
+        return res.status(500).json({ error: error.message });
+    }
+}
+
+module.exports = {
+    isDeveloperAccount,
+    getDevOverride,
+    getCopiedPIsWithDevOverride,
+    hasUserCopiedWithDevOverride,
+    setDevOverride,
+    getDevOverrideStatus
+};
+

package/functions/generic-api/user-api/helpers/review_helpers.js

@@ -70,7 +70,7 @@ async function findLatestComputationDate(db, insightsCollection, resultsSub, com
 
 /**
  * Checks if a Signed-In User has ever copied a specific PI.
- * Uses SignedInUserCopiedPIs computation (primary) with fallback to direct portfolio check.
+ * Uses dev override (if enabled) > SignedInUserCopiedPIs computation > direct portfolio check.
  */
 async function hasUserCopied(db, userCid, piCid, config) {
     const { signedInUsersCollection } = config;
@@ -78,6 +78,15 @@ async function hasUserCopied(db, userCid, piCid, config) {
     const userCidNum = Number(userCid);
 
     try {
+        // === DEV OVERRIDE CHECK (for developer accounts) ===
+        const { hasUserCopiedWithDevOverride } = require('./dev_helpers');
+        const devResult = await hasUserCopiedWithDevOverride(db, userCid, piCid, config, console);
+        if (devResult !== null) {
+            // devResult is true/false (not null), meaning dev override is active
+            return devResult;
+        }
+        // devResult is null, meaning no dev override, continue with normal logic
+        
         // === PRIMARY: Try to fetch from SignedInUserCopiedPIs computation ===
         const insightsCollection = config.unifiedInsightsCollection || 'unified_insights';
         const category = 'signed_in_user';

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

@@ -8,6 +8,7 @@ const { getPiAnalytics, getUserRecommendations, getWatchlist, updateWatchlist, a
 const { initiateVerification, finalizeVerification } = require('./helpers/verification_helpers');
 const { getUserWatchlists, getWatchlist: getWatchlistById, createWatchlist, updateWatchlist: updateWatchlistById, deleteWatchlist, copyWatchlist, getPublicWatchlists } = require('./helpers/watchlist_helpers');
 const { subscribeToAlerts, updateSubscription, unsubscribeFromAlerts, getUserSubscriptions, subscribeToWatchlist } = require('./helpers/subscription_helpers');
+const { setDevOverride, getDevOverrideStatus } = require('./helpers/dev_helpers');
 
 module.exports = (dependencies, config) => {
     const router = express.Router();
@@ -67,5 +68,9 @@ module.exports = (dependencies, config) => {
     router.get('/me/watchlists/:id/trigger-counts', (req, res) => getWatchlistTriggerCounts(req, res, dependencies, config));
     router.get('/me/watchlists/:id/rankings-check', (req, res) => checkPisInRankings(req, res, dependencies, config));
     
+    // --- Developer Mode (only for whitelisted developer accounts) ---
+    router.post('/dev/override', (req, res) => setDevOverride(req, res, dependencies, config));
+    router.get('/dev/override', (req, res) => getDevOverrideStatus(req, res, dependencies, config));
+    
     return router;
 };

package/package.json

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