bulltrackers-module 1.0.768 → 1.0.770

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;