bulltrackers-module 1.0.592 → 1.0.593

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

@@ -0,0 +1,336 @@
+/**
+ * @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 developerg,
+ */
+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: [],
+                pretendToBePI: false,
+                impersonateCid: null, // CID to impersonate/view as
+                pretendSubscribedToAllAlerts: false, // Pretend to be subscribed to all alert types for all PIs
+                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: [],
+                pretendToBePI: false,
+                impersonateCid: null,
+                pretendSubscribedToAllAlerts: false,
+                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 || [],
+            pretendToBePI: data.pretendToBePI === true,
+            impersonateCid: data.impersonateCid ? Number(data.impersonateCid) : null,
+            pretendSubscribedToAllAlerts: data.pretendSubscribedToAllAlerts === true,
+            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, pretendToBePI, impersonateCid, pretendSubscribedToAllAlerts } = 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 (only required if enabled is true)
+    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"
+        });
+    }
+    
+    // Validate impersonateCid if provided
+    if (impersonateCid !== undefined && impersonateCid !== null) {
+        const parsedCid = Number(impersonateCid);
+        if (isNaN(parsedCid) || parsedCid <= 0) {
+            return res.status(400).json({ 
+                error: "Invalid request",
+                message: "impersonateCid must be a positive number, or null to disable impersonation"
+            });
+        }
+    }
+    
+    // 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));
+        
+        // Get existing override to preserve values not being updated
+        const existingDoc = await overrideRef.get();
+        const existingData = existingDoc.exists ? existingDoc.data() : {};
+        
+        const overrideData = {
+            userCid: Number(userCid),
+            enabled: enabled !== undefined ? (enabled === true) : (existingData.enabled || false),
+            fakeCopiedPIs: enabled !== undefined ? validatedPIs : (existingData.fakeCopiedPIs || []),
+            pretendToBePI: pretendToBePI !== undefined ? (pretendToBePI === true) : (existingData.pretendToBePI || false),
+            impersonateCid: impersonateCid !== undefined ? (impersonateCid ? Number(impersonateCid) : null) : (existingData.impersonateCid || null),
+            pretendSubscribedToAllAlerts: pretendSubscribedToAllAlerts !== undefined ? (pretendSubscribedToAllAlerts === true) : (existingData.pretendSubscribedToAllAlerts || false),
+            lastUpdated: FieldValue.serverTimestamp()
+        };
+        
+        await overrideRef.set(overrideData, { merge: true });
+        
+        const logParts = [
+            `enabled=${overrideData.enabled}`,
+            `pretendToBePI=${overrideData.pretendToBePI}`,
+            `impersonateCid=${overrideData.impersonateCid || 'null'}`,
+            `pretendSubscribedToAllAlerts=${overrideData.pretendSubscribedToAllAlerts}`,
+            `${validatedPIs.length} fake PIs`
+        ];
+        logger.log('SUCCESS', `[setDevOverride] Updated dev override for user ${userCid}: ${logParts.join(', ')}`);
+        
+        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,
+            pretendToBePI: devOverride.pretendToBePI || false,
+            impersonateCid: devOverride.impersonateCid || null,
+            pretendSubscribedToAllAlerts: devOverride.pretendSubscribedToAllAlerts || false,
+            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 });
+    }
+}
+
+/**
+ * Get the effective CID to use for a developer account
+ * Returns impersonateCid if set, otherwise returns the actual userCid
+ * Only works for developer accounts
+ * 
+ * Note: If pretendToBePI is false, impersonation will not be used for PI-related checks
+ * to prevent unintended impersonation when the user doesn't want to pretend to be a PI
+ */
+async function getEffectiveCid(db, userCid, config, logger = null) {
+    if (!isDeveloperAccount(userCid)) {
+        return Number(userCid); // Not a developer, return actual CID
+    }
+    
+    const devOverride = await getDevOverride(db, userCid, config, logger);
+    // Only use impersonation if dev override is enabled AND impersonateCid is set
+    // BUT: If pretendToBePI is explicitly false, don't use impersonation (user doesn't want to be treated as PI)
+    if (devOverride && devOverride.enabled && devOverride.impersonateCid) {
+        // Check if user explicitly doesn't want to pretend to be a PI
+        // If pretendToBePI is false, don't use impersonation (respects user intent)
+        if (devOverride.pretendToBePI === false) {
+            if (logger && logger.log) {
+                logger.log('INFO', `[getEffectiveCid] DEV OVERRIDE: User ${userCid} has impersonateCid set but pretendToBePI=false, using actual CID ${userCid} instead`);
+            } else {
+                console.log(`[getEffectiveCid] DEV OVERRIDE: User ${userCid} has impersonateCid set but pretendToBePI=false, using actual CID ${userCid} instead`);
+            }
+            return Number(userCid);
+        }
+        
+        if (logger && logger.log) {
+            logger.log('INFO', `[getEffectiveCid] DEV OVERRIDE: User ${userCid} impersonating CID ${devOverride.impersonateCid}`);
+        } else {
+            console.log(`[getEffectiveCid] DEV OVERRIDE: User ${userCid} impersonating CID ${devOverride.impersonateCid}`);
+        }
+        return Number(devOverride.impersonateCid);
+    }
+    
+    return Number(userCid);
+}
+
+module.exports = {
+    isDeveloperAccount,
+    getDevOverride,
+    getCopiedPIsWithDevOverride,
+    hasUserCopiedWithDevOverride,
+    setDevOverride,
+    getDevOverrideStatus,
+    getEffectiveCid
+};