bulltrackers-module 1.0.765 → 1.0.768

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

@@ -1,17 +1,15 @@
+/**
+ * @fileoverview New Sector Exposure Alert
+ * Refactored to map InstrumentID -> Ticker -> Sector (Industry)
+ * UPDATE: Uses "Last Known" logic for previous state (Lookback 14 days)
+ * Confirmed working 29/01/2026
+ */
 const { Computation } = require('../framework');
 
 class NewSectorExposure extends Computation {
     
     constructor() {
         super();
-        this.SECTOR_MAPPING = {
-            1: 'Currencies',
-            2: 'Commodities',
-            4: 'Indices',
-            5: 'Stocks',
-            6: 'ETF',
-            10: 'Cryptocurrencies'
-        };
     }
 
     static getConfig() {
@@ -23,9 +21,15 @@ class NewSectorExposure extends Computation {
             
             requires: {
                 'portfolio_snapshots': {
-                    lookback: 1, // Today + Yesterday
+                    lookback: 14, // INCREASED: Look back 2 weeks to find last known state
                     mandatory: true,
                     fields: ['user_id', 'portfolio_data', 'date']
+                },
+                'ticker_mappings': {
+                    mandatory: false
+                },
+                'sector_mappings': {
+                    mandatory: false
                 }
             },
 
@@ -38,12 +42,11 @@ class NewSectorExposure extends Computation {
                 }
             },
 
-            // LEGACY METADATA
             userType: 'POPULAR_INVESTOR',
             alert: {
                 id: 'newSector',
                 frontendName: 'New Sector Entry',
-                description: 'Alert when a Popular Investor enters a new sector category',
+                description: 'Alert when a Popular Investor enters a new industry sector',
                 messageTemplate: '{piUsername} entered new sector(s): {sectorName}',
                 severity: 'low',
                 configKey: 'newSector',
@@ -55,7 +58,7 @@ class NewSectorExposure extends Computation {
                             type: 'multiselect',
                             label: 'Watch specific sectors',
                             description: 'Only alert for these sectors',
-                            options: ['Stocks', 'Cryptocurrencies', 'ETF', 'Indices', 'Commodities', 'Currencies'],
+                            options: ['Technology', 'Basic Materials', 'Consumer Cyclical', 'Financial Services', 'Real Estate', 'Healthcare', 'Energy', 'Industrials'],
                             default: []
                         }
                     ],
@@ -70,49 +73,90 @@ class NewSectorExposure extends Computation {
     async process(context) {
         const { data, entityId, date, rules } = context;
 
-        // 1. Get Data
+        // 1. Get Data Sources
         const history = data['portfolio_snapshots'] || [];
-        const todayRow = history.find(d => d.date === date);
+        // FIX: Handle DataFetcher returning Objects (keyed by ID) or Arrays.
+        const tickerRows = Object.values(data['ticker_mappings'] || {});
+        const sectorRows = Object.values(data['sector_mappings'] || {});
+
+        // 2. Build Mapping Dictionaries
+        const tickerMap = new Map();
+        tickerRows.forEach(row => {
+            if (row.instrument_id && row.ticker) {
+                tickerMap.set(Number(row.instrument_id), row.ticker.toUpperCase());
+            }
+        });
+
+        const sectorMap = new Map();
+        sectorRows.forEach(row => {
+            if (row.symbol && row.sector && row.sector !== 'N/A') {
+                sectorMap.set(row.symbol.toUpperCase(), row.sector);
+            }
+        });
+
+        const resolveSector = (instrumentId) => {
+            const ticker = tickerMap.get(Number(instrumentId));
+            if (!ticker) return null;
+            return sectorMap.get(ticker);
+        };
+
+        // 3. Helper to handle BigQuery Dates
+        const toDateStr = (d) => {
+            if (!d) return null;
+            if (d.value) return d.value;
+            return d;
+        };
+
+        // 4. Find Today and Last Known Previous Row
+        // Sort history descending by date to find the most recent previous entry
+        history.sort((a, b) => {
+            const dateA = toDateStr(a.date);
+            const dateB = toDateStr(b.date);
+            return dateB.localeCompare(dateA); // Descending (Newest First)
+        });
+
+        const todayRow = history.find(d => toDateStr(d.date) === date);
         
-        // Calc yesterday date
-        const yDate = new Date(date);
-        yDate.setDate(yDate.getDate() - 1);
-        const yDateStr = yDate.toISOString().split('T')[0];
-        const yesterdayRow = history.find(d => d.date === yDateStr);
+        // Find the first row where date is strictly less than target date
+        // Since we sorted descending, this is the "Last Known" date
+        const previousRow = history.find(d => toDateStr(d.date) < date);
 
-        // 2. Extract Data
+        // 5. Extract Portfolio Data
         const todayData = rules.portfolio.extractPortfolioData(todayRow);
-        const yesterdayData = rules.portfolio.extractPortfolioData(yesterdayRow);
+        const previousData = rules.portfolio.extractPortfolioData(previousRow);
 
         if (!todayData) return;
 
-        // 3. Helper to get Sector Map
+        // 6. Calculate Sector Exposures
         const getSectorMap = (pData) => {
             const map = new Map();
-            // Using Rule: extractPositionsByType gives AggregatedPositionsByInstrumentTypeID
-            const aggs = rules.portfolio.extractPositionsByType(pData);
+            const positions = rules.portfolio.extractPositions(pData);
             
-            aggs.forEach(agg => {
-                const typeId = agg.InstrumentTypeID;
-                const invested = agg.Invested || 0;
+            positions.forEach(pos => {
+                const instrumentId = rules.portfolio.getInstrumentId(pos);
+                const invested = rules.portfolio.getInvested(pos); 
                 
-                if (typeId && invested > 0) {
-                    const sectorName = this.SECTOR_MAPPING[typeId];
-                    if (sectorName) map.set(sectorName, invested);
+                if (instrumentId && invested > 0) {
+                    const sectorName = resolveSector(instrumentId);
+                    if (sectorName) {
+                        const current = map.get(sectorName) || 0;
+                        map.set(sectorName, current + invested);
+                    }
                 }
             });
             return map;
         };
 
         const todaySectors = getSectorMap(todayData);
-        const yesterdaySectors = getSectorMap(yesterdayData);
+        const previousSectors = getSectorMap(previousData);
 
+        // 7. Compare
         const newExposures = [];
-        const isBaselineReset = (!yesterdayData);
+        const isBaselineReset = (!previousData); // True if no previous history found
 
         if (!isBaselineReset) {
             for (const [sectorName, invested] of todaySectors) {
-                const prevInvested = yesterdaySectors.get(sectorName) || 0;
+                const prevInvested = previousSectors.get(sectorName) || 0;
                 if (prevInvested === 0 && invested > 0) {
                     newExposures.push(sectorName);
                 }
@@ -121,11 +165,14 @@ class NewSectorExposure extends Computation {
 
         const result = {
             currentSectors: Array.from(todaySectors.keys()),
-            previousSectors: isBaselineReset ? [] : Array.from(yesterdaySectors.keys()),
+            previousSectors: isBaselineReset ? [] : Array.from(previousSectors.keys()),
             newExposures,
             sectorName: newExposures.join(', '), 
             isBaselineReset,
-            triggered: newExposures.length > 0
+            triggered: newExposures.length > 0,
+            _metadata: {
+                previousDate: previousRow ? toDateStr(previousRow.date) : null
+            }
         };
 
         this.setResult(entityId, result);

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

@@ -1,3 +1,8 @@
+/**
+ * @fileoverview New Social Post Alert
+ * Logic: Alerts ONLY if a post exists with a creation date matching the current run date.
+ * Relies on DataFetcher V2.8+ to handle JSON parsing/double-encoding.
+ */
 const { Computation } = require('../framework');
 
 class NewSocialPost extends Computation {
@@ -7,11 +12,11 @@ class NewSocialPost extends Computation {
             name: 'NewSocialPost',
             type: 'per-entity',
             category: 'alerts',
-            isHistorical: false,
+            isHistorical: true,
             
             requires: {
                 'social_post_snapshots': {
-                    lookback: 0,
+                    lookback: 5, // Short lookback just to ensure we catch the specific row
                     mandatory: true,
                     fields: ['user_id', 'posts_data', 'date']
                 }
@@ -26,19 +31,15 @@ class NewSocialPost extends Computation {
                 }
             },
 
-            // LEGACY METADATA
             userType: 'POPULAR_INVESTOR',
             alert: {
                 id: 'newSocialPost',
                 frontendName: 'New Social Post',
-                description: 'Alert when a Popular Investor makes a new social post',
+                description: 'Alert when a Popular Investor makes a new social post today',
                 messageTemplate: '{piUsername} posted a new update: {title}',
                 severity: 'low',
                 configKey: 'newSocialPost',
-                isDynamic: false,
-                thresholds: [],
-                conditions: [],
-                resultKeys: ['hasNewPost', 'latestPostDate', 'postCount', 'title']
+                isDynamic: false
             }
         };
     }
@@ -46,50 +47,77 @@ class NewSocialPost extends Computation {
     async process(context) {
         const { data, entityId, date, rules } = context;
 
-        // 1. Get Data using Rules
-        // V2 data structure: data['table'][entityId] is the row (when lookback=0)
-        const row = data['social_post_snapshots']; 
-        const posts = rules.social.extractPosts(row);
+        // 1. Get History
+        const history = data['social_post_snapshots'] || [];
+        
+        // Helper: Handle BigQuery Date Objects
+        const toDateStr = (d) => {
+            if (!d) return null;
+            if (d.value) return d.value;
+            return d;
+        };
+
+        // 2. Find the Snapshot for "Today" (The Execution Date)
+        // We strictly want to know if they posted *on this specific date*.
+        const todayRow = history.find(d => toDateStr(d.date) === date);
+
+        if (!todayRow) {
+            // No snapshot exists for this date yet, so we can't determine if they posted.
+            this.setResult(entityId, { 
+                hasNewPost: false, 
+                triggered: false,
+                reason: "No snapshot found for date" 
+            });
+            return;
+        }
+
+        // 3. Extract Posts
+        // (DataFetcher V2.8 automatically handles the double-encoded JSON)
+        const posts = rules.social.extractPosts(todayRow);
 
         let hasNewPost = false;
         let latestPost = null;
 
-        // 2. Logic
+        // 4. Check for posts created "Today"
         for (const post of posts) {
-            const postDate = rules.social.getPostDate(post);
-            if (!postDate) continue;
+            const postDateObj = rules.social.getPostDate(post);
+            if (!postDateObj) continue;
+
+            // Format YYYY-MM-DD
+            const postDateStr = postDateObj.toISOString().slice(0, 10);
 
-            // Check matches today (YYYY-MM-DD)
-            if (postDate.toISOString().slice(0, 10) === date) {
+            if (postDateStr === date) {
                 hasNewPost = true;
                 
-                const latestDate = latestPost ? rules.social.getPostDate(latestPost) : new Date(0);
-                if (postDate > latestDate) {
+                // Track the latest one for the alert title
+                if (!latestPost || postDateObj > rules.social.getPostDate(latestPost)) {
                     latestPost = post;
                 }
             }
         }
 
-        // 3. Title Extraction
+        // 5. Format Title for Alert
         let displayTitle = 'New Update';
         if (latestPost) {
             const text = rules.social.getPostText(latestPost);
-            const rawTitle = latestPost.Title; // Fallback if rule doesn't cover Title specifically
+            const rawTitle = latestPost.Title;
 
             if (rawTitle) {
                 displayTitle = rawTitle;
             } else if (text) {
-                displayTitle = text.substring(0, 50).replace(/\n/g, ' ');
-                if (text.length > 50) displayTitle += '...';
+                // Truncate text for display
+                displayTitle = text.substring(0, 60).replace(/\n/g, ' ');
+                if (text.length > 60) displayTitle += '...';
             }
         }
 
+        // 6. Set Result
         const result = {
             hasNewPost,
             latestPostDate: latestPost ? rules.social.getPostDate(latestPost) : null,
             postCount: posts.length,
             title: displayTitle,
-            triggered: hasNewPost
+            triggered: hasNewPost // Only triggers if a post matched today's date
         };
 
         this.setResult(entityId, result);