bulltrackers-module 1.0.766 → 1.0.769

package/functions/computation-system-v2/computations/SignedInUserList.js

@@ -0,0 +1,51 @@
+const { Computation } = require('../framework');
+
+class DebugSignedInUsers extends Computation {
+    static getConfig() {
+        return {
+            name: 'DebugSignedInUsers',
+            type: 'per-entity',
+            category: 'debug',
+            
+            // CRITICAL: Tells the Orchestrator which partition to use
+            userType: 'SIGNED_IN_USER', 
+
+            requires: {
+                // DRIVER TABLE: This MUST be first.
+                // The DAG will only create tasks for Entity IDs found in this filtered query.
+                'portfolio_snapshots': {
+                    lookback: 0, // Just need today's existence
+                    mandatory: true,
+                    fields: ['user_id', 'date'],
+                    filter: { user_type: 'SIGNED_IN_USER' }
+                }
+            },
+            
+            storage: {
+                // Just log to console or a debug table for now
+                bigquery: false, 
+                firestore: { enabled: false } 
+            }
+        };
+    }
+
+    async process(context) {
+        const { entityId, data } = context;
+        
+        // If the Orchestrator works correctly, we should ONLY see Signed-In Users here.
+        // We verify by returning their ID.
+        
+        const row = data['portfolio_snapshots'];
+        
+        // Sanity Check: If row exists, we are good.
+        if (row) {
+             this.setResult(entityId, {
+                 status: 'Found',
+                 userType: 'SIGNED_IN_USER',
+                 checkedAt: new Date().toISOString()
+             });
+        }
+    }
+}
+
+module.exports = DebugSignedInUsers;

package/functions/computation-system-v2/computations/SignedInUserMirrorHistory.js

@@ -0,0 +1,138 @@
+const { Computation } = require('../framework');
+
+class SignedInUserMirrorHistory extends Computation {
+    static getConfig() {
+        return {
+            name: 'SignedInUserMirrorHistory',
+            type: 'per-entity',
+            category: 'signed_in_user',
+            
+            // CRITICAL: Must be historical to accumulate the "Past" list over time
+            // without needing huge lookbacks.
+            isHistorical: true, 
+            
+            requires: {
+                'portfolio_snapshots': {
+                    lookback: 0,
+                    mandatory: true,
+                    fields: ['user_id', 'portfolio_data', 'date']
+                },
+                // Reduced from 90 to 30 to comply with DAG limits
+                'trade_history_snapshots': {
+                    lookback: 30, 
+                    mandatory: false,
+                    fields: ['user_id', 'history_data']
+                },
+                'pi_master_list': {
+                    lookback: 1,
+                    mandatory: false,
+                    fields: ['cid', 'username']
+                }
+            },
+            
+            storage: {
+                bigquery: true,
+                firestore: {
+                    enabled: true,
+                    path: 'users/{entityId}/mirror_history',
+                    merge: true
+                }
+            }
+        };
+    }
+
+    async process(context) {
+        const { data, entityId, rules, previousResult } = context;
+
+        // 1. Setup & Username Map
+        const masterList = data['pi_master_list'] || [];
+        const usernameMap = new Map();
+        const toArray = (input) => Array.isArray(input) ? input : Object.values(input || {});
+        
+        toArray(masterList).forEach(row => {
+            if (row.cid && row.username) usernameMap.set(String(row.cid), row.username);
+        });
+
+        // 2. Determine CURRENT Mirrors (From Today's Portfolio)
+        const currentMap = new Map();
+        const portfolioRow = data['portfolio_snapshots'];
+        
+        if (portfolioRow) {
+            const pData = rules.portfolio.extractPortfolioData(portfolioRow);
+            const rawMirrors = rules.portfolio.extractMirrors(pData); 
+            
+            rawMirrors.forEach(m => {
+                const cid = String(m.ParentCID || m.MirrorID);
+                if (cid && cid !== '0') {
+                    currentMap.set(cid, {
+                        cid: Number(cid),
+                        username: usernameMap.get(cid) || m.ParentUsername || 'Unknown',
+                        invested: m.Invested || 0,
+                        profit: m.NetProfit || 0,
+                        status: 'active',
+                        startedAt: m.InitDate || null 
+                    });
+                }
+            });
+        }
+
+        // 3. Determine PAST Mirrors (Merge Previous State + New Closures)
+        const pastMap = new Map();
+
+        // A. Load existing past mirrors from yesterday's result
+        if (previousResult && Array.isArray(previousResult.past)) {
+            previousResult.past.forEach(pm => pastMap.set(String(pm.cid), pm));
+        }
+
+        // B. Detect New Closures (Was in Previous Current, NOT in Today's Current)
+        if (previousResult && Array.isArray(previousResult.current)) {
+            previousResult.current.forEach(prevCurr => {
+                const cidStr = String(prevCurr.cid);
+                if (!currentMap.has(cidStr)) {
+                    // This mirror was active yesterday but is gone today -> It closed.
+                    pastMap.set(cidStr, {
+                        ...prevCurr,
+                        status: 'closed',
+                        closedAt: context.date, // Mark closure date as today
+                        invested: 0 // Reset invested for closed items
+                    });
+                }
+            });
+        }
+
+        // C. Supplement with Trade History (Only look back 30 days for metadata)
+        // This catches any explicit "Stop Copy" events that might provide better metadata
+        const historyRows = data['trade_history_snapshots'] || [];
+        historyRows.forEach(row => {
+            const trades = rules.trades.extractTrades(row);
+            trades.forEach(trade => {
+                const parentCID = trade.ParentCID || trade.MirrorID || trade.CopyTraderID;
+                const cidStr = String(parentCID);
+                
+                // If we found a past interaction that isn't currently active
+                if (parentCID && cidStr !== '0' && !currentMap.has(cidStr)) {
+                    if (!pastMap.has(cidStr)) {
+                        // Found a copy in history that wasn't in our previous state
+                        // (e.g. from before we started tracking, or within the 30d window)
+                        pastMap.set(cidStr, {
+                            cid: Number(parentCID),
+                            username: usernameMap.get(cidStr) || 'Unknown',
+                            status: 'closed',
+                            lastInteraction: rules.trades.getCloseDate(trade) || row.date
+                        });
+                    }
+                }
+            });
+        });
+
+        // 4. Final Output
+        this.setResult(entityId, {
+            current: Array.from(currentMap.values()),
+            past: Array.from(pastMap.values()),
+            totalUniqueCopied: currentMap.size + pastMap.size,
+            updatedAt: new Date().toISOString()
+        });
+    }
+}
+
+module.exports = SignedInUserMirrorHistory;

package/functions/computation-system-v2/computations/SignedInUserPIProfileMetrics.js

@@ -0,0 +1,106 @@
+const { Computation } = require('../framework');
+
+class SignedInUserPIProfileMetrics extends Computation {
+    static getConfig() {
+        return {
+            name: 'SignedInUserPIProfileMetrics',
+            type: 'per-entity',
+            category: 'signed_in_user',
+            isHistorical: true,
+            userType: 'SIGNED_IN_USER',
+
+            requires: {
+                // DRIVER TABLE
+                // lookback: 0 prevents "All history" fetch.
+                // filter: user_type ensures only signed-in users are fetched.
+                'portfolio_snapshots': {
+                    lookback: 0,
+                    mandatory: true,
+                    fields: ['user_id', 'user_type', 'portfolio_data', 'date'],
+                    filter: { user_type: 'SIGNED_IN_USER' }
+                },
+                'trade_history_snapshots': {
+                    lookback: 0,
+                    fields: ['user_id', 'user_type', 'history_data', 'date'],
+                    filter: { user_type: 'SIGNED_IN_USER' }
+                },
+                'ticker_mappings': { mandatory: false, fields: ['instrument_id', 'ticker'] },
+                'sector_mappings': { mandatory: false, fields: ['symbol', 'sector'] }
+            },
+
+            storage: {
+                bigquery: true,
+                firestore: {
+                    enabled: true,
+                    path: 'users/{entityId}/pi_profile_metrics/{date}',
+                    merge: true
+                }
+            }
+        };
+    }
+
+    async process(context) {
+        const { data, entityId, rules, dataFetcher } = context;
+        const portfolioRow = data['portfolio_snapshots'];
+
+        // Guard clause REMOVED to prove framework filtering works
+
+        // 2. PI STATUS CHECK (Intersection)
+        // Dynamically verify if this specific customer ID exists in the master list.
+        const piCheck = await dataFetcher.fetch({
+            table: 'pi_master_list',
+            filter: { cid: parseInt(entityId, 10) },
+            fields: ['cid'],
+            lookback: 0
+        });
+
+        if (!piCheck || piCheck.length === 0) {
+            return;
+        }
+
+        // 3. CORE LOGIC
+        const result = {
+            isPopularInvestor: true,
+            portfolioSummary: { totalValue: 0, profitPercent: 0, winRatio: 0 },
+            sectorExposure: {},
+            updatedAt: new Date().toISOString()
+        };
+
+        const pData = rules.portfolio.extractPortfolioData(portfolioRow);
+        const positions = rules.portfolio.extractPositions(pData);
+
+        result.portfolioSummary = {
+            totalValue: rules.portfolio.calculateTotalValue(positions),
+            profitPercent: rules.portfolio.calculateWeightedProfitPercent(positions),
+            winRatio: rules.portfolio.calculateWinRatio(positions)
+        };
+
+        const tickerMap = this._buildTickerMap(data['ticker_mappings']);
+        const sectorMap = this._buildSectorMap(data['sector_mappings']);
+        const instrumentSectorMap = {};
+        Object.keys(tickerMap).forEach(instId => {
+            const ticker = tickerMap[instId];
+            if (sectorMap[ticker]) instrumentSectorMap[instId] = sectorMap[ticker];
+        });
+
+        result.sectorExposure = rules.portfolio.calculateSectorExposure(positions, instrumentSectorMap);
+
+        this.setResult(entityId, result);
+    }
+
+    _buildTickerMap(rows) {
+        const map = {};
+        const arr = Array.isArray(rows) ? rows : Object.values(rows || {});
+        arr.forEach(r => { if (r.instrument_id) map[r.instrument_id] = r.ticker; });
+        return map;
+    }
+
+    _buildSectorMap(rows) {
+        const map = {};
+        const arr = Array.isArray(rows) ? rows : Object.values(rows || {});
+        arr.forEach(r => { if (r.symbol) map[r.symbol] = r.sector; });
+        return map;
+    }
+}
+
+module.exports = SignedInUserPIProfileMetrics;

package/functions/computation-system-v2/computations/SignedInUserProfileMetrics.js

@@ -0,0 +1,324 @@
+/**
+ * @fileoverview Signed-In User Profile Metrics (v2 Refactor)
+ * * TARGETS: 'SIGNED_IN_USER' only (via BQ filters).
+ * * STRATEGY: Iterates Portfolio Mirrors to enrich copied PI data.
+ */
+const { Computation } = require('../framework');
+
+class SignedInUserProfileMetrics extends Computation {
+
+    static getConfig() {
+        return {
+            name: 'SignedInUserProfileMetrics',
+            type: 'per-entity',
+            category: 'signed_in_user',
+            isHistorical: true,
+            
+            requires: {
+                // --- Core Data (Drivers) ---
+                // [CRITICAL] Filters restrict execution to Signed-In Users only
+                'portfolio_snapshots': {
+                    lookback: 30,
+                    mandatory: true,
+                    fields: ['user_id', 'portfolio_data', 'date'],
+                    filter: { user_type: 'SIGNED_IN_USER' } 
+                },
+                'trade_history_snapshots': {
+                    lookback: 30,
+                    mandatory: false,
+                    fields: ['user_id', 'history_data', 'date'],
+                    filter: { user_type: 'SIGNED_IN_USER' }
+                },
+                'social_post_snapshots': {
+                    lookback: 7,
+                    mandatory: false,
+                    fields: ['user_id', 'posts_data', 'date'],
+                    filter: { user_type: 'SIGNED_IN_USER' }
+                },
+                
+                // --- Reference Data (Lookups) ---
+                // Used only to enrich PIs found in the user's copy list
+                'pi_rankings': {
+                    lookback: 7,
+                    mandatory: false,
+                    fields: ['pi_id', 'rankings_data', 'username', 'date']
+                },
+                'pi_master_list': {
+                    lookback: 1,
+                    mandatory: false,
+                    fields: ['cid', 'username']
+                },
+                'pi_ratings': {
+                    lookback: 30,
+                    mandatory: false,
+                    fields: ['pi_id', 'average_rating', 'date']
+                },
+                
+                // --- Mappings ---
+                'ticker_mappings': { mandatory: false },
+                'sector_mappings': { mandatory: false }
+            },
+
+            storage: {
+                bigquery: true,
+                firestore: {
+                    enabled: true,
+                    path: 'user_profiles/{entityId}/metrics/{date}', // Standardized path
+                    merge: true
+                }
+            },
+
+            userType: 'SIGNED_IN_USER'
+        };
+    }
+
+    async process(context) {
+        const { data, entityId, rules } = context;
+
+        // ==========================================================================================
+        // 0. HELPERS & REFERENCE DATA
+        // ==========================================================================================
+        const toDateStr = (d) => (d?.value || (d instanceof Date ? d.toISOString().slice(0, 10) : String(d)));
+        const toArray = (input) => (Array.isArray(input) ? input : (input ? Object.values(input) : []));
+
+        // Helper to handle V2 Map-based data structure
+        const getEntityRows = (dataset) => {
+            if (!dataset) return [];
+            // Direct entity lookup (fastest)
+            if (dataset[entityId]) return Array.isArray(dataset[entityId]) ? dataset[entityId] : [dataset[entityId]];
+            // Fallback for flat arrays (slower, but safe)
+            if (Array.isArray(dataset)) return dataset.filter(r => String(r.user_id || r.cid) === String(entityId));
+            return [];
+        };
+
+        const sortAsc = (input) => toArray(input).sort((a, b) => toDateStr(a.date).localeCompare(toDateStr(b.date)));
+
+        // Mappings
+        const tickerMap = new Map();
+        toArray(data['ticker_mappings']).forEach(row => { if (row.instrument_id) tickerMap.set(Number(row.instrument_id), row.ticker); });
+        const resolveTicker = (id) => tickerMap.get(Number(id)) || `ID:${id}`;
+
+        const sectorMap = new Map();
+        toArray(data['sector_mappings']).forEach(row => { if (row.symbol) sectorMap.set(row.symbol.toUpperCase(), row.sector); });
+        const resolveSector = (id) => {
+            const ticker = resolveTicker(id);
+            return ticker ? (sectorMap.get(ticker) || 'Unknown') : 'Unknown';
+        };
+
+        // Global Reference Data (Optimized for Lookups)
+        // We convert these arrays to Maps/Finders only once if this were a global calc, 
+        // but here we just do simple lookups for the specific copied PIs.
+        const globalRankings = toArray(data['pi_rankings']);
+        const piMasterList = toArray(data['pi_master_list']);
+
+        const resolveUsername = (cid) => {
+            const rank = globalRankings.find(r => String(r.pi_id || r.CustomerId) === String(cid));
+            if (rank?.username || rank?.UserName) return rank.username || rank.UserName;
+            const master = piMasterList.find(m => String(m.cid) === String(cid));
+            return master?.username || 'Unknown';
+        };
+
+        // Initialize Result Structure
+        const result = {
+            socialEngagement: { chartType: 'line', data: [] },
+            myPosts: { chartType: 'feed', data: [] },
+            profitablePositions: { chartType: 'bar', data: [] },
+            topWinningPositions: { chartType: 'table', data: [] },
+            sectorPerformance: { bestSector: null, worstSector: null, bestSectorProfit: 0, worstSectorProfit: 0 },
+            sectorExposure: { chartType: 'pie', data: {} },
+            assetExposure: { chartType: 'pie', data: {} },
+            portfolioSummary: { totalInvested: 0, totalProfit: 0, profitPercent: 0 },
+            copiedPIs: { chartType: 'cards', data: [] },     // Populated from Mirrors
+            recommendedPIs: { chartType: 'cards', data: [] }, // (Optional: derived from similarity)
+            recentlyViewedPages: { chartType: 'list', data: [] },
+            alertGraphs: { chartType: 'line', data: [] },
+            performanceGraphics: { chartType: 'composite', data: {} },
+            exposureGraphics: { chartType: 'composite', data: {} }
+        };
+
+        // ==========================================================================================
+        // 1. DATA PREPARATION
+        // ==========================================================================================
+        const portfolios = sortAsc(getEntityRows(data['portfolio_snapshots']));
+        const historyData = sortAsc(getEntityRows(data['trade_history_snapshots']));
+        const socialData = sortAsc(getEntityRows(data['social_post_snapshots']));
+        
+        const currentPortfolio = portfolios.length > 0 ? portfolios[portfolios.length - 1] : null;
+
+        // ==========================================================================================
+        // 2. SOCIAL FEED (My Posts)
+        // ==========================================================================================
+        const socialFeed = [];
+        socialData.forEach(day => {
+            const posts = rules.social.extractPosts(day);
+            const dStr = toDateStr(day.date);
+            let dayLikes = 0, dayComments = 0;
+
+            posts.forEach(p => {
+                const likes = rules.social.getPostLikes(p) || 0;
+                const comments = rules.social.getPostComments(p) || 0;
+                dayLikes += likes;
+                dayComments += comments;
+
+                socialFeed.push({
+                    id: p.id,
+                    date: rules.social.getPostDate(p),
+                    text: rules.social.getPostText(p),
+                    likes,
+                    comments,
+                    type: 'post'
+                });
+            });
+
+            if (dayLikes > 0 || dayComments > 0) {
+                result.socialEngagement.data.push({ date: dStr, likes: dayLikes, comments: dayComments });
+            }
+        });
+        // Limit feed size
+        result.myPosts.data = socialFeed.sort((a, b) => new Date(b.date) - new Date(a.date)).slice(0, 20);
+
+        // ==========================================================================================
+        // 3. TRADES & PERFORMANCE
+        // ==========================================================================================
+        const dailyPnL = new Map();
+        const winLoss = { wins: 0, losses: 0, profit: 0, loss: 0 };
+        const tradeStats = new Map();
+
+        historyData.forEach(dayDoc => {
+            const trades = rules.trades.extractTrades(dayDoc);
+            trades.forEach(t => {
+                const closeDate = rules.trades.getCloseDate(t);
+                if (!closeDate) return;
+                
+                const dKey = closeDate.toISOString().split('T')[0];
+                const profit = rules.trades.getNetProfit(t);
+
+                // Stats for Bar Chart
+                const entry = tradeStats.get(dKey) || { date: dKey, profitableCount: 0, totalCount: 0 };
+                entry.totalCount++;
+                if (profit > 0) entry.profitableCount++;
+                tradeStats.set(dKey, entry);
+
+                // Stats for Aggregate Graphics
+                if (profit > 0) { winLoss.wins++; winLoss.profit += profit; }
+                else if (profit < 0) { winLoss.losses++; winLoss.loss += profit; }
+                
+                dailyPnL.set(dKey, (dailyPnL.get(dKey) || 0) + profit);
+            });
+        });
+
+        result.profitablePositions.data = Array.from(tradeStats.values())
+            .sort((a,b) => a.date.localeCompare(b.date))
+            .slice(-30);
+        
+        result.performanceGraphics.data = {
+            winRate: (winLoss.wins + winLoss.losses) > 0 ? Number(((winLoss.wins / (winLoss.wins + winLoss.losses)) * 100).toFixed(2)) : 0,
+            avgWin: winLoss.wins > 0 ? Number((winLoss.profit / winLoss.wins).toFixed(2)) : 0,
+            avgLoss: winLoss.losses > 0 ? Number((winLoss.loss / winLoss.losses).toFixed(2)) : 0,
+            profitFactor: winLoss.losses !== 0 ? Number((Math.abs(winLoss.profit / winLoss.loss)).toFixed(2)) : (winLoss.profit > 0 ? Infinity : 0),
+            dailyPnL: Array.from(dailyPnL.entries()).map(([date, pnl]) => ({ date, pnl: Number(pnl.toFixed(2)) })).sort((a,b) => a.date.localeCompare(b.date)).slice(-20)
+        };
+
+        // ==========================================================================================
+        // 4. PORTFOLIO & COPIED PIs (The Core Requirement)
+        // ==========================================================================================
+        if (currentPortfolio) {
+            const pData = rules.portfolio.extractPortfolioData(currentPortfolio);
+            const positions = rules.portfolio.extractPositions(pData);
+            
+            // Extract Mirrors using Rules (assumes rule exists, or manual extraction if needed)
+            // If rules.portfolio doesn't have extractMirrors, we can look at pData.AggregatedMirrors directly
+            const mirrors = pData.AggregatedMirrors || []; 
+
+            let totalInv = 0, totalProf = 0;
+            const secExp = {}, assetExp = {}, secProfits = {};
+
+            // A. Process Direct Positions
+            positions.forEach(pos => {
+                const id = rules.portfolio.getInstrumentId(pos);
+                const inv = rules.portfolio.getInvested(pos);
+                const profPct = rules.portfolio.getNetProfit(pos);
+                const profVal = inv * (profPct / 100);
+                
+                totalInv += inv; 
+                totalProf += profVal;
+                
+                const ticker = resolveTicker(id); 
+                const sector = resolveSector(id);
+                
+                secExp[sector] = (secExp[sector] || 0) + inv;
+                assetExp[ticker] = (assetExp[ticker] || 0) + inv;
+
+                if (!secProfits[sector]) secProfits[sector] = { profit: 0, weight: 0 };
+                secProfits[sector].profit += profVal; 
+                secProfits[sector].weight += inv;
+            });
+
+            // B. Process Copied PIs (Mirrors)
+            // * We iterate the USER'S mirrors, then lookup the PI data.
+            // * This avoids fetching all PIs as primary data.
+            mirrors.forEach(m => {
+                const cid = String(m.ParentCID || m.CID); // Adjust based on exact schema
+                const inv = m.Invested || m.Amount || 0;
+                const profPct = m.NetProfit || 0;
+                
+                totalInv += inv; 
+                totalProf += (inv * (profPct / 100));
+
+                // LOOKUP: Get PI details from the global reference data
+                const rank = globalRankings.find(r => String(r.pi_id || r.CustomerId) === cid);
+                
+                result.copiedPIs.data.push({
+                    cid,
+                    username: resolveUsername(cid),
+                    invested: inv,
+                    netProfit: m.NetProfit || 0,
+                    value: m.Value || 0,
+                    pendingClosure: m.PendingForClosure === true,
+                    isRanked: !!rank,
+                    // Enrich with Reference Data
+                    rankData: rank ? { 
+                        riskScore: rules.rankings.getRiskScore(rank), 
+                        gain: rules.rankings.getTotalGain(rank),
+                        aum: rules.rankings.getAUMTier(rank)
+                    } : null
+                });
+            });
+
+            // Summary Stats
+            result.portfolioSummary = {
+                totalInvested: Number(totalInv.toFixed(2)),
+                totalProfit: Number(totalProf.toFixed(2)),
+                profitPercent: totalInv > 0 ? Number(((totalProf / totalInv) * 100).toFixed(2)) : 0
+            };
+
+            // Calculate Best/Worst Sectors
+            let bestS = null, worstS = null, bestP = -Infinity, worstP = Infinity;
+            Object.entries(secProfits).forEach(([sec, d]) => {
+                if (d.weight <= 0) return;
+                const p = (d.profit / d.weight) * 100;
+                if (p > bestP) { bestP = p; bestS = sec; }
+                if (p < worstP) { worstP = p; worstS = sec; }
+            });
+            result.sectorPerformance = { 
+                bestSector: bestS, 
+                worstSector: worstS, 
+                bestSectorProfit: bestS ? Number(bestP.toFixed(2)) : 0,
+                worstSectorProfit: worstS ? Number(worstP.toFixed(2)) : 0
+            };
+            
+            // Exposure Charts
+            if (totalInv > 0) {
+                Object.keys(secExp).forEach(k => result.sectorExposure.data[k] = Number(((secExp[k]/totalInv)*100).toFixed(2)));
+                Object.entries(assetExp)
+                    .sort((a,b) => b[1] - a[1])
+                    .slice(0, 10)
+                    .forEach(([k,v]) => result.assetExposure.data[k] = Number(((v/totalInv)*100).toFixed(2)));
+            }
+        }
+
+        this.setResult(entityId, result);
+    }
+}
+
+module.exports = SignedInUserProfileMetrics;