bulltrackers-module 1.0.766 → 1.0.769

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

@@ -1,234 +1,162 @@
 /**
- * @fileoverview Popular Investor Profile Metrics - v2 Adaptation
- * 
- * This is the most complex computation, migrated to demonstrate the v2 framework.
- * 
- * Original v1 features preserved:
- * - Profile page metrics for Popular Investors
- * - Social engagement (7-day accumulation)
- * - Profitable positions from trade history
- * - Sector/asset exposure analysis
- * - Rankings, ratings, page views, watchlist data
- * - Alert history with 7-day metrics
- * - Exposure over time (historical continuity)
- * 
- * v2 Changes:
- * - Uses `getConfig()` instead of `getMetadata()` + `getDependencies()`
- * - Directly references BigQuery table names in `requires`
- * - Data accessed via `context.data['table_name']`
- * - Simplified series handling through lookback configuration
+ * @fileoverview Popular Investor Profile Metrics (V3.7 DATA ACCESS FIX)
+ * * FIX: Correctly accesses DataFetcher response maps.
+ * (Previously failed because it treated the Map-of-Arrays as a flat list of rows).
+ * * FIX: 'getEntityRows' helper now handles both Map lookups and flat fallbacks.
  */
-
 const { Computation } = require('../framework');
 
 class PopularInvestorProfileMetrics extends Computation {
-    
-    /**
-     * v2 Configuration - Single source of truth for computation requirements.
-     */
+
     static getConfig() {
         return {
             name: 'PopularInvestorProfileMetrics',
+            type: 'per-entity',
             category: 'popular_investor',
+            isHistorical: true,
             
-            // Direct table references with lookback configuration
             requires: {
-                // Core data - mandatory for execution
+                // --- Core Data ---
                 'portfolio_snapshots': {
-                    lookback: 0,
+                    lookback: 30,
                     mandatory: true,
-                    filter: { user_type: 'POPULAR_INVESTOR' }
+                    fields: ['user_id', 'portfolio_data', 'date']
                 },
                 'trade_history_snapshots': {
-                    lookback: 0,
-                    mandatory: true,
-                    filter: { user_type: 'POPULAR_INVESTOR' }
+                    lookback: 30,
+                    mandatory: false,
+                    fields: ['user_id', 'history_data', 'date']
+                },
+                'social_post_snapshots': {
+                    lookback: 7,
+                    mandatory: false,
+                    fields: ['user_id', 'posts_data', 'date']
                 },
                 
-                // Rankings - for AUM, risk score, gain, copiers
+                // --- Reference ---
+                'pi_master_list': {
+                    lookback: 1,
+                    mandatory: false,
+                    fields: ['cid', 'username']
+                },
+
+                // --- KPI Data ---
                 'pi_rankings': {
-                    lookback: 7,  // Self-healing: use latest available
-                    mandatory: false
+                    lookback: 7,
+                    mandatory: false,
+                    fields: ['pi_id', 'rankings_data', 'username', 'date']
                 },
-                
-                // Ratings - 30-day average
                 'pi_ratings': {
                     lookback: 30,
-                    mandatory: false
+                    mandatory: false,
+                    fields: ['pi_id', 'reviews', 'ratings_by_user', 'average_rating', 'total_ratings', 'date']
                 },
-                
-                // Page views - 7-day accumulation
                 'pi_page_views': {
-                    lookback: 7,
-                    mandatory: false
+                    lookback: 14,
+                    mandatory: false,
+                    fields: ['pi_id', 'views_by_user', 'total_views', 'unique_viewers', 'date']
                 },
-                
-                // Watchlist - 30-day trend
                 'watchlist_membership': {
                     lookback: 30,
-                    mandatory: false
+                    mandatory: false,
+                    fields: ['pi_id', 'total_users', 'date']
                 },
-                
-                // Alert history - 7-day metrics
                 'pi_alert_history': {
-                    lookback: 7,
-                    mandatory: false
-                },
-                
-                // Social posts - 7-day engagement
-                'social_post_snapshots': {
                     lookback: 7,
                     mandatory: false,
-                    filter: { user_type: 'POPULAR_INVESTOR' }
+                    fields: ['pi_id', 'alert_type', 'trigger_count', 'metadata', 'date']
                 },
-                
-                // Ticker mappings for display names
-                'ticker_mappings': {
-                    lookback: 0,  // Not date-partitioned
-                    mandatory: false
+
+                // --- Mappings ---
+                'ticker_mappings': { mandatory: false },
+                'sector_mappings': { mandatory: false }
+            },
+
+            storage: {
+                bigquery: true,
+                firestore: {
+                    enabled: true,
+                    path: 'profiles/{entityId}/metrics/{date}',
+                    merge: true
                 }
             },
-            
-            // No computation dependencies
-            dependencies: [],
-            
-            // Runs per user
-            type: 'per-entity',
-            
-            // Needs previous day's result for exposure over time
-            isHistorical: true,
-            
-            // Output config
-            ttlDays: 60
-        };
-    }
-    
-    static getSchema() {
-        return {
-            type: 'object',
-            properties: {
-                username: { type: 'string' },
-                socialEngagement: { type: 'object' },
-                profitablePositions: { type: 'object' },
-                topWinningPositions: { type: 'object' },
-                sectorPerformance: { type: 'object' },
-                sectorExposure: { type: 'object' },
-                assetExposure: { type: 'object' },
-                portfolioSummary: { type: 'object' },
-                rankingsData: { type: 'object' },
-                ratingsData: { type: 'object' },
-                pageViewsData: { type: 'object' },
-                watchlistData: { type: 'object' },
-                alertHistoryData: { type: 'object' },
-                sectorExposureOverTime: { type: 'object' },
-                assetExposureOverTime: { type: 'object' },
-                alertMetrics: { type: 'object' }
-            }
+
+            userType: 'POPULAR_INVESTOR'
         };
     }
-    
-    static getWeight() {
-        return 10.0;  // Complex per-user computation
-    }
-    
-    /**
-     * Process a single user's profile metrics.
-     */
+
     async process(context) {
-        const { date, entityId: userId, data, previousResult } = context;
-        
-        // Extract data from context
-        const portfolio = data['portfolio_snapshots'];
-        const historyDoc = data['trade_history_snapshots'];
-        const rankings = data['pi_rankings'];
-        const ratings = data['pi_ratings'];
-        const pageViews = data['pi_page_views'];
-        const watchlist = data['watchlist_membership'];
-        const alerts = data['pi_alert_history'];
-        const social = data['social_post_snapshots'];
-        const tickerMappings = data['ticker_mappings'];
-        
-        // Build instrument mappings
-        const mappings = this._buildMappings(tickerMappings);
-        
-        // Initialize result structure
-        const result = this._initializeResult();
-        
-        // ==========================================================================================
-        // 1. Social Engagement (7-Day Accumulation + Chart)
-        // ==========================================================================================
-        this._processSocialEngagement(result, social, userId);
-        
-        // ==========================================================================================
-        // 2. Profitable Positions (From Trade History)
-        // ==========================================================================================
-        this._processProfitablePositions(result, historyDoc);
-        
-        // ==========================================================================================
-        // 3. Top Winning Positions
-        // ==========================================================================================
-        this._processTopWinningPositions(result, portfolio, historyDoc, mappings);
-        
-        // ==========================================================================================
-        // 4. Sector Performance
-        // ==========================================================================================
-        this._processSectorPerformance(result, portfolio, mappings);
-        
-        // ==========================================================================================
-        // 5. & 6. Exposure & Portfolio Summary
-        // ==========================================================================================
-        this._processExposureAndSummary(result, portfolio, mappings);
-        
+        const { data, entityId, date, rules } = context;
+
         // ==========================================================================================
-        // 7. Rankings Data
+        // 0. PREPARATION & HELPER FUNCTIONS
         // ==========================================================================================
-        this._processRankingsData(result, rankings, userId);
         
-        // ==========================================================================================
-        // 8. Username (from rankings)
-        // ==========================================================================================
-        if (rankings) {
-            const rankEntry = this._findLatestRankEntry(rankings, userId);
-            if (rankEntry) {
-                result.username = rankEntry.UserName || rankEntry.username || null;
+        const toDateStr = (d) => {
+            if (!d) return "";
+            if (d.value) return d.value;
+            return d instanceof Date ? d.toISOString().slice(0, 10) : String(d);
+        };
+
+        const toArray = (input) => {
+            if (!input) return [];
+            if (Array.isArray(input)) return input;
+            return Object.values(input);
+        };
+
+        // FIX: Robustly retrieve rows for THIS entity from any table structure
+        const getEntityRows = (dataset) => {
+            if (!dataset) return [];
+
+            // Case A: Map { "312723": [...] } (Standard DataFetcher behavior with entityField)
+            if (dataset[entityId]) {
+                const val = dataset[entityId];
+                return Array.isArray(val) ? val : [val];
             }
-        }
-        
-        // ==========================================================================================
-        // 9. Ratings Data (30-Day Average + Trend)
-        // ==========================================================================================
-        this._processRatingsData(result, ratings, userId);
-        
-        // ==========================================================================================
-        // 10. Page Views Data (7-Day Sum + Daily Chart)
-        // ==========================================================================================
-        this._processPageViewsData(result, pageViews, userId);
-        
-        // ==========================================================================================
-        // 11. Watchlist Data (Latest Snapshot + 30-Day Trend)
-        // ==========================================================================================
-        this._processWatchlistData(result, watchlist, userId);
-        
-        // ==========================================================================================
-        // 12. Alert History (Accumulation + Metrics)
-        // ==========================================================================================
-        this._processAlertHistory(result, alerts, userId);
-        
-        // ==========================================================================================
-        // 13. Exposure Over Time (Requires Previous State)
-        // ==========================================================================================
-        this._processExposureOverTime(result, previousResult, date);
+
+            // Case B: Flat Array [ row, row ] (Fallback for tables without entityField config)
+            if (Array.isArray(dataset)) {
+                // Check if the array actually contains rows or nested arrays (from bad Object.values)
+                if (dataset.length > 0 && Array.isArray(dataset[0])) {
+                    // Flatten if we somehow got [[rows], [rows]]
+                    return dataset.flat().filter(r => String(r.pi_id || r.user_id || r.cid) === String(entityId));
+                }
+                return dataset.filter(r => String(r.pi_id || r.user_id || r.cid) === String(entityId));
+            }
+
+            return [];
+        };
+
+        const sortAsc = (input) => {
+            const arr = toArray(input);
+            return arr.sort((a, b) => {
+                const dA = toDateStr(a.date);
+                const dB = toDateStr(b.date);
+                if (!dA) return 1;
+                if (!dB) return -1;
+                return dA.localeCompare(dB);
+            });
+        };
         
-        // Store result
-        this.setResult(userId, result);
-    }
-    
-    // =========================================================================
-    // PRIVATE METHODS
-    // =========================================================================
-    
-    _initializeResult() {
-        return {
+        // Mappings (Global, not per-entity)
+        const tickerMap = new Map();
+        toArray(data['ticker_mappings']).forEach(row => {
+            if (row.instrument_id && row.ticker) tickerMap.set(Number(row.instrument_id), row.ticker.toUpperCase());
+        });
+
+        const sectorMap = new Map();
+        toArray(data['sector_mappings']).forEach(row => {
+            if (row.symbol && row.sector) sectorMap.set(row.symbol.toUpperCase(), row.sector);
+        });
+
+        const resolveTicker = (id) => tickerMap.get(Number(id)) || `ID:${id}`;
+        const resolveSector = (id) => {
+            const ticker = tickerMap.get(Number(id));
+            return ticker ? (sectorMap.get(ticker) || 'Unknown') : 'Unknown';
+        };
+
+        // Initialize Result
+        const result = {
             username: null,
             socialEngagement: { chartType: 'line', data: [] },
             profitablePositions: { chartType: 'bar', data: [] },
@@ -238,483 +166,268 @@ class PopularInvestorProfileMetrics extends Computation {
             assetExposure: { chartType: 'pie', data: {} },
             portfolioSummary: { totalInvested: 0, totalProfit: 0, profitPercent: 0 },
             rankingsData: { aum: 0, riskScore: 0, gain: 0, copiers: 0, winRatio: 0, trades: 0 },
-            ratingsData: { 
-                averageRating: 0,
-                totalRatings: 0,
-                ratingsOverTime: { chartType: 'line', data: [] } 
-            },
-            pageViewsData: { 
-                totalViews: 0,
-                uniqueViewers: 0,
-                viewsOverTime: { chartType: 'bar', data: [] } 
-            },
-            watchlistData: { 
-                totalUsers: 0,
-                publicWatchlistCount: 0, 
-                privateWatchlistCount: 0,
-                watchlistOverTime: { chartType: 'line', data: [] } 
-            },
+            ratingsData: { averageRating: 0, totalRatings: 0, ratingsOverTime: { chartType: 'line', data: [] } },
+            pageViewsData: { totalViews: 0, uniqueViewers: 0, viewsOverTime: { chartType: 'bar', data: [] } },
+            watchlistData: { totalUsers: 0, watchlistOverTime: { chartType: 'line', data: [] } },
             alertHistoryData: { triggeredAlerts: [], alertCountsOverTime: { chartType: 'bar', data: [] } },
             sectorExposureOverTime: { chartType: 'line', data: [] },
             assetExposureOverTime: { chartType: 'line', data: [] },
             alertMetrics: { totalLast7Days: 0, breakdown: {} }
         };
-    }
-    
-    _buildMappings(tickerMappings) {
-        const mappings = {
-            instrumentToTicker: {},
-            instrumentToSector: {}
-        };
-        
-        if (!tickerMappings) return mappings;
+
+        // ==========================================================================================
+        // 1. DATA RETRIEVAL (Using Fixed 'getEntityRows')
+        // ==========================================================================================
         
-        // Handle different data structures
-        if (Array.isArray(tickerMappings)) {
-            for (const row of tickerMappings) {
-                const id = row.instrument_id || row.instrumentId;
-                if (id) {
-                    mappings.instrumentToTicker[String(id)] = row.ticker || row.symbol || `ID${id}`;
-                    if (row.sector) mappings.instrumentToSector[String(id)] = row.sector;
-                }
-            }
-        } else if (typeof tickerMappings === 'object') {
-            for (const [id, data] of Object.entries(tickerMappings)) {
-                if (typeof data === 'string') {
-                    mappings.instrumentToTicker[id] = data;
-                } else if (typeof data === 'object') {
-                    mappings.instrumentToTicker[id] = data.ticker || data.symbol || `ID${id}`;
-                    if (data.sector) mappings.instrumentToSector[id] = data.sector;
-                }
+        // These tables are keyed by 'user_id' (same as entityId) or 'pi_id' (same value)
+        const portfolios = sortAsc(getEntityRows(data['portfolio_snapshots']));
+        const historyData = sortAsc(getEntityRows(data['trade_history_snapshots']));
+        const socialData = sortAsc(getEntityRows(data['social_post_snapshots']));
+        const rankings = sortAsc(getEntityRows(data['pi_rankings']));
+        const ratings = sortAsc(getEntityRows(data['pi_ratings']));
+        const pageViews = sortAsc(getEntityRows(data['pi_page_views']));
+        const watchlists = sortAsc(getEntityRows(data['watchlist_membership']));
+        const alerts = sortAsc(getEntityRows(data['pi_alert_history']));
+        const masterList = getEntityRows(data['pi_master_list']); 
+
+        const currentPortfolio = portfolios.length > 0 ? portfolios[portfolios.length - 1] : null;
+        const currentRanking = rankings.length > 0 ? rankings[rankings.length - 1] : null;
+
+        // ==========================================================================================
+        // 2. USERNAME
+        // ==========================================================================================
+        if (masterList.length > 0 && masterList[0].username) {
+            result.username = masterList[0].username;
+        } else if (currentRanking) {
+            result.username = currentRanking.username || currentRanking.UserName || null;
+            if (!result.username) {
+                const rData = rules.rankings.extractRankingsData(currentRanking);
+                result.username = rData?.UserName || null;
             }
         }
-        
-        return mappings;
-    }
-    
-    _processSocialEngagement(result, social, userId) {
-        if (!social) return;
-        
-        // social is date-keyed: { "2026-01-24": [...], "2026-01-23": [...] }
-        const dates = Object.keys(social).sort();
-        
-        for (const dateStr of dates) {
-            const dailyData = social[dateStr];
-            if (!dailyData) continue;
-            
-            // Find user's posts
-            let userPosts = [];
-            if (Array.isArray(dailyData)) {
-                userPosts = dailyData.filter(p => String(p.user_id || p.userId) === String(userId));
-            } else if (dailyData[userId]) {
-                userPosts = Array.isArray(dailyData[userId]) ? dailyData[userId] : [dailyData[userId]];
-            }
-            
-            if (userPosts.length > 0) {
-                let likes = 0, comments = 0;
-                for (const post of userPosts) {
-                    likes += (post.LikesCount || post.likes || 0);
-                    comments += (post.CommentsCount || post.comments || 0);
-                }
-                result.socialEngagement.data.push({ date: dateStr, likes, comments });
+
+        // ==========================================================================================
+        // 3. RANKINGS
+        // ==========================================================================================
+        if (currentRanking) {
+            const rData = rules.rankings.extractRankingsData(currentRanking);
+            if (rData) {
+                result.rankingsData = {
+                    aum: rules.rankings.getAUMTier(rData),
+                    riskScore: rules.rankings.getRiskScore(rData),
+                    gain: rules.rankings.getTotalGain(rData),
+                    copiers: rules.rankings.getCopiers(rData),
+                    winRatio: rules.rankings.getWinRatio(rData),
+                    trades: rules.rankings.getTotalTrades(rData)
+                };
             }
         }
-    }
-    
-    _processProfitablePositions(result, historyDoc) {
-        if (!historyDoc) return;
-        
-        const trades = this._extractTrades(historyDoc);
+
+        // ==========================================================================================
+        // 4. TRADES
+        // ==========================================================================================
         const profitableMap = new Map();
-        
-        for (const trade of trades) {
-            const closeDateTime = trade.CloseDateTime || trade.closeDateTime || trade.close_date;
-            if (!closeDateTime) continue;
-            
-            const closeDate = new Date(closeDateTime);
-            if (isNaN(closeDate.getTime())) continue;
-            
-            const dateKey = closeDate.toISOString().split('T')[0];
-            const existing = profitableMap.get(dateKey) || { date: dateKey, profitableCount: 0, totalCount: 0 };
-            existing.totalCount++;
-            
-            const netProfit = trade.NetProfit || trade.netProfit || trade.net_profit || 0;
-            if (netProfit > 0) existing.profitableCount++;
-            
-            profitableMap.set(dateKey, existing);
-        }
-        
+        const allClosedTrades = [];
+
+        historyData.forEach(dayDoc => {
+            const trades = rules.trades.extractTrades(dayDoc);
+            trades.forEach(trade => {
+                const closeDate = rules.trades.getCloseDate(trade);
+                if (!closeDate) return;
+                
+                const dKey = closeDate.toISOString().split('T')[0];
+                const profit = rules.trades.getNetProfit(trade);
+                
+                const entry = profitableMap.get(dKey) || { date: dKey, profitableCount: 0, totalCount: 0 };
+                entry.totalCount++;
+                if (profit > 0) entry.profitableCount++;
+                profitableMap.set(dKey, entry);
+
+                allClosedTrades.push({
+                    ticker: resolveTicker(rules.trades.getInstrumentId(trade)),
+                    closeDate: closeDate,
+                    netProfit: profit,
+                    direction: rules.trades.isBuy(trade) ? 'Buy' : 'Sell'
+                });
+            });
+        });
+
         result.profitablePositions.data = Array.from(profitableMap.values())
             .sort((a, b) => a.date.localeCompare(b.date))
             .slice(-30);
-    }
-    
-    _processTopWinningPositions(result, portfolio, historyDoc, mappings) {
-        const topWinning = [];
-        
-        // From current portfolio
-        if (portfolio) {
-            const positions = this._extractPositions(portfolio);
-            for (const pos of positions) {
-                const instrumentId = pos.InstrumentID || pos.instrumentId || pos.instrument_id;
-                const netProfit = pos.NetProfit || pos.netProfit || pos.net_profit || 0;
-                const invested = pos.Amount || pos.amount || pos.invested || 0;
-                const value = pos.Value || pos.value || invested + netProfit;
-                
-                if (netProfit > 0 && instrumentId) {
-                    const ticker = mappings.instrumentToTicker[String(instrumentId)] || `ID${instrumentId}`;
-                    topWinning.push({ instrumentId, ticker, netProfit, invested, value, isCurrent: true, closeDate: null });
-                }
-            }
-        }
-        
-        // From trade history
-        if (historyDoc) {
-            const trades = this._extractTrades(historyDoc);
-            for (const trade of trades) {
-                const netProfit = trade.NetProfit || trade.netProfit || trade.net_profit || 0;
-                const instrumentId = trade.InstrumentID || trade.instrumentId || trade.instrument_id;
-                
-                if (netProfit > 0 && instrumentId) {
-                    const ticker = mappings.instrumentToTicker[String(instrumentId)] || `ID${instrumentId}`;
-                    const closeDate = trade.CloseDateTime || trade.closeDateTime || trade.close_date || null;
-                    topWinning.push({ instrumentId, ticker, netProfit, invested: 0, value: 0, isCurrent: false, closeDate });
-                }
-            }
-        }
-        
-        result.topWinningPositions.data = topWinning
+
+        result.topWinningPositions.data = allClosedTrades
             .sort((a, b) => b.netProfit - a.netProfit)
-            .slice(0, 20);
-    }
-    
-    _processSectorPerformance(result, portfolio, mappings) {
-        if (!portfolio || !mappings.instrumentToSector || Object.keys(mappings.instrumentToSector).length === 0) {
-            return;
-        }
-        
-        const positions = this._extractPositions(portfolio);
-        const sectorProfits = new Map();
-        
-        for (const pos of positions) {
-            const instrumentId = pos.InstrumentID || pos.instrumentId || pos.instrument_id;
-            const netProfit = pos.NetProfit || pos.netProfit || pos.net_profit || 0;
-            const invested = pos.Amount || pos.amount || pos.invested || 0;
-            
-            if (instrumentId && invested > 0) {
-                const sector = mappings.instrumentToSector[String(instrumentId)] || 'Unknown';
-                const weightedProfit = invested * (netProfit / 100);
-                const existing = sectorProfits.get(sector) || { totalProfit: 0, totalInvested: 0 };
-                existing.totalProfit += weightedProfit;
-                existing.totalInvested += invested;
-                sectorProfits.set(sector, existing);
-            }
-        }
-        
-        let bestSector = null, worstSector = null;
-        let bestProfit = -Infinity, worstProfit = Infinity;
-        
-        for (const [sector, data] of sectorProfits.entries()) {
-            const profitPercent = data.totalInvested > 0 ? (data.totalProfit / data.totalInvested) * 100 : 0;
-            if (profitPercent > bestProfit) { bestProfit = profitPercent; bestSector = sector; }
-            if (profitPercent < worstProfit) { worstProfit = profitPercent; worstSector = sector; }
-        }
-        
-        result.sectorPerformance = {
-            bestSector,
-            worstSector,
-            bestSectorProfit: bestProfit !== -Infinity ? bestProfit : 0,
-            worstSectorProfit: worstProfit !== Infinity ? worstProfit : 0
-        };
-    }
-    
-    _processExposureAndSummary(result, portfolio, mappings) {
-        if (!portfolio) return;
-        
-        const positions = this._extractPositions(portfolio);
-        const sectorMap = {};
-        const assetMap = {};
-        let total = 0, totalInvested = 0, totalProfit = 0;
-        
-        for (const pos of positions) {
-            const instrumentId = pos.InstrumentID || pos.instrumentId || pos.instrument_id;
-            const invested = pos.Amount || pos.amount || pos.invested || 0;
-            const netProfit = pos.NetProfit || pos.netProfit || pos.net_profit || 0;
-            const value = pos.Value || pos.value || invested + netProfit;
-            
-            total += value;
-            totalInvested += invested;
-            totalProfit += invested * (netProfit / 100);
-            
-            const sector = mappings.instrumentToSector[String(instrumentId)] || 'Unknown';
-            sectorMap[sector] = (sectorMap[sector] || 0) + value;
+            .slice(0, 5)
+            .map(t => ({
+                ticker: t.ticker,
+                profit: Number(t.netProfit.toFixed(2)),
+                date: t.closeDate.toISOString().slice(0, 10),
+                direction: t.direction
+            }));
+
+        // ==========================================================================================
+        // 5. PORTFOLIO & SECTOR EXPOSURE
+        // ==========================================================================================
+        if (currentPortfolio) {
+            const pData = rules.portfolio.extractPortfolioData(currentPortfolio);
+            const positions = rules.portfolio.extractPositions(pData);
             
-            const ticker = mappings.instrumentToTicker[String(instrumentId)] || `ID${instrumentId}`;
-            assetMap[ticker] = (assetMap[ticker] || 0) + value;
-        }
-        
-        if (total > 0) {
-            Object.keys(sectorMap).forEach(k => {
-                result.sectorExposure.data[k] = Number(((sectorMap[k] / total) * 100).toFixed(2));
+            let totalInvested = 0, totalProfit = 0;
+            const secMap = {};
+            const assetMap = {};
+            const sectorProfits = {};
+
+            positions.forEach(pos => {
+                const id = rules.portfolio.getInstrumentId(pos);
+                const invested = rules.portfolio.getInvested(pos); 
+                const netProfit = rules.portfolio.getNetProfit(pos);
+                
+                totalInvested += invested;
+                totalProfit += (invested * (netProfit / 100));
+                
+                const ticker = resolveTicker(id);
+                const sector = resolveSector(id);
+
+                assetMap[ticker] = (assetMap[ticker] || 0) + invested;
+                secMap[sector] = (secMap[sector] || 0) + invested;
+
+                if (!sectorProfits[sector]) sectorProfits[sector] = { profit: 0, weight: 0 };
+                sectorProfits[sector].profit += (invested * (netProfit / 100));
+                sectorProfits[sector].weight += invested;
             });
-            
+
+            result.portfolioSummary = {
+                totalInvested: Number(totalInvested.toFixed(2)),
+                totalProfit: Number(totalProfit.toFixed(2)),
+                profitPercent: totalInvested > 0 ? Number(((totalProfit / totalInvested) * 100).toFixed(2)) : 0
+            };
+
             Object.entries(assetMap)
-                .sort(([, a], [, b]) => b - a)
+                .sort(([,a], [,b]) => b - a)
                 .slice(0, 10)
-                .forEach(([k, v]) => {
-                    result.assetExposure.data[k] = Number(((v / total) * 100).toFixed(2));
-                });
-        }
-        
-        result.portfolioSummary = {
-            totalInvested: Number(totalInvested.toFixed(2)),
-            totalProfit: Number(totalProfit.toFixed(2)),
-            profitPercent: totalInvested > 0 ? Number(((totalProfit / totalInvested) * 100).toFixed(2)) : 0
-        };
-    }
-    
-    _processRankingsData(result, rankings, userId) {
-        const rankEntry = this._findLatestRankEntry(rankings, userId);
-        if (!rankEntry) return;
-        
-        result.rankingsData = {
-            aum: rankEntry.AUMTierDesc || rankEntry.Aum || rankEntry.aum || 0,
-            riskScore: rankEntry.RiskScore || rankEntry.riskScore || 0,
-            gain: rankEntry.Gain || rankEntry.gain || 0,
-            copiers: rankEntry.Copiers || rankEntry.copiers || 0,
-            winRatio: rankEntry.WinRatio || rankEntry.winRatio || 0,
-            trades: rankEntry.Trades || rankEntry.trades || 0
-        };
-    }
-    
-    _findLatestRankEntry(rankings, userId) {
-        if (!rankings) return null;
-        
-        // rankings is date-keyed: { "2026-01-24": [...], ... }
-        if (typeof rankings === 'object' && !Array.isArray(rankings)) {
-            const dates = Object.keys(rankings).sort().reverse();
-            for (const dateStr of dates) {
-                const dayRankings = rankings[dateStr];
-                if (Array.isArray(dayRankings)) {
-                    const entry = dayRankings.find(r => 
-                        String(r.CustomerId || r.pi_id || r.userId) === String(userId)
-                    );
-                    if (entry) return entry;
-                }
-            }
-        }
-        
-        // Direct array
-        if (Array.isArray(rankings)) {
-            return rankings.find(r => 
-                String(r.CustomerId || r.pi_id || r.userId) === String(userId)
-            );
-        }
-        
-        return null;
-    }
-    
-    _processRatingsData(result, ratings, userId) {
-        if (!ratings) return;
-        
-        const dates = Object.keys(ratings).sort();
-        let sumRatings = 0, countRatings = 0;
-        
-        for (const dateStr of dates) {
-            const dayRatings = ratings[dateStr];
-            const userRating = this._findUserData(dayRatings, userId);
-            
-            if (userRating) {
-                const avg = userRating.average_rating || userRating.avgRating || 0;
-                const total = userRating.total_ratings || userRating.totalRatings || 0;
-                
-                result.ratingsData.ratingsOverTime.data.push({
-                    date: dateStr,
-                    rating: avg,
-                    count: total
-                });
-                
-                if (avg > 0) {
-                    sumRatings += avg;
-                    countRatings++;
-                }
-                
-                result.ratingsData.totalRatings = total;
-            }
-        }
-        
-        if (countRatings > 0) {
-            result.ratingsData.averageRating = Number((sumRatings / countRatings).toFixed(2));
-        }
-    }
-    
-    _processPageViewsData(result, pageViews, userId) {
-        if (!pageViews) return;
-        
-        const dates = Object.keys(pageViews).sort();
-        
-        for (const dateStr of dates) {
-            const dayViews = pageViews[dateStr];
-            const userViews = this._findUserData(dayViews, userId);
-            
-            if (userViews) {
-                const views = userViews.total_views || userViews.totalViews || 0;
-                const uniques = userViews.unique_viewers || userViews.uniqueViewers || 0;
-                
-                result.pageViewsData.viewsOverTime.data.push({
-                    date: dateStr,
-                    views: views
-                });
-                
-                result.pageViewsData.totalViews += views;
-                result.pageViewsData.uniqueViewers = uniques;
-            }
+                .forEach(([k, v]) => result.assetExposure.data[k] = Number(v.toFixed(2)));
+
+            Object.entries(secMap)
+                .forEach(([k, v]) => result.sectorExposure.data[k] = Number(v.toFixed(2)));
+
+            let bestS = null, worstS = null, bestP = -Infinity, worstP = Infinity;
+            Object.entries(sectorProfits).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, bestSectorProfit: bestS ? Number(bestP.toFixed(2)) : 0,
+                worstSector: worstS, worstSectorProfit: worstS ? Number(worstP.toFixed(2)) : 0
+            };
         }
-    }
-    
-    _processWatchlistData(result, watchlist, userId) {
-        if (!watchlist) return;
-        
-        const dates = Object.keys(watchlist).sort();
-        
-        for (const dateStr of dates) {
-            const dayWatchlist = watchlist[dateStr];
-            const userWatchlist = this._findUserData(dayWatchlist, userId);
+
+        // ==========================================================================================
+        // 6. EXPOSURE OVER TIME
+        // ==========================================================================================
+        portfolios.forEach(entry => {
+            const pData = rules.portfolio.extractPortfolioData(entry);
+            const positions = rules.portfolio.extractPositions(pData);
+            const dateStr = toDateStr(entry.date);
             
-            if (userWatchlist) {
-                const total = userWatchlist.total_users || userWatchlist.totalUsers || 0;
-                
-                result.watchlistData.watchlistOverTime.data.push({
-                    date: dateStr,
-                    count: total
-                });
-                
-                result.watchlistData.totalUsers = total;
-                result.watchlistData.publicWatchlistCount = userWatchlist.public_watchlist_count || userWatchlist.publicCount || 0;
-                result.watchlistData.privateWatchlistCount = userWatchlist.private_watchlist_count || userWatchlist.privateCount || 0;
-            }
-        }
-    }
-    
-    _processAlertHistory(result, alerts, userId) {
-        if (!alerts) return;
-        
-        const dates = Object.keys(alerts).sort();
-        let totalAlertsLast7Days = 0;
-        const alertBreakdown = {};
-        
-        for (const dateStr of dates) {
-            const dayAlerts = alerts[dateStr];
-            const userAlerts = this._findUserData(dayAlerts, userId);
+            const dailySec = {};
+            const dailyAsset = {};
             
-            if (userAlerts && typeof userAlerts === 'object') {
-                let dayCount = 0;
-                
-                for (const [alertType, data] of Object.entries(userAlerts)) {
-                    if (alertType.toLowerCase().includes('test')) continue;
-                    
-                    const count = data.count || data.trigger_count || 1;
-                    totalAlertsLast7Days += count;
-                    dayCount += count;
-                    
-                    alertBreakdown[alertType] = (alertBreakdown[alertType] || 0) + count;
-                }
-                
-                if (dayCount > 0) {
-                    result.alertHistoryData.alertCountsOverTime.data.push({
-                        date: dateStr,
-                        count: dayCount
-                    });
-                }
-            }
-        }
-        
-        result.alertMetrics.totalLast7Days = totalAlertsLast7Days;
-        result.alertMetrics.breakdown = alertBreakdown;
-        
-        // Sort chart
-        result.alertHistoryData.alertCountsOverTime.data.sort((a, b) => a.date.localeCompare(b.date));
-    }
-    
-    _processExposureOverTime(result, previousResult, currentDate) {
-        // Restore from previous day
-        if (previousResult) {
-            if (previousResult.sectorExposureOverTime?.data) {
-                result.sectorExposureOverTime.data = [...previousResult.sectorExposureOverTime.data];
+            positions.forEach(pos => {
+                const id = rules.portfolio.getInstrumentId(pos);
+                const invested = rules.portfolio.getInvested(pos);
+                const ticker = resolveTicker(id);
+                const sector = resolveSector(id);
+                dailySec[sector] = (dailySec[sector] || 0) + invested;
+                dailyAsset[ticker] = (dailyAsset[ticker] || 0) + invested;
+            });
+
+            result.sectorExposureOverTime.data.push({ date: dateStr, sectors: dailySec });
+            result.assetExposureOverTime.data.push({ date: dateStr, assets: dailyAsset });
+        });
+
+        // ==========================================================================================
+        // 7. SOCIAL, RATINGS, PAGEVIEWS, WATCHLIST
+        // ==========================================================================================
+        const sevenDaysAgo = new Date(new Date(date).setDate(new Date(date).getDate() - 7)).toISOString().slice(0,10);
+        
+        socialData.filter(d => toDateStr(d.date) >= sevenDaysAgo).forEach(day => {
+            const posts = rules.social.extractPosts(day);
+            let likes = 0, comments = 0;
+            posts.forEach(p => {
+                likes += (rules.social.getPostLikes(p) || 0);
+                comments += (rules.social.getPostComments(p) || 0);
+            });
+            result.socialEngagement.data.push({ date: toDateStr(day.date), likes, comments });
+        });
+
+        ratings.forEach(r => {
+            const val = Number(r.average_rating || 0);
+            const count = Number(r.total_ratings || 0);
+            const d = toDateStr(r.date);
+            if (d) {
+                result.ratingsData.ratingsOverTime.data.push({ date: d, rating: val, count });
+                result.ratingsData.totalRatings = count;
+                result.ratingsData.averageRating = val;
             }
-            if (previousResult.assetExposureOverTime?.data) {
-                result.assetExposureOverTime.data = [...previousResult.assetExposureOverTime.data];
+        });
+
+        pageViews.forEach(p => {
+            const views = Number(p.total_views || 0);
+            const d = toDateStr(p.date);
+            if (d) {
+                result.pageViewsData.viewsOverTime.data.push({ date: d, views });
+                result.pageViewsData.totalViews += views; 
+                result.pageViewsData.uniqueViewers = Number(p.unique_viewers || 0);
             }
-        }
-        
-        // Add today's exposure
-        if (Object.keys(result.sectorExposure.data).length > 0) {
-            const todaySectorEntry = { date: currentDate, sectors: result.sectorExposure.data };
-            const idx = result.sectorExposureOverTime.data.findIndex(d => d.date === currentDate);
-            if (idx >= 0) {
-                result.sectorExposureOverTime.data[idx] = todaySectorEntry;
-            } else {
-                result.sectorExposureOverTime.data.push(todaySectorEntry);
+        });
+
+        watchlists.forEach(w => {
+            const count = Number(w.total_users || 0);
+            const d = toDateStr(w.date);
+            if (d) {
+                result.watchlistData.watchlistOverTime.data.push({ date: d, count });
+                result.watchlistData.totalUsers = count;
             }
-        }
-        
-        if (Object.keys(result.assetExposure.data).length > 0) {
-            const todayAssetEntry = { date: currentDate, assets: result.assetExposure.data };
-            const idx = result.assetExposureOverTime.data.findIndex(d => d.date === currentDate);
-            if (idx >= 0) {
-                result.assetExposureOverTime.data[idx] = todayAssetEntry;
-            } else {
-                result.assetExposureOverTime.data.push(todayAssetEntry);
+        });
+
+        // ==========================================================================================
+        // 8. ALERTS HISTORY
+        // ==========================================================================================
+        const alertsWindow = alerts.filter(d => toDateStr(d.date) >= sevenDaysAgo);
+        const alertsByDate = {};
+
+        alertsWindow.forEach(row => {
+            const d = toDateStr(row.date);
+            const type = row.alert_type;
+            const count = Number(row.trigger_count || 1);
+            
+            if (type && type.toLowerCase().includes('test')) return;
+
+            result.alertMetrics.totalLast7Days += count;
+            result.alertMetrics.breakdown[type] = (result.alertMetrics.breakdown[type] || 0) + count;
+            alertsByDate[d] = (alertsByDate[d] || 0) + count;
+
+            if (d === date) {
+                result.alertHistoryData.triggeredAlerts.push({
+                    alertType: type,
+                    triggered: true,
+                    count: count,
+                    metadata: row.metadata || {}
+                });
             }
-        }
-        
-        // Limit to 30 days
-        if (result.sectorExposureOverTime.data.length > 30) {
-            result.sectorExposureOverTime.data = result.sectorExposureOverTime.data.slice(-30);
-        }
-        if (result.assetExposureOverTime.data.length > 30) {
-            result.assetExposureOverTime.data = result.assetExposureOverTime.data.slice(-30);
-        }
-    }
-    
-    // =========================================================================
-    // DATA EXTRACTION HELPERS
-    // =========================================================================
-    
-    _extractPositions(portfolio) {
-        if (!portfolio) return [];
-        if (Array.isArray(portfolio)) return portfolio;
-        if (portfolio.AggregatedPositions) return portfolio.AggregatedPositions;
-        if (portfolio.Positions) return portfolio.Positions;
-        if (portfolio.positions) return portfolio.positions;
-        return [];
-    }
-    
-    _extractTrades(historyDoc) {
-        if (!historyDoc) return [];
-        if (Array.isArray(historyDoc)) return historyDoc;
-        if (historyDoc.Trades) return historyDoc.Trades;
-        if (historyDoc.trades) return historyDoc.trades;
-        if (historyDoc.History) return historyDoc.History;
-        return [];
-    }
-    
-    _findUserData(dayData, userId) {
-        if (!dayData) return null;
-        
-        // Direct lookup by user ID
-        if (dayData[userId]) return dayData[userId];
-        if (dayData[String(userId)]) return dayData[String(userId)];
-        
-        // Array - find by user ID field
-        if (Array.isArray(dayData)) {
-            return dayData.find(item => 
-                String(item.pi_id || item.user_id || item.userId) === String(userId)
-            );
-        }
-        
-        return null;
+        });
+
+        Object.entries(alertsByDate)
+            .sort((a, b) => a[0].localeCompare(b[0]))
+            .forEach(([d, count]) => {
+                result.alertHistoryData.alertCountsOverTime.data.push({ date: d, count });
+            });
+
+        this.setResult(entityId, result);
     }
 }
 
-module.exports = PopularInvestorProfileMetrics;
+module.exports = PopularInvestorProfileMetrics;