bulltrackers-module 1.0.591 → 1.0.592

package/functions/generic-api/user-api/helpers/alerts/test_alert_helpers.js

@@ -1,212 +0,0 @@
-/**
- * @fileoverview Test Alert Helpers
- * Allows developers to send test alerts for testing the alert system
- */
-
-const { FieldValue } = require('@google-cloud/firestore');
-const { getAllAlertTypes, getAlertTypeByComputation } = require('../../../../alert-system/helpers/alert_type_registry');
-const { isDeveloperAccount, getDevOverride } = require('../dev/dev_helpers');
-const { getCidFromFirebaseUid } = require('../core/path_resolution_helpers');
-const { writeWithMigration } = require('../core/path_resolution_helpers');
-
-/**
- * POST /user/dev/test-alert
- * Send a test alert to users
- * 
- * Request body:
- * {
- *   userCid: number (required) - Developer account CID
- *   alertTypeId: string (optional) - Alert type ID, defaults to first available
- *   targetUsers: 'all' | 'dev' | number[] (optional) - Who to send to, defaults to 'dev'
- *   piCid: number (optional) - PI CID for the alert, defaults to 1
- *   piUsername: string (optional) - PI username, defaults to 'TestPI'
- *   metadata: object (optional) - Additional metadata for the alert
- * }
- */
-async function sendTestAlert(req, res, dependencies, config) {
-    const { db, logger, collectionRegistry } = dependencies;
-    const { userCid, alertTypeId, targetUsers = 'dev', piCid = 1, piUsername = 'TestPI', metadata = {} } = req.body;
-    
-    if (!userCid) {
-        return res.status(400).json({ error: "Missing userCid" });
-    }
-    
-    // SECURITY CHECK: Only allow developer accounts
-    if (!isDeveloperAccount(userCid)) {
-        logger.log('WARN', `[sendTestAlert] Unauthorized attempt by user ${userCid}`);
-        return res.status(403).json({ 
-            error: "Forbidden",
-            message: "Test alerts are only available for authorized developer accounts"
-        });
-    }
-    
-    try {
-        // Get alert type
-        let alertType;
-        if (alertTypeId) {
-            alertType = getAlertTypeByComputation(alertTypeId);
-            if (!alertType) {
-                const allTypes = getAllAlertTypes();
-                alertType = allTypes.find(t => t.id === alertTypeId);
-            }
-        }
-        
-        // Default to first available alert type if not specified
-        if (!alertType) {
-            const allTypes = getAllAlertTypes();
-            if (allTypes.length === 0) {
-                return res.status(400).json({ error: "No alert types available" });
-            }
-            alertType = allTypes[0];
-            logger.log('INFO', `[sendTestAlert] Using default alert type: ${alertType.id}`);
-        }
-        
-        // Determine target users (as eToro CIDs)
-        let targetCids = [];
-        
-        if (targetUsers === 'all') {
-            // Get all users from signedInUsers collection (who have etoroCID)
-            const signedInUsersSnapshot = await db.collection('signedInUsers')
-                .where('etoroCID', '!=', null)
-                .get();
-            
-            targetCids = signedInUsersSnapshot.docs
-                .map(doc => doc.data().etoroCID)
-                .filter(cid => cid != null);
-            logger.log('INFO', `[sendTestAlert] Sending to all ${targetCids.length} users`);
-        } else if (targetUsers === 'dev') {
-            // Get all developer accounts with dev override enabled
-            const devOverridesCollection = config.devOverridesCollection || 'dev_overrides';
-            const devOverridesSnapshot = await db.collection(devOverridesCollection).get();
-            
-            const devCids = [];
-            for (const doc of devOverridesSnapshot.docs) {
-                const data = doc.data();
-                if (data.enabled === true) {
-                    devCids.push(Number(doc.id));
-                }
-            }
-            
-            // Also include the requesting developer
-            if (!devCids.includes(Number(userCid))) {
-                devCids.push(Number(userCid));
-            }
-            
-            targetCids = devCids;
-            logger.log('INFO', `[sendTestAlert] Sending to ${targetCids.length} developer accounts`);
-        } else if (Array.isArray(targetUsers)) {
-            // Specific user CIDs
-            targetCids = targetUsers.map(cid => Number(cid)).filter(cid => !isNaN(cid) && cid > 0);
-            logger.log('INFO', `[sendTestAlert] Sending to ${targetCids.length} specific users`);
-        } else {
-            return res.status(400).json({ 
-                error: "Invalid targetUsers",
-                message: "targetUsers must be 'all', 'dev', or an array of user CIDs"
-            });
-        }
-        
-        if (targetCids.length === 0) {
-            return res.status(400).json({ 
-                error: "No target users",
-                message: "No users found matching the target criteria"
-            });
-        }
-        
-        // Generate alert message
-        const { generateAlertMessage } = require('../../../../alert-system/helpers/alert_type_registry');
-        const alertMessage = generateAlertMessage(alertType, piUsername, {
-            ...metadata,
-            isTest: true,
-            testSentBy: Number(userCid),
-            testSentAt: new Date().toISOString()
-        });
-        
-        // Create notifications for each target user (using eToro CIDs and collection registry)
-        const notificationPromises = [];
-        const today = new Date().toISOString().split('T')[0];
-        
-        for (const targetCid of targetCids) {
-            const notificationId = `test_alert_${Date.now()}_${targetCid}_${piCid}_${Math.random().toString(36).substring(2, 9)}`;
-            
-            const notificationData = {
-                id: notificationId,
-                type: 'testAlerts', // Use testAlerts type for test notifications
-                subType: 'alert',
-                title: `[TEST] ${alertType.name}`,
-                message: alertMessage,
-                read: false,
-                timestamp: FieldValue.serverTimestamp(),
-                createdAt: FieldValue.serverTimestamp(),
-                metadata: {
-                    piCid: Number(piCid),
-                    piUsername: piUsername,
-                    alertType: alertType.id,
-                    alertTypeName: alertType.name,
-                    computationName: alertType.computationName,
-                    computationDate: today,
-                    severity: alertType.severity,
-                    isTest: true,
-                    testSentBy: Number(userCid),
-                    testSentAt: new Date().toISOString(),
-                    notificationType: 'testAlerts',
-                    userCid: Number(targetCid),
-                    ...metadata
-                }
-            };
-            
-            // Use writeWithMigration to write to new path (with legacy fallback)
-            // notifications is a subcollection, so we need isCollection: true and documentId
-            const writePromise = writeWithMigration(
-                db,
-                'signedInUsers',
-                'notifications',
-                { cid: String(targetCid) },
-                notificationData,
-                {
-                    isCollection: true,
-                    merge: false,
-                    dataType: 'notifications',
-                    documentId: notificationId,
-                    dualWrite: false, // Disable dual write - we're fully migrated to new path
-                    config,
-                    collectionRegistry
-                }
-            ).catch(err => {
-                logger.log('ERROR', `[sendTestAlert] Failed to write notification for CID ${targetCid}: ${err.message}`, err);
-                throw err; // Re-throw so we know if writes are failing
-            });
-            
-            notificationPromises.push(writePromise);
-        }
-        
-        // Wait for all notifications to be written
-        await Promise.all(notificationPromises);
-        
-        const successCount = notificationPromises.length;
-        logger.log('SUCCESS', `[sendTestAlert] Created ${successCount} test notifications for alert type ${alertType.id}`);
-        
-        return res.status(200).json({
-            success: true,
-            message: `Test alert sent to ${targetCids.length} users`,
-            alertType: {
-                id: alertType.id,
-                name: alertType.name,
-                computationName: alertType.computationName
-            },
-            targetUsers: {
-                count: targetCids.length,
-                cids: targetCids
-            },
-            piCid: Number(piCid),
-            piUsername: piUsername,
-            notificationsCreated: successCount
-        });
-        
-    } catch (error) {
-        logger.log('ERROR', `[sendTestAlert] Error sending test alert:`, error);
-        return res.status(500).json({ error: error.message });
-    }
-}
-
-module.exports = { sendTestAlert };
-

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

@@ -1,193 +0,0 @@
-/**
- * @fileoverview Collection Path Helpers (Backward Compatibility)
- * Re-exports from core/path_resolution_helpers.js for backward compatibility
- * This file maintains the old API while using the new migration-enabled helpers
- */
-
-// Re-export from core helpers for backward compatibility
-const coreHelpers = require('./core/path_resolution_helpers');
-
-/**
- * Extract collection name from a full path
- * @param {string} path - Full Firestore path (e.g., 'signedInUsers/123/portfolio/latest')
- * @returns {string} - Collection name (e.g., 'signedInUsers')
- */
-function extractCollectionName(path) {
-    return path.split('/')[0];
-}
-
-/**
- * Dual read helper - tries new structure first, falls back to legacy
- * @deprecated Use readWithMigration from core/path_resolution_helpers instead
- * @param {object} db - Firestore instance
- * @param {string} newPath - New collection path
- * @param {string} legacyPath - Legacy collection path
- * @param {object} [options={}] - Options for reading
- * @param {boolean} [options.isCollection=false] - If true, reads as collection; if false, reads as document
- * @returns {Promise<object|null>} - Document data or null if not found
- */
-async function readWithFallback(db, newPath, legacyPath, options = {}) {
-    const { isCollection = false } = options;
-    
-    try {
-        // Try new structure first
-        if (isCollection) {
-            const newSnapshot = await db.collection(newPath).get();
-            if (!newSnapshot.empty) {
-                return { snapshot: newSnapshot, source: 'new' };
-            }
-        } else {
-            const newDoc = await db.doc(newPath).get();
-            if (newDoc.exists) {
-                return { data: newDoc.data(), source: 'new' };
-            }
-        }
-    } catch (newError) {
-        console.warn(`[readWithFallback] New path failed: ${newPath}`, newError.message);
-    }
-    
-    // Fallback to legacy
-    try {
-        if (isCollection) {
-            const legacySnapshot = await db.collection(legacyPath).get();
-            if (!legacySnapshot.empty) {
-                return { snapshot: legacySnapshot, source: 'legacy' };
-            }
-        } else {
-            const legacyDoc = await db.doc(legacyPath).get();
-            if (legacyDoc.exists) {
-                return { data: legacyDoc.data(), source: 'legacy' };
-            }
-        }
-    } catch (legacyError) {
-        console.warn(`[readWithFallback] Legacy path failed: ${legacyPath}`, legacyError.message);
-    }
-    
-    return null;
-}
-
-/**
- * Dual write helper - writes to both new and legacy locations during migration
- * @deprecated Use writeWithMigration from core/path_resolution_helpers instead
- * @param {object} db - Firestore instance
- * @param {string} newPath - New collection path
- * @param {string} legacyPath - Legacy collection path
- * @param {object} data - Data to write
- * @param {object} [options={}] - Write options
- * @param {boolean} [options.isCollection=false] - If true, writes as collection; if false, writes as document
- * @param {boolean} [options.merge=false] - If true, merges data instead of overwriting
- * @returns {Promise<void>}
- */
-async function writeDual(db, newPath, legacyPath, data, options = {}) {
-    const { isCollection = false, merge = false } = options;
-    const batch = db.batch();
-    
-    try {
-        if (isCollection) {
-            // For collections, we need the document ID
-            if (!data.id) {
-                throw new Error('Collection writes require document ID in data.id');
-            }
-            const newRef = db.collection(newPath).doc(data.id);
-            const legacyRef = db.collection(legacyPath).doc(data.id);
-            
-            const { id, ...dataWithoutId } = data;
-            if (merge) {
-                batch.set(newRef, dataWithoutId, { merge: true });
-                batch.set(legacyRef, dataWithoutId, { merge: true });
-            } else {
-                batch.set(newRef, dataWithoutId);
-                batch.set(legacyRef, dataWithoutId);
-            }
-        } else {
-            // For documents
-            const newRef = db.doc(newPath);
-            const legacyRef = db.doc(legacyPath);
-            
-            if (merge) {
-                batch.set(newRef, data, { merge: true });
-                batch.set(legacyRef, data, { merge: true });
-            } else {
-                batch.set(newRef, data);
-                batch.set(legacyRef, data);
-            }
-        }
-        
-        await batch.commit();
-    } catch (error) {
-        console.error('[writeDual] Error writing to both locations:', error);
-        throw error;
-    }
-}
-
-/**
- * Get user-centric portfolio path (latest snapshot)
- * @param {object} collectionRegistry - Collection registry
- * @param {string|number} cid - User CID
- * @returns {string} - Path to latest portfolio snapshot
- */
-function getUserPortfolioPath(collectionRegistry, cid) {
-    return coreHelpers.getCollectionPath(collectionRegistry, 'signedInUsers', 'portfolio', { cid: String(cid) });
-}
-
-/**
- * Get user-centric trade history path (latest snapshot)
- * @param {object} collectionRegistry - Collection registry
- * @param {string|number} cid - User CID
- * @returns {string} - Path to latest trade history snapshot
- */
-function getUserTradeHistoryPath(collectionRegistry, cid) {
-    return coreHelpers.getCollectionPath(collectionRegistry, 'signedInUsers', 'tradeHistory', { cid: String(cid) });
-}
-
-/**
- * Get user-centric social posts path
- * @param {object} collectionRegistry - Collection registry
- * @param {string|number} cid - User CID
- * @returns {string} - Path to social posts collection
- */
-function getUserSocialPostsPath(collectionRegistry, cid) {
-    return coreHelpers.getCollectionPath(collectionRegistry, 'signedInUsers', 'socialPosts', { cid: String(cid) });
-}
-
-/**
- * Get root data portfolio path (date-based)
- * @param {object} collectionRegistry - Collection registry
- * @param {string} date - Date string (YYYY-MM-DD)
- * @param {string|number} cid - User CID
- * @returns {string} - Path to date-based portfolio data
- */
-function getRootDataPortfolioPath(collectionRegistry, date, cid) {
-    return coreHelpers.getCollectionPath(collectionRegistry, 'rootData', 'signedInUserPortfolio', { date, cid: String(cid) });
-}
-
-/**
- * Get root data trade history path (date-based)
- * @param {object} collectionRegistry - Collection registry
- * @param {string} date - Date string (YYYY-MM-DD)
- * @param {string|number} cid - User CID
- * @returns {string} - Path to date-based trade history data
- */
-function getRootDataTradeHistoryPath(collectionRegistry, date, cid) {
-    return coreHelpers.getCollectionPath(collectionRegistry, 'rootData', 'signedInUserTradeHistory', { date, cid: String(cid) });
-}
-
-// Re-export core helpers
-module.exports = {
-    getCidFromFirebaseUid: coreHelpers.getCidFromFirebaseUid,
-    getCollectionPath: coreHelpers.getCollectionPath,
-    extractCollectionName,
-    readWithFallback,
-    writeDual,
-    getUserPortfolioPath,
-    getUserTradeHistoryPath,
-    getUserSocialPostsPath,
-    getRootDataPortfolioPath,
-    getRootDataTradeHistoryPath,
-    // Also export new migration helpers
-    readWithMigration: coreHelpers.readWithMigration,
-    writeWithMigration: coreHelpers.writeWithMigration,
-    getNewPath: coreHelpers.getNewPath,
-    getLegacyPath: coreHelpers.getLegacyPath
-};
-

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

@@ -1,68 +0,0 @@
-/**
- * @fileoverview Compression/Decompression Utilities
- * Handles decompression of computation results stored as compressed byte strings
- */
-
-const zlib = require('zlib');
-
-/**
- * Decompress computation results if they are stored as compressed byte strings
- * @param {object} data - The raw Firestore document data
- * @returns {object} The decompressed JSON object or original data if not compressed
- */
-function tryDecompress(data) {
-    if (data && data._compressed === true && data.payload) {
-        try {
-            let buffer;
-            
-            // Handle different payload types from Firestore
-            if (Buffer.isBuffer(data.payload)) {
-                // Already a Buffer - use directly
-                buffer = data.payload;
-            } else if (typeof data.payload === 'string') {
-                // If it's a string, try base64 first, then direct
-                try {
-                    buffer = Buffer.from(data.payload, 'base64');
-                } catch (e) {
-                    // If not base64, might already be decompressed JSON string
-                    try {
-                        const parsed = JSON.parse(data.payload);
-                        // If parsing succeeds, return it (data was already decompressed)
-                        return parsed;
-                    } catch (e2) {
-                        // Not JSON either, try as raw buffer
-                        buffer = Buffer.from(data.payload);
-                    }
-                }
-            } else {
-                // Try to convert to Buffer
-                buffer = Buffer.from(data.payload);
-            }
-            
-            // Decompress the buffer
-            const decompressed = zlib.gunzipSync(buffer);
-            const jsonString = decompressed.toString('utf8');
-            
-            // Parse the JSON string
-            const parsed = JSON.parse(jsonString);
-            
-            // Verify it's an object, not a string
-            if (typeof parsed === 'string') {
-                // Might be double-encoded JSON string
-                return JSON.parse(parsed);
-            }
-            
-            return parsed;
-        } catch (e) {
-            console.error('[tryDecompress] Decompression failed:', e.message);
-            // Return empty object on failure to avoid crashing
-            return {};
-        }
-    }
-    return data;
-}
-
-module.exports = {
-    tryDecompress
-};
-