bulltrackers-module 1.0.592 → 1.0.593

package/functions/old-generic-api/user-api/helpers/verification/verification_helpers.js

@@ -0,0 +1,323 @@
+/**
+ * @fileoverview Logic for User Verification (OTP Bio Check) and On-Demand Data Triggers.
+ */
+const { IntelligentProxyManager } = require('../../../../core/utils/intelligent_proxy_manager');
+const { IntelligentHeaderManager } = require('../../../../core/utils/intelligent_header_manager');
+const { PubSubUtils } = require('../../../../core/utils/pubsub_utils');
+const { FieldValue } = require('@google-cloud/firestore');
+
+/**
+ * 1. Initiate Verification
+ * Generates an OTP and returns it to the user to place in their bio.
+ */
+async function initiateVerification(req, res, dependencies, config) {
+    const { db, logger } = dependencies;
+    const { username } = req.body;
+    
+    // Safety check: ensure config exists
+    if (!config) {
+        logger?.log('ERROR', '[Verification] Config is undefined or null in initiateVerification');
+        return res.status(500).json({ error: "Configuration not initialized." });
+    }
+    
+    const { verificationsCollection } = config;
+    
+    // Safety check: ensure required config values exist
+    if (!verificationsCollection) {
+        logger?.log('ERROR', '[Verification] verificationsCollection is not defined in config');
+        return res.status(500).json({ error: "Configuration error: verificationsCollection not initialized." });
+    }
+
+    if (!username || typeof username !== 'string') {
+        return res.status(400).json({ error: "Invalid username." });
+    }
+
+    try {
+        // Generate a simple 6-char alphanumeric OTP
+        const otp = Math.random().toString(36).substring(2, 8).toUpperCase();
+        
+        // Store pending request
+        // Key by username to prevent multiple active requests per user
+        await db.collection(verificationsCollection).doc(username.toLowerCase()).set({
+            username,
+            otp,
+            status: 'PENDING',
+            createdAt: FieldValue.serverTimestamp(),
+            expiresAt: new Date(Date.now() + 3600000) // 1 hour expiry
+        });
+
+        return res.status(200).json({ 
+            success: true, 
+            message: "Please place this code in your eToro Bio or Short Bio.",
+            otp 
+        });
+
+    } catch (error) {
+        return res.status(500).json({ error: error.message });
+    }
+}
+
+/**
+ * 2. Finalize Verification
+ * Checks eToro API for the OTP, claims the user, and triggers on-demand fetching.
+ */
+async function finalizeVerification(req, res, dependencies, config) {
+    const { db, logger } = dependencies;
+    const { username } = req.body;
+    
+    // Safety check: ensure config exists and is an object
+    if (!config || typeof config !== 'object') {
+        logger.log('ERROR', '[Verification] Config is undefined, null, or not an object', { configType: typeof config, configValue: config });
+        return res.status(500).json({ error: "Configuration not initialized." });
+    }
+    
+    // Safe destructuring with defaults to prevent ReferenceErrors
+    const { 
+        verificationsCollection = null, 
+        signedInUsersCollection = null,
+        proxyConfig = null, 
+        headerConfig = null,
+        pubsubTopicUserFetch = null,
+        pubsubTopicUserFetchOnDemand = null,
+        pubsubTopicSocialFetch = null
+    } = config || {};
+    
+    // Safety check: ensure required config values exist
+    if (!signedInUsersCollection) {
+        logger.log('ERROR', '[Verification] signedInUsersCollection is not defined in config', { 
+            configKeys: Object.keys(config),
+            signedInUsersCollection: config.signedInUsersCollection 
+        });
+        return res.status(500).json({ error: "Configuration error: signedInUsersCollection not initialized." });
+    }
+    
+    if (!verificationsCollection) {
+        logger.log('ERROR', '[Verification] verificationsCollection is not defined in config', { 
+            configKeys: Object.keys(config),
+            verificationsCollection: config.verificationsCollection 
+        });
+        return res.status(500).json({ error: "Configuration error: verificationsCollection not initialized." });
+    }
+    
+    // Use on-demand topic for user signup (API-triggered)
+    const taskEngineTopic = pubsubTopicUserFetchOnDemand || pubsubTopicUserFetch || 'etoro-user-fetch-topic-ondemand';
+
+    if (!username) return res.status(400).json({ error: "Missing username." });
+
+    try {
+        const docRef = db.collection(verificationsCollection).doc(username.toLowerCase());
+        const doc = await docRef.get();
+
+        if (!doc.exists) {
+            return res.status(404).json({ error: "No pending verification found. Please initiate first." });
+        }
+
+        const verificationData = doc.data();
+        if (verificationData.status === 'VERIFIED') {
+            return res.status(200).json({ success: true, message: "User already verified." });
+        }
+
+        const otp = verificationData.otp;
+
+        // --- A. Fetch eToro Profile ---
+        const proxyManager = new IntelligentProxyManager(db, logger, proxyConfig);
+        const headerManager = new IntelligentHeaderManager(db, logger, headerConfig);
+        
+        logger.log('INFO', `[Verification] Fetching profile for ${username} via Proxy/Header managers...`);
+
+        // Select Header
+        const { header } = await headerManager.selectHeader();
+        const requestHeaders = {
+            'Accept': 'application/json',
+            'Referer': 'https://www.etoro.com/',
+            ...header
+        };
+
+        const targetUrl = `https://www.etoro.com/api/logininfo/v1.1/users/${username}`;
+        
+        let profileData = null;
+        try {
+            const response = await proxyManager.fetch(targetUrl, { 
+                method: 'GET', 
+                headers: requestHeaders 
+            });
+
+            if (response.ok) {
+                profileData = await response.json();
+            } else {
+                // [FIX] Fallback to direct fetch with proper error handling
+                logger.log('WARN', `[Verification] Proxy failed (${response.status}). Trying direct fetch...`);
+                try {
+                    const directFetch = typeof fetch !== 'undefined' ? fetch : require('node-fetch');
+                    const directRes = await directFetch(targetUrl, { headers: requestHeaders });
+                    if (directRes.ok) {
+                        profileData = await directRes.json();
+                    } else {
+                        throw new Error(`eToro API status: ${directRes.status}`);
+                    }
+                } catch (directErr) {
+                    logger.log('ERROR', `[Verification] Direct fetch also failed for ${username}`, directErr);
+                    throw new Error(`Failed to fetch eToro profile. Proxy: ${response.status}, Direct: ${directErr.message}`);
+                }
+            }
+        } catch (fetchErr) {
+            logger.log('ERROR', `[Verification] Fetch failed for ${username}`, fetchErr);
+            return res.status(502).json({ error: "Failed to connect to eToro. Try again later." });
+        }
+
+        if (!profileData || !profileData.realCID) {
+            return res.status(404).json({ error: "eToro user not found or invalid response." });
+        }
+
+        // --- B. Validate OTP ---
+        const bio = profileData.userBio?.aboutMe || profileData.aboutMe || "";
+        const bioShort = profileData.userBio?.aboutMeShort || profileData.aboutMeShort || "";
+        
+        if (!bio.includes(otp) && !bioShort.includes(otp)) {
+            return res.status(400).json({ 
+                success: false, 
+                error: "OTP not found in Bio.",
+                debug: "Ensure the code is saved in your 'About Me' section."
+            });
+        }
+
+        // --- C. Success: Store & Trigger ---
+        const realCID = profileData.realCID;
+        const isOptOut = profileData.optOut === true; // Private profile
+
+        // 1. Mark Verified
+        await docRef.update({ 
+            status: 'VERIFIED', 
+            verifiedAt: FieldValue.serverTimestamp(),
+            cid: realCID,
+            isOptOut
+        });
+
+        // 2. Create/Update User Doc
+        await db.collection(signedInUsersCollection).doc(String(realCID)).set({
+            username: profileData.username,
+            cid: realCID,
+            fullName: `${profileData.firstName || ''} ${profileData.lastName || ''}`.trim(),
+            avatar: profileData.avatars?.find(a => a.type === 'Original')?.url || null,
+            isOptOut,
+            verifiedAt: FieldValue.serverTimestamp(),
+            lastLogin: FieldValue.serverTimestamp()
+        }, { merge: true });
+
+        // 3. Trigger Downstream Systems via Pub/Sub
+        // Send unified request to task engine that handles both portfolio/history AND social data
+        const pubsubUtils = new PubSubUtils(dependencies);
+        
+        // Generate a requestId for tracking and to ensure finalizeOnDemandRequest runs
+        // This is critical - without requestId, the root data indexer and computations won't be triggered
+        const requestId = `signup-${realCID}-${Date.now()}`;
+        
+        // Create request tracking document (similar to user sync requests)
+        try {
+            const requestRef = db.collection('user_sync_requests')
+                .doc(String(realCID))
+                .collection('requests')
+                .doc(requestId);
+            
+            await requestRef.set({
+                targetUserCid: realCID,
+                username: profileData.username,
+                status: 'pending',
+                source: 'user_signup',
+                requestedAt: FieldValue.serverTimestamp(),
+                createdAt: FieldValue.serverTimestamp(),
+                metadata: {
+                    isNewUser: true,
+                    verificationSource: 'otp_verification'
+                }
+            });
+            
+            logger.log('INFO', `[Verification] Created request tracking document for ${username} (${realCID}): ${requestId}`);
+        } catch (reqError) {
+            logger.log('WARN', `[Verification] Failed to create request tracking document: ${reqError.message}`);
+            // Continue anyway - the requestId is still set
+        }
+        
+        // Create a unified on-demand request that includes both portfolio and social
+        // The task engine will process both, update root data, then trigger computations
+        const unifiedTask = {
+            type: 'ON_DEMAND_USER_UPDATE', // Matches Task Engine handler
+            cid: realCID, // Top-level CID for handler
+            username: profileData.username, // Top-level username for handler
+            requestId: requestId, // CRITICAL: Required for finalizeOnDemandRequest to run
+            source: 'user_signup', // Mark as signup to ensure computations are triggered
+            data: {
+                cid: realCID,
+                username: profileData.username,
+                includeSocial: true, // Flag to include social data fetch
+                since: new Date(Date.now() - (7 * 24 * 60 * 60 * 1000)).toISOString() // Last 7 days for social
+            },
+            metadata: {
+                onDemand: true,
+                targetCid: realCID, // Optimization: only process this user
+                isNewUser: true, // Flag to add to daily update queue
+                requestedAt: new Date().toISOString(),
+                userType: 'SIGNED_IN_USER' // Explicitly set userType for computation selection
+            }
+        };
+        
+        // Only trigger if user is public (has portfolio data)
+        if (!isOptOut) {
+            await pubsubUtils.publish(taskEngineTopic, unifiedTask);
+            logger.log('INFO', `[Verification] Triggered unified data fetch (portfolio + social) for ${username} (${realCID}) via on-demand topic with requestId: ${requestId}`);
+        } else {
+            // For private users, still fetch social data but no portfolio
+            const socialOnlyTask = {
+                type: 'ON_DEMAND_USER_UPDATE',
+                cid: realCID,
+                username: profileData.username,
+                requestId: requestId, // CRITICAL: Required for finalizeOnDemandRequest to run
+                source: 'user_signup',
+                data: {
+                    cid: realCID,
+                    username: profileData.username,
+                    includeSocial: true,
+                    portfolioOnly: false, // Skip portfolio for private users
+                    since: new Date(Date.now() - (7 * 24 * 60 * 60 * 1000)).toISOString()
+                },
+                metadata: {
+                    onDemand: true,
+                    targetCid: realCID,
+                    isNewUser: true,
+                    requestedAt: new Date().toISOString(),
+                    userType: 'SIGNED_IN_USER' // Explicitly set userType for computation selection
+                }
+            };
+            await pubsubUtils.publish(taskEngineTopic, socialOnlyTask);
+            logger.log('INFO', `[Verification] Triggered social-only fetch for private user ${username} (${realCID}) via on-demand topic with requestId: ${requestId}`);
+        }
+
+        return res.status(200).json({ 
+            success: true, 
+            message: "Account verified successfully. Data ingestion started.",
+            cid: realCID
+        });
+
+    } catch (error) {
+        // Enhanced error logging to capture full error details
+        const errorDetails = {
+            message: error?.message || 'Unknown error',
+            stack: error?.stack || 'No stack trace',
+            name: error?.name || 'Error',
+            configExists: !!config,
+            configKeys: config ? Object.keys(config) : [],
+            signedInUsersCollection: config?.signedInUsersCollection || 'NOT SET',
+            verificationsCollection: config?.verificationsCollection || 'NOT SET'
+        };
+        
+        logger.log('ERROR', `[Verification] System error for ${username}`, errorDetails);
+        logger.log('ERROR', `[Verification] Full error object:`, error);
+        
+        return res.status(500).json({ 
+            error: error?.message || 'An unexpected error occurred during verification.',
+            details: process.env.NODE_ENV === 'development' ? errorDetails : undefined
+        });
+    }
+}
+
+module.exports = { initiateVerification, finalizeVerification };

package/functions/old-generic-api/user-api/helpers/watchlist/watchlist_analytics_helpers.js

@@ -0,0 +1,96 @@
+/**
+ * @fileoverview Watchlist Analytics Helpers
+ * Handles watchlist analytics and trigger counts
+ */
+
+const { Timestamp } = require('@google-cloud/firestore');
+const { readWithMigration } = require('../core/path_resolution_helpers');
+
+/**
+ * GET /user/me/watchlists/:id/trigger-counts
+ * Get alert trigger counts for PIs in a watchlist (last 7 days)
+ */
+async function getWatchlistTriggerCounts(req, res, dependencies, config) {
+    const { db, logger } = dependencies;
+    const { userCid } = req.query;
+    const { id } = req.params;
+    
+    if (!userCid || !id) {
+        return res.status(400).json({ error: "Missing userCid or watchlist id" });
+    }
+    
+    try {
+        // Read watchlist from new path with migration
+        const watchlistResult = await readWithMigration(
+            db,
+            'signedInUsers',
+            'watchlists',
+            { cid: userCid },
+            {
+                isCollection: false,
+                dataType: 'watchlists',
+                config,
+                logger,
+                documentId: id,
+                collectionRegistry: dependencies.collectionRegistry
+            }
+        );
+        
+        let items = [];
+        if (watchlistResult && watchlistResult.data) {
+            items = watchlistResult.data.items || [];
+        } else {
+            // Fallback to legacy path
+            const watchlistsCollection = config.watchlistsCollection || 'watchlists';
+            const watchlistRef = db.collection(watchlistsCollection)
+                .doc(String(userCid))
+                .collection('lists')
+                .doc(id);
+            
+            const watchlistDoc = await watchlistRef.get();
+            
+            if (!watchlistDoc.exists) {
+                return res.status(404).json({ error: "Watchlist not found" });
+            }
+            
+            const watchlistData = watchlistDoc.data();
+            items = watchlistData.items || [];
+        }
+        
+        // Calculate date 7 days ago
+        const sevenDaysAgo = new Date();
+        sevenDaysAgo.setDate(sevenDaysAgo.getDate() - 7);
+        const cutoffTimestamp = Timestamp.fromDate(sevenDaysAgo);
+        
+        const triggerCounts = {};
+        const alertTriggersCollection = config.alertTriggersCollection || 'alert_triggers';
+        
+        // For each PI in the watchlist, count triggers in last 7 days
+        for (const item of items) {
+            const piCid = item.cid;
+            const triggersRef = db.collection(alertTriggersCollection)
+                .doc(String(userCid))
+                .collection('triggers')
+                .where('piCid', '==', piCid)
+                .where('triggeredAt', '>', cutoffTimestamp);
+            
+            const triggersSnapshot = await triggersRef.get();
+            triggerCounts[piCid] = triggersSnapshot.size;
+        }
+        
+        return res.status(200).json({
+            triggerCounts,
+            watchlistId: id,
+            period: '7days'
+        });
+        
+    } catch (error) {
+        logger.log('ERROR', `[getWatchlistTriggerCounts] Error fetching trigger counts`, error);
+        return res.status(500).json({ error: error.message });
+    }
+}
+
+module.exports = {
+    getWatchlistTriggerCounts
+};
+

package/functions/old-generic-api/user-api/helpers/watchlist/watchlist_data_helpers.js

@@ -0,0 +1,141 @@
+/**
+ * @fileoverview Legacy Watchlist Data Helpers
+ * Handles legacy single watchlist endpoints with migration support
+ */
+
+const { FieldValue } = require('@google-cloud/firestore');
+const { readWithMigration, writeWithMigration } = require('../core/path_resolution_helpers');
+const { getEffectiveCid } = require('../dev/dev_helpers');
+
+/**
+ * GET /user/me/watchlist (Legacy)
+ * Fetches the user's legacy watchlist
+ * Migrates to new path automatically
+ */
+async function getWatchlist(req, res, dependencies, config) {
+    const { db, logger } = dependencies;
+    const { userCid } = req.query;
+    
+    if (!userCid) {
+        return res.status(400).json({ error: "Missing userCid" });
+    }
+    
+    try {
+        const effectiveCid = await getEffectiveCid(db, userCid, config, logger);
+        
+        // Try new path with migration
+        const result = await readWithMigration(
+            db,
+            'signedInUsers',
+            'watchlists',
+            { cid: effectiveCid },
+            {
+                isCollection: true,
+                dataType: 'watchlists',
+                config,
+                logger,
+                collectionRegistry: dependencies.collectionRegistry
+            }
+        );
+        
+        if (result && result.snapshot) {
+            // Convert snapshot to legacy format for backward compatibility
+            const watchlistData = {};
+            result.snapshot.forEach(doc => {
+                watchlistData[doc.id] = doc.data();
+            });
+            
+            return res.status(200).json({ 
+                watchlist: watchlistData,
+                effectiveCid: effectiveCid,
+                actualCid: Number(userCid),
+                migrated: result.source === 'legacy'
+            });
+        }
+        
+        // Fallback to legacy collection
+        const watchlistsCollection = config.watchlistsCollection || 'watchlists';
+        const watchlistRef = db.collection(watchlistsCollection).doc(String(effectiveCid));
+        const watchlistDoc = await watchlistRef.get();
+        
+        if (!watchlistDoc.exists) {
+            return res.status(200).json({ watchlist: {} });
+        }
+        
+        const watchlistData = watchlistDoc.data();
+        return res.status(200).json({ 
+            watchlist: watchlistData,
+            effectiveCid: effectiveCid,
+            actualCid: Number(userCid)
+        });
+        
+    } catch (error) {
+        logger.log('ERROR', `[getWatchlist] Error fetching watchlist for ${userCid}`, error);
+        return res.status(500).json({ error: error.message });
+    }
+}
+
+/**
+ * POST /watchlist (Legacy)
+ * Adds/Updates a watchlist item
+ * Writes to both new and legacy paths during migration
+ */
+async function updateWatchlist(req, res, dependencies, config) {
+    const { db, logger } = dependencies;
+    const { userCid, type, target, alertConfig } = req.body;
+    
+    if (!userCid || !type || !target) {
+        return res.status(400).json({ error: "Invalid payload" });
+    }
+
+    try {
+        const effectiveCid = await getEffectiveCid(db, userCid, config, logger);
+        
+        // Generate entry ID
+        const entryId = type === 'static' 
+            ? `static_${target}` 
+            : `dyn_${Buffer.from(JSON.stringify(target)).toString('base64').slice(0,10)}`;
+        
+        const watchlistEntry = {
+            type,
+            target,
+            alertConfig: alertConfig || {},
+            updatedAt: FieldValue.serverTimestamp()
+        };
+        
+        // Write to new path with dual write
+        await writeWithMigration(
+            db,
+            'signedInUsers',
+            'watchlists',
+            { cid: effectiveCid },
+            watchlistEntry,
+            {
+                isCollection: true,
+                merge: true,
+                dataType: 'watchlists',
+                config,
+                documentId: entryId,
+                dualWrite: true,
+                collectionRegistry: dependencies.collectionRegistry
+            }
+        );
+        
+        return res.status(200).json({ 
+            success: true, 
+            id: entryId,
+            effectiveCid: effectiveCid,
+            actualCid: Number(userCid)
+        });
+
+    } catch (error) {
+        logger.log('ERROR', `[updateWatchlist] Error updating watchlist for ${userCid}`, error);
+        return res.status(500).json({ error: error.message });
+    }
+}
+
+module.exports = {
+    getWatchlist,
+    updateWatchlist
+};
+