aiden-shared-calculations-unified 1.0.35 → 1.0.37

package/calculations/pnl/historical/profitability_migration.js

@@ -1,58 +1,58 @@
-/**
- * @fileoverview Calculates the migration of users between profitability states.
- */
-
-class ProfitabilityMigration {
-    constructor() {
-        this.profitableToUnprofitable = 0;
-        this.unprofitableToProfitable = 0;
-        this.remainedProfitable = 0;
-        this.remainedUnprofitable = 0;
-    }
-
-    process(todayPortfolio, yesterdayPortfolio, userId) {
-        if (!todayPortfolio || !yesterdayPortfolio) {
-            return;
-        }
-
-        const todayProfit = this.calculateTotalPnl(todayPortfolio);
-        const yesterdayProfit = this.calculateTotalPnl(yesterdayPortfolio);
-
-        if (todayProfit === null || yesterdayProfit === null) {
-            return;
-        }
-
-        const wasProfitable = yesterdayProfit > 0;
-        const isProfitable = todayProfit > 0;
-
-        if (wasProfitable && !isProfitable) {
-            this.profitableToUnprofitable++;
-        } else if (!wasProfitable && isProfitable) {
-            this.unprofitableToProfitable++;
-        } else if (wasProfitable && isProfitable) {
-            this.remainedProfitable++;
-        } else {
-            this.remainedUnprofitable++;
-        }
-    }
-
-    calculateTotalPnl(portfolio) {
-        if (portfolio && portfolio.AggregatedPositions) {
-            return portfolio.AggregatedPositions.reduce((sum, pos) => sum + pos.NetProfit, 0);
-        } else if (portfolio && portfolio.PublicPositions) {
-            return portfolio.PublicPositions.reduce((sum, pos) => sum + pos.NetProfit, 0);
-        }
-        return null;
-    }
-
-    getResult() {
-        return {
-            profitable_to_unprofitable: this.profitableToUnprofitable,
-            unprofitable_to_profitable: this.unprofitableToProfitable,
-            remained_profitable: this.remainedProfitable,
-            remained_unprofitable: this.remainedUnprofitable,
-        };
-    }
-}
-
+/**
+ * @fileoverview Calculates the migration of users between profitability states.
+ */
+
+class ProfitabilityMigration {
+    constructor() {
+        this.profitableToUnprofitable = 0;
+        this.unprofitableToProfitable = 0;
+        this.remainedProfitable = 0;
+        this.remainedUnprofitable = 0;
+    }
+
+    process(todayPortfolio, yesterdayPortfolio, userId) {
+        if (!todayPortfolio || !yesterdayPortfolio) {
+            return;
+        }
+
+        const todayProfit = this.calculateTotalPnl(todayPortfolio);
+        const yesterdayProfit = this.calculateTotalPnl(yesterdayPortfolio);
+
+        if (todayProfit === null || yesterdayProfit === null) {
+            return;
+        }
+
+        const wasProfitable = yesterdayProfit > 0;
+        const isProfitable = todayProfit > 0;
+
+        if (wasProfitable && !isProfitable) {
+            this.profitableToUnprofitable++;
+        } else if (!wasProfitable && isProfitable) {
+            this.unprofitableToProfitable++;
+        } else if (wasProfitable && isProfitable) {
+            this.remainedProfitable++;
+        } else {
+            this.remainedUnprofitable++;
+        }
+    }
+
+    calculateTotalPnl(portfolio) {
+        if (portfolio && portfolio.AggregatedPositions) {
+            return portfolio.AggregatedPositions.reduce((sum, pos) => sum + pos.NetProfit, 0);
+        } else if (portfolio && portfolio.PublicPositions) {
+            return portfolio.PublicPositions.reduce((sum, pos) => sum + pos.NetProfit, 0);
+        }
+        return null;
+    }
+
+    getResult() {
+        return {
+            profitable_to_unprofitable: this.profitableToUnprofitable,
+            unprofitable_to_profitable: this.unprofitableToProfitable,
+            remained_profitable: this.remainedProfitable,
+            remained_unprofitable: this.remainedUnprofitable,
+        };
+    }
+}
+
 module.exports = ProfitabilityMigration;

package/calculations/pnl/historical/user_profitability_tracker.js

@@ -1,118 +1,118 @@
-/**
- * @fileoverview Tracks user profitability over a 7-day rolling window.
- * This version shards the output AND calculates the user's *weighted average daily PNL (as a decimal %)*.
- */
-
-const { Firestore } = require('@google-cloud/firestore');
-const firestore = new Firestore();
-
-const NUM_SHARDS = 50;
-
-class UserProfitabilityTracker {
-    constructor() {
-        // This will store { userId: { weightedPnlSum: 0, totalInvested: 0 } }
-        this.dailyData = {}; 
-    }
-
-    /**
-     * Calculates the weighted PNL for the day.
-     * NetProfit is a decimal % return (e.g., 0.03)
-     * Invested is a decimal % weight (e.g., 0.05)
-     */
-    calculateWeightedDailyPnl(portfolio) {
-        if (!portfolio || !portfolio.AggregatedPositions || portfolio.AggregatedPositions.length === 0) {
-            return { weightedPnl: 0, totalInvested: 0 };
-        }
-
-        let weightedPnlSum = 0;
-        let totalInvested = 0;
-
-        for (const pos of portfolio.AggregatedPositions) {
-            // Use NetProfit (the % return)
-            const netProfit = ('NetProfit' in pos) ? pos.NetProfit : (pos.ProfitAndLoss || 0); 
-            // Use InvestedAmount (the % portfolio weight)
-            const invested = pos.InvestedAmount || pos.Amount || 0; 
-
-            if (invested > 0) {
-                weightedPnlSum += netProfit * invested;
-                totalInvested += invested;
-            }
-        }
-
-        return { weightedPnlSum, totalInvested };
-    }
-
-    process(todayPortfolio, yesterdayPortfolio, userId) {
-        if (!todayPortfolio) return;
-
-        const { weightedPnlSum, totalInvested } = this.calculateWeightedDailyPnl(todayPortfolio);
-
-        if (totalInvested > 0) {
-            this.dailyData[userId] = { weightedPnlSum, totalInvested };
-        }
-    }
-
-    async getResult() {
-        // --- START MODIFICATION ---
-        // If no data was processed (e.g., no portfolios found for the day),
-        // return null to allow the backfill to retry.
-        if (Object.keys(this.dailyData).length === 0) {
-            console.warn('[UserProfitabilityTracker] No daily data was processed. Returning null for backfill.');
-            return null;
-        }
-        // --- END MODIFICATION ---
-
-        const today = new Date().toISOString().slice(0, 10);
-        const results = {}; // For sharded history
-        const dailyPnlMap = {}; // For the new profile calc
-
-        // Prepare sharded data structure
-        for (let i = 0; i < NUM_SHARDS; i++) {
-            results[`user_profitability_shard_${i}`] = {};
-        }
-
-        // ... (Fetch existing shards logic, same as your file) ...
-        const shardPromises = [];
-        for (let i = 0; i < NUM_SHARDS; i++) {
-            const docRef = firestore.collection('historical_insights').doc(`user_profitability_shard_${i}`);
-            shardPromises.push(docRef.get());
-        }
-        const shardSnapshots = await Promise.all(shardPromises);
-        const existingData = shardSnapshots.map(snap => (snap.exists ? snap.data().profits : {}));
-
-
-        for (const userId in this.dailyData) {
-            const { weightedPnlSum, totalInvested } = this.dailyData[userId];
-
-            // Calculate the final weighted average % return for the day
-            // We cap totalInvested at 1.0 (100%) in case of data issues
-            const totalWeight = Math.min(1.0, totalInvested);
-            const dailyAvgPnl = (totalWeight > 0) ? (weightedPnlSum / totalWeight) : 0;
-
-            // Store this for the profile calc dependency
-            dailyPnlMap[userId] = dailyAvgPnl;
-
-            // --- Now, update the sharded history ---
-            const shardIndex = parseInt(userId, 10) % NUM_SHARDS;
-            const userHistory = existingData[shardIndex][userId] || [];
-            
-            // Store the decimal % pnl in the history
-            userHistory.push({ date: today, pnl: dailyAvgPnl }); 
-            
-            const shardKey = `user_profitability_shard_${shardIndex}`;
-            if (!results[shardKey]) results[shardKey] = {};
-            results[shardKey][userId] = userHistory.slice(-7);
-        }
-
-        return {
-            sharded_user_profitability: results,
-            daily_pnl_map: dailyPnlMap // <-- This now correctly outputs the weighted avg % PNL
-        };
-    }
-
-    reset() {
-        this.dailyData = {};
-    }
-}
-
+/**
+ * @fileoverview Tracks user profitability over a 7-day rolling window.
+ * This version shards the output AND calculates the user's *weighted average daily PNL (as a decimal %)*.
+ */
+
+const { Firestore } = require('@google-cloud/firestore');
+const firestore = new Firestore();
+
+const NUM_SHARDS = 50;
+
+class UserProfitabilityTracker {
+    constructor() {
+        // This will store { userId: { weightedPnlSum: 0, totalInvested: 0 } }
+        this.dailyData = {}; 
+    }
+
+    /**
+     * Calculates the weighted PNL for the day.
+     * NetProfit is a decimal % return (e.g., 0.03)
+     * Invested is a decimal % weight (e.g., 0.05)
+     */
+    calculateWeightedDailyPnl(portfolio) {
+        if (!portfolio || !portfolio.AggregatedPositions || portfolio.AggregatedPositions.length === 0) {
+            return { weightedPnl: 0, totalInvested: 0 };
+        }
+
+        let weightedPnlSum = 0;
+        let totalInvested = 0;
+
+        for (const pos of portfolio.AggregatedPositions) {
+            // Use NetProfit (the % return)
+            const netProfit = ('NetProfit' in pos) ? pos.NetProfit : (pos.ProfitAndLoss || 0); 
+            // Use InvestedAmount (the % portfolio weight)
+            const invested = pos.InvestedAmount || pos.Amount || 0; 
+
+            if (invested > 0) {
+                weightedPnlSum += netProfit * invested;
+                totalInvested += invested;
+            }
+        }
+
+        return { weightedPnlSum, totalInvested };
+    }
+
+    process(todayPortfolio, yesterdayPortfolio, userId) {
+        if (!todayPortfolio) return;
+
+        const { weightedPnlSum, totalInvested } = this.calculateWeightedDailyPnl(todayPortfolio);
+
+        if (totalInvested > 0) {
+            this.dailyData[userId] = { weightedPnlSum, totalInvested };
+        }
+    }
+
+    async getResult() {
+        // --- START MODIFICATION ---
+        // If no data was processed (e.g., no portfolios found for the day),
+        // return null to allow the backfill to retry.
+        if (Object.keys(this.dailyData).length === 0) {
+            console.warn('[UserProfitabilityTracker] No daily data was processed. Returning null for backfill.');
+            return null;
+        }
+        // --- END MODIFICATION ---
+
+        const today = new Date().toISOString().slice(0, 10);
+        const results = {}; // For sharded history
+        const dailyPnlMap = {}; // For the new profile calc
+
+        // Prepare sharded data structure
+        for (let i = 0; i < NUM_SHARDS; i++) {
+            results[`user_profitability_shard_${i}`] = {};
+        }
+
+        // ... (Fetch existing shards logic, same as your file) ...
+        const shardPromises = [];
+        for (let i = 0; i < NUM_SHARDS; i++) {
+            const docRef = firestore.collection('historical_insights').doc(`user_profitability_shard_${i}`);
+            shardPromises.push(docRef.get());
+        }
+        const shardSnapshots = await Promise.all(shardPromises);
+        const existingData = shardSnapshots.map(snap => (snap.exists ? snap.data().profits : {}));
+
+
+        for (const userId in this.dailyData) {
+            const { weightedPnlSum, totalInvested } = this.dailyData[userId];
+
+            // Calculate the final weighted average % return for the day
+            // We cap totalInvested at 1.0 (100%) in case of data issues
+            const totalWeight = Math.min(1.0, totalInvested);
+            const dailyAvgPnl = (totalWeight > 0) ? (weightedPnlSum / totalWeight) : 0;
+
+            // Store this for the profile calc dependency
+            dailyPnlMap[userId] = dailyAvgPnl;
+
+            // --- Now, update the sharded history ---
+            const shardIndex = parseInt(userId, 10) % NUM_SHARDS;
+            const userHistory = existingData[shardIndex][userId] || [];
+            
+            // Store the decimal % pnl in the history
+            userHistory.push({ date: today, pnl: dailyAvgPnl }); 
+            
+            const shardKey = `user_profitability_shard_${shardIndex}`;
+            if (!results[shardKey]) results[shardKey] = {};
+            results[shardKey][userId] = userHistory.slice(-7);
+        }
+
+        return {
+            sharded_user_profitability: results,
+            daily_pnl_map: dailyPnlMap // <-- This now correctly outputs the weighted avg % PNL
+        };
+    }
+
+    reset() {
+        this.dailyData = {};
+    }
+}
+
 module.exports = UserProfitabilityTracker;

package/calculations/pnl/profitable_and_unprofitable_status.js

@@ -1,65 +1,65 @@
-/**
- * @fileoverview Counts the number of users whose overall portfolio is in profit vs. loss for the current day.
- */
-
-class DailyUserPnlStatus {
-    constructor() {
-        // Initialize counters
-        this.profitableUsers = 0;
-        this.unprofitableUsers = 0;
-    }
-
-    /**
-     * Processes a single user's portfolio for the current day.
-     * @param {object} todayPortfolio - The portfolio data for the current day.
-     * @param {object} yesterdayPortfolio - Not used in this calculation.
-     * @param {string} userId - The user's ID.
-     * @param {object} context - Shared context data (not used here).
-     */
-    process(todayPortfolio, yesterdayPortfolio, userId, context) {
-        // Prefer AggregatedPositions as it typically contains NetProfit
-        const positions = todayPortfolio?.AggregatedPositions || todayPortfolio?.PublicPositions;
-
-        // Ensure we have portfolio data and positions
-        if (!positions || !Array.isArray(positions) || positions.length === 0) {
-            return; // Skip if no positions data for the user today
-        }
-
-        // Calculate the sum of NetProfit across all positions for the user
-        let totalUserPnl = 0;
-        for (const position of positions) {
-            // Ensure NetProfit exists and is a number, default to 0 otherwise
-            totalUserPnl += (typeof position.NetProfit === 'number' ? position.NetProfit : 0);
-        }
-
-        // Increment the appropriate counter based on the total P/L
-        if (totalUserPnl > 0) {
-            this.profitableUsers++;
-        } else if (totalUserPnl < 0) {
-            this.unprofitableUsers++;
-        }
-        // Users with exactly zero P/L are ignored
-    }
-
-    /**
-     * Returns the final aggregated counts.
-     * @returns {object} Object containing the counts of profitable and unprofitable users.
-     */
-    getResult() {
-        // Return the raw counts
-        return {
-            profitable_user_count: this.profitableUsers,
-            unprofitable_user_count: this.unprofitableUsers
-        };
-    }
-
-    /**
-     * Resets the internal counters for the next processing run.
-     */
-    reset() {
-        this.profitableUsers = 0;
-        this.unprofitableUsers = 0;
-    }
-}
-
+/**
+ * @fileoverview Counts the number of users whose overall portfolio is in profit vs. loss for the current day.
+ */
+
+class DailyUserPnlStatus {
+    constructor() {
+        // Initialize counters
+        this.profitableUsers = 0;
+        this.unprofitableUsers = 0;
+    }
+
+    /**
+     * Processes a single user's portfolio for the current day.
+     * @param {object} todayPortfolio - The portfolio data for the current day.
+     * @param {object} yesterdayPortfolio - Not used in this calculation.
+     * @param {string} userId - The user's ID.
+     * @param {object} context - Shared context data (not used here).
+     */
+    process(todayPortfolio, yesterdayPortfolio, userId, context) {
+        // Prefer AggregatedPositions as it typically contains NetProfit
+        const positions = todayPortfolio?.AggregatedPositions || todayPortfolio?.PublicPositions;
+
+        // Ensure we have portfolio data and positions
+        if (!positions || !Array.isArray(positions) || positions.length === 0) {
+            return; // Skip if no positions data for the user today
+        }
+
+        // Calculate the sum of NetProfit across all positions for the user
+        let totalUserPnl = 0;
+        for (const position of positions) {
+            // Ensure NetProfit exists and is a number, default to 0 otherwise
+            totalUserPnl += (typeof position.NetProfit === 'number' ? position.NetProfit : 0);
+        }
+
+        // Increment the appropriate counter based on the total P/L
+        if (totalUserPnl > 0) {
+            this.profitableUsers++;
+        } else if (totalUserPnl < 0) {
+            this.unprofitableUsers++;
+        }
+        // Users with exactly zero P/L are ignored
+    }
+
+    /**
+     * Returns the final aggregated counts.
+     * @returns {object} Object containing the counts of profitable and unprofitable users.
+     */
+    getResult() {
+        // Return the raw counts
+        return {
+            profitable_user_count: this.profitableUsers,
+            unprofitable_user_count: this.unprofitableUsers
+        };
+    }
+
+    /**
+     * Resets the internal counters for the next processing run.
+     */
+    reset() {
+        this.profitableUsers = 0;
+        this.unprofitableUsers = 0;
+    }
+}
+
 module.exports = DailyUserPnlStatus;

package/calculations/sectors/historical/diversification_pnl.js

@@ -1,77 +1,77 @@
-// CORRECTED PATH: ../utils/ instead of ../../utils/
-const { getInstrumentSectorMap } = require('../../../utils/sector_mapping_provider');
-
-/**
- * Aggregates P/L by the number of unique sectors a user is invested in.
- */
-class DiversificationPnl {
-    constructor() {
-        this.pnl_by_sector_count = {};
-        this.sectorMapping = null;
-    }
-
-    _initBucket(count) {
-        if (!this.pnl_by_sector_count[count]) {
-            this.pnl_by_sector_count[count] = { pnl_sum: 0, count: 0 };
-        }
-    }
-
-    /**
-     * FIX: Helper function to calculate total P&L from positions
-     * @param {object} portfolio
-     * @returns {number|null}
-     */
-    _calculateTotalPnl(portfolio) {
-        const positions = portfolio?.AggregatedPositions || portfolio?.PublicPositions;
-        if (positions && Array.isArray(positions)) {
-            // Sum all NetProfit fields, defaulting to 0 if a position has no NetProfit
-            return positions.reduce((sum, pos) => sum + (pos.NetProfit || 0), 0);
-        }
-        return null;
-    }
-
-    async process(todayPortfolio, yesterdayPortfolio, userId) { // Added async
-        // FIX: Only need todayPortfolio for this logic
-        if (!todayPortfolio) {
-            return;
-        }
-         
-        if(!this.sectorMapping) {
-            this.sectorMapping = await getInstrumentSectorMap();
-        }
-
-        const positions = todayPortfolio.AggregatedPositions || todayPortfolio.PublicPositions;
-
-        if (!positions || !Array.isArray(positions)) {
-            return;
-        }
-
-        const uniqueSectors = new Set();
-        for (const position of positions) {
-            const sector = this.sectorMapping[position.InstrumentID] || 'Other';
-            uniqueSectors.add(sector);
-        }
-
-        const sectorCount = uniqueSectors.size;
-        if (sectorCount === 0) {
-            return;
-        }
-
-        // FIX: Calculate dailyPnl by summing NetProfit from all positions
-        const dailyPnl = this._calculateTotalPnl(todayPortfolio);
-
-        if (dailyPnl === null) {
-            return; // Cannot calculate P&L for this user
-        }
-
-        this._initBucket(sectorCount);
-        this.pnl_by_sector_count[sectorCount].pnl_sum += dailyPnl;
-        this.pnl_by_sector_count[sectorCount].count++;
-    }
-
-    getResult() {
-        return this.pnl_by_sector_count;
-    }
-}
-
+// CORRECTED PATH: ../utils/ instead of ../../utils/
+const { getInstrumentSectorMap } = require('../../../utils/sector_mapping_provider');
+
+/**
+ * Aggregates P/L by the number of unique sectors a user is invested in.
+ */
+class DiversificationPnl {
+    constructor() {
+        this.pnl_by_sector_count = {};
+        this.sectorMapping = null;
+    }
+
+    _initBucket(count) {
+        if (!this.pnl_by_sector_count[count]) {
+            this.pnl_by_sector_count[count] = { pnl_sum: 0, count: 0 };
+        }
+    }
+
+    /**
+     * FIX: Helper function to calculate total P&L from positions
+     * @param {object} portfolio
+     * @returns {number|null}
+     */
+    _calculateTotalPnl(portfolio) {
+        const positions = portfolio?.AggregatedPositions || portfolio?.PublicPositions;
+        if (positions && Array.isArray(positions)) {
+            // Sum all NetProfit fields, defaulting to 0 if a position has no NetProfit
+            return positions.reduce((sum, pos) => sum + (pos.NetProfit || 0), 0);
+        }
+        return null;
+    }
+
+    async process(todayPortfolio, yesterdayPortfolio, userId) { // Added async
+        // FIX: Only need todayPortfolio for this logic
+        if (!todayPortfolio) {
+            return;
+        }
+         
+        if(!this.sectorMapping) {
+            this.sectorMapping = await getInstrumentSectorMap();
+        }
+
+        const positions = todayPortfolio.AggregatedPositions || todayPortfolio.PublicPositions;
+
+        if (!positions || !Array.isArray(positions)) {
+            return;
+        }
+
+        const uniqueSectors = new Set();
+        for (const position of positions) {
+            const sector = this.sectorMapping[position.InstrumentID] || 'Other';
+            uniqueSectors.add(sector);
+        }
+
+        const sectorCount = uniqueSectors.size;
+        if (sectorCount === 0) {
+            return;
+        }
+
+        // FIX: Calculate dailyPnl by summing NetProfit from all positions
+        const dailyPnl = this._calculateTotalPnl(todayPortfolio);
+
+        if (dailyPnl === null) {
+            return; // Cannot calculate P&L for this user
+        }
+
+        this._initBucket(sectorCount);
+        this.pnl_by_sector_count[sectorCount].pnl_sum += dailyPnl;
+        this.pnl_by_sector_count[sectorCount].count++;
+    }
+
+    getResult() {
+        return this.pnl_by_sector_count;
+    }
+}
+
 module.exports = DiversificationPnl;