bulltrackers-module 1.0.591 → 1.0.593

package/functions/api-v2/routes/profile.js

@@ -0,0 +1,212 @@
+const express = require('express');
+const { 
+    pageCollection, 
+    latestUserCentricSnapshot, 
+    fetchPopularInvestorMasterList,
+    fetchUserRecommendations,
+    checkDataStatus,
+    getComputationResults,
+    isSignedInUser
+} = require('../helpers/data-fetchers/firestore.js');
+
+const router = express.Router();
+
+/**
+ * PRIVATE PROFILE PAGE - Signed-in User's Own Profile
+ * 
+ * This route returns the signed-in user's own profile data.
+ * - For regular users: Uses SignedInUserProfileMetrics computation
+ * - For Popular Investors: Uses SignedInUserPIPersonalizedMetrics computation
+ * 
+ * Access: Private (requires authentication - only the signed-in user can access their own profile)
+ */
+
+// GET /profile/me - Private profile page (signed-in user's own data)
+router.get('/me', async (req, res) => {
+    try {
+        const { db } = req.dependencies;
+        const { date, lookback = 7 } = req.query;
+        const userId = req.targetUserId;
+        
+        // Default to today if no date provided
+        const targetDate = date || new Date().toISOString().split('T')[0];
+        
+        let computationName = 'SignedInUserProfileMetrics'; 
+
+        // Check if the signed-in user is a Popular Investor
+        try {
+            await fetchPopularInvestorMasterList(db, userId);
+            // User is a PI, use the specialized PI metrics
+            computationName = 'SignedInUserPIPersonalizedMetrics';
+        } catch (e) { 
+            // User is not a PI, keep default computation
+        }
+        
+        const metrics = await pageCollection(db, targetDate, computationName, userId, parseInt(lookback));
+        res.json({ 
+            success: true, 
+            computation: computationName, 
+            data: metrics,
+            profileType: 'private' // Indicates this is the user's own private profile
+        });
+    } catch (error) {
+        res.status(404).json({ error: error.message });
+    }
+});
+
+// GET /profile/metrics - Legacy route (deprecated, use /profile/me instead)
+// Kept for backward compatibility
+router.get('/metrics', async (req, res) => {
+    try {
+        const { db } = req.dependencies;
+        const { date, lookback = 7 } = req.query;
+        const userId = req.targetUserId;
+        
+        // Default to today if no date provided
+        const targetDate = date || new Date().toISOString().split('T')[0];
+        
+        let computationName = 'SignedInUserProfileMetrics'; 
+
+        try {
+            await fetchPopularInvestorMasterList(db, userId);
+            computationName = 'SignedInUserPIPersonalizedMetrics';
+        } catch (e) { /* Not PI */ }
+        
+        const metrics = await pageCollection(db, targetDate, computationName, userId, parseInt(lookback));
+        res.json({ success: true, computation: computationName, data: metrics });
+    } catch (error) {
+        res.status(404).json({ error: error.message });
+    }
+});
+
+// GET /profile/data-status (Rec 2)
+router.get('/data-status', async (req, res) => {
+    try {
+        const status = await checkDataStatus(req.dependencies.db, req.targetUserId);
+        res.json({ success: true, data: status });
+    } catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+
+// GET /profile/posts (Rec 3)
+router.get('/posts', async (req, res) => {
+    try {
+        // Fetch latest posts snapshot
+        const posts = await latestUserCentricSnapshot(req.dependencies.db, req.targetUserId, 'posts', 'post', 'SignedInUsers', 'latest');
+        res.json({ success: true, data: posts });
+    } catch (error) {
+        res.status(404).json({ error: error.message });
+    }
+});
+
+// GET /profile/is-popular-investor (Rec 5)
+router.get('/is-popular-investor', async (req, res) => {
+    try {
+        await fetchPopularInvestorMasterList(req.dependencies.db, req.targetUserId);
+        res.json({ isPi: true });
+    } catch (e) {
+        res.json({ isPi: false });
+    }
+});
+
+// GET /profile/recommendations (Updated for Rec 16)
+router.get('/recommendations', async (req, res) => {
+    try {
+        const { db } = req.dependencies;
+        const { type } = req.query; // 'similar', 'hedges'
+        
+        if (type === 'hedges' || type === 'similar') {
+             const today = new Date().toISOString().split('T')[0];
+             const compName = type === 'hedges' ? 'RecommendedHedges' : 'SimilarInvestors';
+             const data = await getComputationResults(db, compName, today, req.targetUserId);
+             return res.json({ success: true, data });
+        }
+
+        const data = await fetchUserRecommendations(db, req.targetUserId);
+        res.json({ success: true, data });
+    } catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+
+// GET /profile/portfolio (Existing)
+router.get('/portfolio', async (req, res) => {
+    try {
+        const { db } = req.dependencies;
+        const data = await latestUserCentricSnapshot(db, req.targetUserId, 'portfolio', 'portfolio', 'SignedInUsers', 'latest');
+        res.json({ success: true, data });
+    } catch (error) {
+        res.status(404).json({ error: error.message });
+    }
+});
+
+// GET /profile/is-signed-in-user/:cid - Check if user exists in SignedInUsers
+router.get('/is-signed-in-user/:cid', async (req, res) => {
+    try {
+        const { db } = req.dependencies;
+        const { cid } = req.params;
+        const isSignedIn = await isSignedInUser(db, cid);
+        res.json({ success: true, isSignedInUser: isSignedIn });
+    } catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+
+// GET /profile/computations - Get computation results for the signed-in user
+router.get('/computations', async (req, res) => {
+    try {
+        const { db } = req.dependencies;
+        const { computation, date, mode = 'latest' } = req.query;
+        const userId = req.targetUserId;
+        
+        if (!computation) {
+            return res.status(400).json({ error: "Missing required parameter: computation" });
+        }
+        
+        // Parse computation names (comma-separated)
+        const computationNames = computation.split(',').map(c => c.trim()).filter(c => c);
+        if (computationNames.length === 0) {
+            return res.status(400).json({ error: "Invalid computation parameter" });
+        }
+        
+        // Use today's date if not provided
+        const targetDate = date || new Date().toISOString().split('T')[0];
+        
+        // Fetch results for each computation
+        const results = {};
+        for (const compName of computationNames) {
+            try {
+                const data = await getComputationResults(db, compName, targetDate, userId);
+                results[compName] = data;
+            } catch (error) {
+                // If latest mode and today fails, try yesterday
+                if (mode === 'latest') {
+                    try {
+                        const yesterday = new Date();
+                        yesterday.setDate(yesterday.getDate() - 1);
+                        const yesterdayStr = yesterday.toISOString().split('T')[0];
+                        const data = await getComputationResults(db, compName, yesterdayStr, userId);
+                        results[compName] = data;
+                    } catch (e) {
+                        results[compName] = null;
+                    }
+                } else {
+                    results[compName] = null;
+                }
+            }
+        }
+        
+        res.json({ 
+            success: true, 
+            userId,
+            date: targetDate,
+            mode,
+            computations: results
+        });
+    } catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+
+module.exports = router;

package/functions/api-v2/routes/reviews.js

@@ -0,0 +1,72 @@
+const express = require('express');
+const { manageReviews } = require('../helpers/data-fetchers/firestore.js');
+
+const router = express.Router();
+
+// POST /reviews/submit
+router.post('/submit', async (req, res) => {
+    try {
+        const { db } = req.dependencies;
+        const { piId, rating, comment, username, isAnonymous } = req.body;
+        
+        const result = await manageReviews(db, req.targetUserId, 'submit', { 
+            piId, rating, comment, username, isAnonymous 
+        });
+        
+        res.json(result);
+    } catch (error) {
+        res.status(403).json({ error: error.message });
+    }
+});
+
+// GET /reviews/me - Get all reviews by the signed-in user
+// Optional query param: ?piId=xxx to filter by specific PI
+router.get('/me', async (req, res) => {
+    try {
+        const { db } = req.dependencies;
+        const { piId } = req.query; // Optional filter by PI ID
+        
+        let snap;
+        if (piId) {
+            // Fetch specific review for a PI
+            const doc = await db.collection('SignedInUsers').doc(req.targetUserId).collection('reviews').doc(String(piId)).get();
+            if (!doc.exists) {
+                return res.json({ success: true, exists: false, review: null });
+            }
+            return res.json({ success: true, exists: true, review: doc.data() });
+        } else {
+            // Fetch all reviews
+            snap = await db.collection('SignedInUsers').doc(req.targetUserId).collection('reviews').get();
+            const data = snap.docs.map(d => d.data());
+            res.json({ success: true, data });
+        }
+    } catch (e) { res.status(500).json({ error: e.message }); }
+});
+
+// GET /reviews/:piId
+router.get('/:piId', async (req, res) => {
+    try {
+        const { db } = req.dependencies;
+        const { piId } = req.params;
+        const { fetchAllReviewsForPI } = require('../helpers/data-fetchers/firestore.js');
+        const result = await fetchAllReviewsForPI(db, piId);
+        res.json({ success: true, ...result });
+    } catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+
+// GET /reviews/:piId/eligibility
+router.get('/:piId/eligibility', async (req, res) => {
+    try {
+        const { db } = req.dependencies;
+        const { piId } = req.params;
+        const { checkReviewEligibility } = require('../helpers/data-fetchers/firestore.js');
+        const result = await checkReviewEligibility(db, req.targetUserId, piId);
+        res.json(result);
+    } catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+
+module.exports = router;

package/functions/api-v2/routes/settings.js

@@ -0,0 +1,71 @@
+const express = require('express');
+const { manageNotificationPreferences, isDeveloper, sendTestAlert } = require('../helpers/data-fetchers/firestore.js');
+
+const router = express.Router();
+
+// GET /settings/notifications
+router.get('/notifications', async (req, res) => {
+    try {
+        const { db } = req.dependencies;
+        const data = await manageNotificationPreferences(db, req.targetUserId, 'get');
+        res.json({ success: true, data });
+    } catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+
+// PUT /settings/notifications
+router.put('/notifications', async (req, res) => {
+    try {
+        const { db } = req.dependencies;
+        const result = await manageNotificationPreferences(db, req.targetUserId, 'update', req.body);
+        res.json(result);
+    } catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+
+// GET /settings/dev/override (Rec 17)
+router.get('/dev/override', async (req, res) => {
+    try {
+        const { db } = req.dependencies;
+        if (!(await isDeveloper(db, req.targetUserId))) return res.status(403).json({ error: "Unauthorized" });
+
+        const doc = await db.collection('dev_overrides').doc(req.targetUserId).get();
+        res.json({ success: true, data: doc.exists ? doc.data() : { enabled: false } });
+    } catch (e) { res.status(500).json({ error: e.message }); }
+});
+
+// POST /settings/dev/override
+router.post('/dev/override', async (req, res) => {
+    try {
+        const { db } = req.dependencies;
+        const { enabled, impersonateCid, fakeCopiedPIs } = req.body;
+        
+        if (!(await isDeveloper(db, req.targetUserId))) return res.status(403).json({ error: "Unauthorized" });
+
+        await db.collection('dev_overrides').doc(req.targetUserId).set({
+            enabled,
+            impersonateCid,
+            fakeCopiedPIs: fakeCopiedPIs || [],
+            updatedAt: new Date()
+        }, { merge: true });
+
+        res.json({ success: true, message: "Dev override updated" });
+    } catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+
+// POST /settings/dev/test-alert (Rec 17)
+router.post('/dev/test-alert', async (req, res) => {
+    try {
+        const { db } = req.dependencies;
+        if (!(await isDeveloper(db, req.targetUserId))) return res.status(403).json({ error: "Unauthorized" });
+
+        const result = await sendTestAlert(db, req.targetUserId, req.body);
+        res.json(result);
+    } catch (e) {         res.status(500).json({ error: e.message }); }
+});
+
+module.exports = router;

package/functions/api-v2/routes/sync.js

@@ -0,0 +1,132 @@
+const express = require('express');
+const { dispatchSyncRequest } = require('../helpers/task_engine_helper.js'); 
+const { 
+    checkSyncRateLimits, 
+    getSyncStatus, 
+    isDeveloper,
+    isSignedInUser,
+    fetchPopularInvestorMasterList,
+    getUserUsername
+} = require('../helpers/data-fetchers/firestore.js');
+
+const router = express.Router();
+
+// POST /sync/request (Unified - Auto-detects user type)
+router.post('/request', async (req, res) => {
+    try {
+        const { pubsub, db } = req.dependencies;
+        // targetId can be passed (for PIs) or default to self
+        const targetId = req.body.targetId || req.targetUserId;
+        
+        // 1. Rate Limits
+        const isDev = await isDeveloper(db, req.targetUserId);
+        const limit = await checkSyncRateLimits(db, targetId, req.targetUserId, isDev);
+        if (!limit.allowed) return res.status(429).json({ error: limit.message });
+
+        // 2. Detect User Types
+        const [isSignedIn, isPI] = await Promise.all([
+            isSignedInUser(db, targetId),
+            fetchPopularInvestorMasterList(db, String(targetId)).then(() => true).catch(() => false)
+        ]);
+
+        if (!isSignedIn && !isPI) {
+            return res.status(404).json({ error: "User not found in SignedInUsers or Popular Investor master list" });
+        }
+
+        // 3. Get username
+        const username = await getUserUsername(db, targetId) || String(targetId);
+
+        // 4. Create request IDs and dispatch tasks
+        const requestIds = [];
+        const tasks = [];
+
+        if (isSignedIn) {
+            const requestId = `sync_${targetId}_user_${Date.now()}`;
+            requestIds.push(requestId);
+            
+            // Log request for signed-in user
+            await db.collection('user_sync_requests').doc(String(targetId)).collection('requests').doc(requestId).set({
+                requestId,
+                status: 'queued',
+                userType: 'SIGNED_IN_USER',
+                requestedBy: req.targetUserId,
+                createdAt: new Date()
+            });
+
+            tasks.push(
+                dispatchSyncRequest(pubsub, targetId, username, {
+                    type: 'ON_DEMAND_USER_UPDATE',
+                    priority: 'high',
+                    source: 'on_demand_sync',
+                    requestId,
+                    requestedBy: req.targetUserId,
+                    userType: 'SIGNED_IN_USER',
+                    metadata: {
+                        requestingUserCid: req.targetUserId
+                    }
+                })
+            );
+        }
+
+        if (isPI) {
+            const requestId = `sync_${targetId}_pi_${Date.now()}`;
+            requestIds.push(requestId);
+            
+            // Log request for PI
+            await db.collection('user_sync_requests').doc(String(targetId)).collection('requests').doc(requestId).set({
+                requestId,
+                status: 'queued',
+                userType: 'POPULAR_INVESTOR',
+                requestedBy: req.targetUserId,
+                createdAt: new Date()
+            });
+
+            tasks.push(
+                dispatchSyncRequest(pubsub, targetId, username, {
+                    type: 'POPULAR_INVESTOR_UPDATE',
+                    priority: 'high',
+                    source: 'on_demand_sync',
+                    requestId,
+                    requestedBy: req.targetUserId,
+                    userType: 'POPULAR_INVESTOR',
+                    metadata: {
+                        requestingUserCid: req.targetUserId
+                    }
+                })
+            );
+        }
+        
+        // Update global limit tracker (only once, regardless of how many tasks)
+        await db.collection('user_sync_requests').doc(String(targetId)).collection('global').doc('latest').set({
+            lastRequestedAt: new Date()
+        }, { merge: true });
+
+        // Dispatch all tasks
+        await Promise.all(tasks);
+        
+        res.json({ 
+            success: true, 
+            requestIds,
+            userTypes: {
+                isSignedInUser: isSignedIn,
+                isPopularInvestor: isPI
+            },
+            message: `Sync dispatched for ${isSignedIn && isPI ? 'both user types' : isSignedIn ? 'signed-in user' : 'popular investor'}` 
+        });
+    } catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+
+// GET /sync/status/:targetId
+router.get('/status/:targetId', async (req, res) => {
+    try {
+        const { db } = req.dependencies;
+        const status = await getSyncStatus(db, req.params.targetId);
+        res.json({ success: true, data: status });
+    } catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+
+module.exports = router;

package/functions/api-v2/routes/verification.js

@@ -0,0 +1,47 @@
+const express = require('express');
+const { initiateVerification, finalizeVerification, fetchUserVerificationData } = require('../helpers/data-fetchers/firestore.js');
+
+const router = express.Router();
+
+// GET /verification/status
+router.get('/status', async (req, res) => {
+    try {
+        const { db } = req.dependencies;
+        const data = await fetchUserVerificationData(db, req.targetUserId);
+        res.json({ success: true, data });
+    } catch (error) {
+        res.status(200).json({ success: false, message: "Not Verified", error: error.message });
+    }
+});
+
+// POST /verification/init
+// Generates OTP for a specific username
+router.post('/init', async (req, res) => {
+    try {
+        const { db } = req.dependencies;
+        const { username } = req.body; // Logic requires username to key the request
+        const result = await initiateVerification(db, username);
+        res.json(result);
+    } catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+
+// POST /verification/finalize
+// Checks Bio -> Verifies User -> Triggers Sync
+router.post('/finalize', async (req, res) => {
+    try {
+        const { db, pubsub } = req.dependencies;
+        const { username } = req.body; 
+
+        if (!username) return res.status(400).json({ error: "Username required" });
+
+        // Pass req.targetUserId if available, but the logic primarily uses username/realCID
+        const result = await finalizeVerification(db, pubsub, req.targetUserId, username);
+        res.json(result);
+    } catch (error) {
+        res.status(400).json({ success: false, error: error.message });
+    }
+});
+
+module.exports = router;

package/functions/api-v2/routes/watchlists.js

@@ -0,0 +1,148 @@
+const express = require('express');
+const { 
+    manageUserWatchlist, 
+    latestUserCentricSnapshot, 
+    fetchPublicWatchlists,
+    publishWatchlistVersion,
+    copyWatchlist,
+    fetchWatchlistVersions,
+    autoGenerateWatchlist,
+    fetchPopularInvestorMasterList,
+    getWatchlistTriggerCounts,
+    subscribeToAllWatchlistPIs
+} = require('../helpers/data-fetchers/firestore.js');
+
+const router = express.Router();
+
+// GET /watchlists/all
+router.get('/all', async (req, res) => {
+    try {
+        const { db } = req.dependencies;
+        const watchlists = await latestUserCentricSnapshot(db, req.targetUserId, 'watchlists', 'watchlist', 'SignedInUsers', null);
+        res.json({ success: true, count: watchlists.length, data: watchlists });
+    } catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+
+// POST /watchlists/auto-generate (Rec 11)
+router.post('/auto-generate', async (req, res) => {
+    try {
+        const result = await autoGenerateWatchlist(req.dependencies.db, req.targetUserId);
+        res.json(result);
+    } catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+
+// GET /watchlists/:id (Rec 12)
+router.get('/:id', async (req, res) => {
+    try {
+        const { db } = req.dependencies;
+        const { id } = req.params;
+        const doc = await latestUserCentricSnapshot(db, req.targetUserId, 'watchlists', 'watchlist', 'SignedInUsers', id);
+        if (!doc) return res.status(404).json({ error: "Watchlist not found" });
+        res.json({ success: true, data: doc });
+    } catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+
+// GET /watchlists/:id/rankings-check (Rec 10)
+router.get('/:id/rankings-check', async (req, res) => {
+    try {
+        const { db } = req.dependencies;
+        const { id } = req.params;
+        
+        // Fetch watchlist
+        const wl = await latestUserCentricSnapshot(db, req.targetUserId, 'watchlists', 'watchlist', 'SignedInUsers', id);
+        if (!wl) return res.status(404).json({ error: "Watchlist not found" });
+
+        const results = {};
+        for (const item of (wl.items || [])) {
+            try {
+                await fetchPopularInvestorMasterList(db, String(item.cid));
+                results[item.cid] = true;
+            } catch {
+                results[item.cid] = false;
+            }
+        }
+        res.json({ success: true, data: results });
+    } catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+
+// POST /watchlists/manage (Unified)
+router.post('/manage', async (req, res) => {
+    try {
+        const { db } = req.dependencies;
+        const { instruction, payload } = req.body; 
+        const result = await manageUserWatchlist(db, req.targetUserId, instruction, payload);
+        res.json(result);
+    } catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+
+// Public & Copy Routes (Existing)
+router.get('/public', async (req, res) => {
+    try {
+        const data = await fetchPublicWatchlists(req.dependencies.db, req.query.limit, req.query.offset);
+        res.json({ success: true, data });
+    } catch (e) { res.status(500).json({ error: e.message }); }
+});
+
+router.post('/:id/publish', async (req, res) => {
+    try {
+        const result = await publishWatchlistVersion(req.dependencies.db, req.targetUserId, req.params.id);
+        res.json(result);
+    } catch (e) { res.status(500).json({ error: e.message }); }
+});
+
+router.post('/:id/copy', async (req, res) => {
+    try {
+        const result = await copyWatchlist(req.dependencies.db, req.targetUserId, req.params.id, req.body.version);
+        res.json(result);
+    } catch (e) { res.status(500).json({ error: e.message }); }
+});
+
+router.get('/:id/versions', async (req, res) => {
+    try {
+        const data = await fetchWatchlistVersions(req.dependencies.db, req.params.id);
+        res.json({ success: true, data });
+    } catch (e) { res.status(500).json({ error: e.message }); }
+});
+
+// GET /watchlists/:id/trigger-counts - Get alert trigger counts for watchlist PIs
+router.get('/:id/trigger-counts', async (req, res) => {
+    try {
+        const { db } = req.dependencies;
+        const { id } = req.params;
+        const result = await getWatchlistTriggerCounts(db, req.targetUserId, id);
+        res.json({ success: true, ...result });
+    } catch (error) {
+        if (error.message === "Watchlist not found") {
+            return res.status(404).json({ error: error.message });
+        }
+        res.status(500).json({ error: error.message });
+    }
+});
+
+// POST /watchlists/:id/subscribe-all - Subscribe to all PIs in a watchlist
+router.post('/:id/subscribe-all', async (req, res) => {
+    try {
+        const { db } = req.dependencies;
+        const { id } = req.params;
+        const { alertTypes, thresholds } = req.body;
+        const result = await subscribeToAllWatchlistPIs(db, req.targetUserId, id, alertTypes, thresholds);
+        res.json(result);
+    } catch (error) {
+        if (error.message === "Watchlist not found") {
+            return res.status(404).json({ error: error.message });
+        }
+        res.status(500).json({ error: error.message });
+    }
+});
+
+module.exports = router;

package/functions/computation-system/helpers/computation_worker.js

@@ -232,7 +232,7 @@ async function handleComputationTask(message, config, dependencies) {
         await db.doc(ledgerPath).update({ status: 'COMPLETED', completedAt: new Date() });
         await recordRunAttempt(db, { date, computation, pass }, 'SUCCESS', null, metrics, triggerReason, resourceTier);
         
-        const { notifyComputationComplete, getComputationDisplayName } = require('../../generic-api/user-api/helpers/notifications/notification_helpers');
+        const { notifyComputationComplete, getComputationDisplayName } = require('../../old-generic-api/user-api/helpers/notifications/notification_helpers.js');
         // Send notification if this was an on-demand computation
         if (metadata?.onDemand && metadata?.requestId && metadata?.requestingUserCid) {
             try {