aiden-shared-calculations-unified 1.0.8 → 1.0.9

package/calculations/speculators/holding_duration_per_asset.js

@@ -1,55 +1,55 @@
-/**
- * @fileoverview Calculates the average holding duration of open speculator positions.
- */
-const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
-
-class HoldingDurationPerAsset {
-    constructor() {
-        this.durationData = {};
-        this.mappings = null;
-    }
-
-    process(portfolioData, userId, context) {
-        if (portfolioData && portfolioData.PublicPositions) {
-            const now = new Date();
-            for (const position of portfolioData.PublicPositions) {
-                const instrumentId = position.InstrumentID;
-                const openTime = new Date(position.OpenDateTime);
-                const durationHours = (now - openTime) / (1000 * 60 * 60);
-
-                if (!this.durationData[instrumentId]) {
-                    this.durationData[instrumentId] = { duration_sum_hours: 0, count: 0 };
-                }
-                this.durationData[instrumentId].duration_sum_hours += durationHours;
-                this.durationData[instrumentId].count++;
-            }
-        }
-    }
-
-    async getResult() {
-        if (!this.mappings) {
-            this.mappings = await loadInstrumentMappings();
-        }
-        const result = {};
-        for (const instrumentId in this.durationData) {
-            const ticker = this.mappings.instrumentToTicker[instrumentId] || instrumentId.toString();
-            const data = this.durationData[instrumentId];
-
-            // REFACTOR: Perform the final calculation directly.
-            if (data.count > 0) {
-                result[ticker] = {
-                    average_duration_hours: data.duration_sum_hours / data.count
-                };
-            }
-        }
-        
-        return result;
-    }
-
-    reset() {
-        this.durationData = {};
-        this.mappings = null;
-    }
-}
-
-module.exports = HoldingDurationPerAsset;
+/**
+ * @fileoverview Calculates the average holding duration of open speculator positions.
+ */
+const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
+
+class HoldingDurationPerAsset {
+    constructor() {
+        this.durationData = {};
+        this.mappings = null;
+    }
+
+    process(portfolioData, yesterdayPortfolio, userId, context) {
+        if (portfolioData && portfolioData.PublicPositions) {
+            const now = new Date();
+            for (const position of portfolioData.PublicPositions) {
+                const instrumentId = position.InstrumentID;
+                const openTime = new Date(position.OpenDateTime);
+                const durationHours = (now - openTime) / (1000 * 60 * 60);
+
+                if (!this.durationData[instrumentId]) {
+                    this.durationData[instrumentId] = { duration_sum_hours: 0, count: 0 };
+                }
+                this.durationData[instrumentId].duration_sum_hours += durationHours;
+                this.durationData[instrumentId].count++;
+            }
+        }
+    }
+
+    async getResult() {
+        if (!this.mappings) {
+            this.mappings = await loadInstrumentMappings();
+        }
+        const result = {};
+        for (const instrumentId in this.durationData) {
+            const ticker = this.mappings.instrumentToTicker[instrumentId] || instrumentId.toString();
+            const data = this.durationData[instrumentId];
+
+            // REFACTOR: Perform the final calculation directly.
+            if (data.count > 0) {
+                result[ticker] = {
+                    average_duration_hours: data.duration_sum_hours / data.count
+                };
+            }
+        }
+        
+        return result;
+    }
+
+    reset() {
+        this.durationData = {};
+        this.mappings = null;
+    }
+}
+
+module.exports = HoldingDurationPerAsset;

package/calculations/speculators/leverage_per_asset.js

@@ -1,47 +1,47 @@
-/**
- * @fileoverview Calculates leverage usage per instrument for speculators.
- */
-const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
-
-class LeveragePerAsset {
-    constructor() {
-        this.leverageData = {};
-        this.mappings = null;
-    }
-
-    process(portfolioData, userId) {
-        if (portfolioData && portfolioData.PublicPositions) {
-            for (const position of portfolioData.PublicPositions) {
-                const instrumentId = position.InstrumentID;
-                const leverage = position.Leverage;
-
-                if (!this.leverageData[instrumentId]) {
-                    this.leverageData[instrumentId] = {};
-                }
-                this.leverageData[instrumentId][leverage] = (this.leverageData[instrumentId][leverage] || 0) + 1;
-            }
-        }
-    }
-
-    async getResult() {
-        if (!this.mappings) {
-            this.mappings = await loadInstrumentMappings();
-        }
-        const result = {};
-        for (const instrumentId in this.leverageData) {
-            const ticker = this.mappings.instrumentToTicker[instrumentId] || instrumentId.toString();
-            result[ticker] = this.leverageData[instrumentId];
-        }
-        if (Object.keys(result).length === 0) return {};
-        return {
-            leverage_per_asset: result
-        };
-    }
-
-    reset() {
-        this.leverageData = {};
-        this.mappings = null;
-    }
-}
-
+/**
+ * @fileoverview Calculates leverage usage per instrument for speculators.
+ */
+const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
+
+class LeveragePerAsset {
+    constructor() {
+        this.leverageData = {};
+        this.mappings = null;
+    }
+
+    process(portfolioData, yesterdayPortfolio, userId, context) {
+        if (portfolioData && portfolioData.PublicPositions) {
+            for (const position of portfolioData.PublicPositions) {
+                const instrumentId = position.InstrumentID;
+                const leverage = position.Leverage;
+
+                if (!this.leverageData[instrumentId]) {
+                    this.leverageData[instrumentId] = {};
+                }
+                this.leverageData[instrumentId][leverage] = (this.leverageData[instrumentId][leverage] || 0) + 1;
+            }
+        }
+    }
+
+    async getResult() {
+        if (!this.mappings) {
+            this.mappings = await loadInstrumentMappings();
+        }
+        const result = {};
+        for (const instrumentId in this.leverageData) {
+            const ticker = this.mappings.instrumentToTicker[instrumentId] || instrumentId.toString();
+            result[ticker] = this.leverageData[instrumentId];
+        }
+        if (Object.keys(result).length === 0) return {};
+        return {
+            leverage_per_asset: result
+        };
+    }
+
+    reset() {
+        this.leverageData = {};
+        this.mappings = null;
+    }
+}
+
 module.exports = LeveragePerAsset;

package/calculations/speculators/leverage_per_sector.js

@@ -1,45 +1,45 @@
-const { getInstrumentSectorMap } = require('../../utils/sector_mapping_provider');
-
-/**
- * @fileoverview Calculates leverage usage per sector for speculators.
- */
-
-class LeveragePerSector {
-    constructor() {
-        this.positions = [];
-    }
-
-    process(portfolioData, userId) {
-        if (portfolioData && portfolioData.PublicPositions) {
-            this.positions.push(...portfolioData.PublicPositions);
-        }
-    }
-
-    async getResult() {
-        if (this.positions.length === 0) return {};
-
-        const sectorMap = await getInstrumentSectorMap();
-        const leverageData = {};
-
-        for (const position of this.positions) {
-            const instrumentId = position.InstrumentID;
-            const sector = sectorMap[instrumentId] || 'N/A';
-            const leverage = position.Leverage;
-
-            if (!leverageData[sector]) {
-                leverageData[sector] = {};
-            }
-            leverageData[sector][leverage] = (leverageData[sector][leverage] || 0) + 1;
-        }
-
-        return {
-            leverage_per_sector: leverageData
-        };
-    }
-
-    reset() {
-        this.positions = [];
-    }
-}
-
+const { getInstrumentSectorMap } = require('../../utils/sector_mapping_provider');
+
+/**
+ * @fileoverview Calculates leverage usage per sector for speculators.
+ */
+
+class LeveragePerSector {
+    constructor() {
+        this.positions = [];
+    }
+
+    process(portfolioData, yesterdayPortfolio, userId, context) {
+        if (portfolioData && portfolioData.PublicPositions) {
+            this.positions.push(...portfolioData.PublicPositions);
+        }
+    }
+
+    async getResult() {
+        if (this.positions.length === 0) return {};
+
+        const sectorMap = await getInstrumentSectorMap();
+        const leverageData = {};
+
+        for (const position of this.positions) {
+            const instrumentId = position.InstrumentID;
+            const sector = sectorMap[instrumentId] || 'N/A';
+            const leverage = position.Leverage;
+
+            if (!leverageData[sector]) {
+                leverageData[sector] = {};
+            }
+            leverageData[sector][leverage] = (leverageData[sector][leverage] || 0) + 1;
+        }
+
+        return {
+            leverage_per_sector: leverageData
+        };
+    }
+
+    reset() {
+        this.positions = [];
+    }
+}
+
 module.exports = LeveragePerSector;

package/calculations/speculators/risk_reward_ratio_per_asset.js

@@ -1,60 +1,60 @@
-/**
- * @fileoverview Calculates the average risk-reward ratio per asset from speculator positions.
- */
-const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
-
-class RiskRewardRatioPerAsset {
-    constructor() {
-        this.rrData = {};
-        this.mappings = null;
-    }
-
-    process(portfolioData, userId, context) {
-        if (portfolioData && portfolioData.PublicPositions) {
-            for (const position of portfolioData.PublicPositions) {
-                if (position.TakeProfitRate > 0 && position.StopLossRate > 0) {
-                    const instrumentId = position.InstrumentID;
-                    const openRate = position.OpenRate;
-                    const potentialReward = Math.abs(position.TakeProfitRate - openRate);
-                    const potentialRisk = Math.abs(openRate - position.StopLossRate);
-
-                    if (potentialRisk > 0) {
-                        const ratio = potentialReward / potentialRisk;
-                        if (!this.rrData[instrumentId]) {
-                            this.rrData[instrumentId] = { ratio_sum: 0, count: 0 };
-                        }
-                        this.rrData[instrumentId].ratio_sum += ratio;
-                        this.rrData[instrumentId].count++;
-                    }
-                }
-            }
-        }
-    }
-
-    async getResult() {
-        if (!this.mappings) {
-            this.mappings = await loadInstrumentMappings();
-        }
-        const result = {};
-        for (const instrumentId in this.rrData) {
-            const ticker = this.mappings.instrumentToTicker[instrumentId] || instrumentId.toString();
-            const data = this.rrData[instrumentId];
-
-            // REFACTOR: Perform the final calculation directly.
-            if (data.count > 0) {
-                result[ticker] = {
-                    average_ratio: data.ratio_sum / data.count
-                };
-            }
-        }
-
-        return result;
-    }
-
-    reset() {
-        this.rrData = {};
-        this.mappings = null;
-    }
-}
-
-module.exports = RiskRewardRatioPerAsset;
+/**
+ * @fileoverview Calculates the average risk-reward ratio per asset from speculator positions.
+ */
+const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
+
+class RiskRewardRatioPerAsset {
+    constructor() {
+        this.rrData = {};
+        this.mappings = null;
+    }
+
+    process(portfolioData, yesterdayPortfolio, userId, context) {
+        if (portfolioData && portfolioData.PublicPositions) {
+            for (const position of portfolioData.PublicPositions) {
+                if (position.TakeProfitRate > 0 && position.StopLossRate > 0) {
+                    const instrumentId = position.InstrumentID;
+                    const openRate = position.OpenRate;
+                    const potentialReward = Math.abs(position.TakeProfitRate - openRate);
+                    const potentialRisk = Math.abs(openRate - position.StopLossRate);
+
+                    if (potentialRisk > 0) {
+                        const ratio = potentialReward / potentialRisk;
+                        if (!this.rrData[instrumentId]) {
+                            this.rrData[instrumentId] = { ratio_sum: 0, count: 0 };
+                        }
+                        this.rrData[instrumentId].ratio_sum += ratio;
+                        this.rrData[instrumentId].count++;
+                    }
+                }
+            }
+        }
+    }
+
+    async getResult() {
+        if (!this.mappings) {
+            this.mappings = await loadInstrumentMappings();
+        }
+        const result = {};
+        for (const instrumentId in this.rrData) {
+            const ticker = this.mappings.instrumentToTicker[instrumentId] || instrumentId.toString();
+            const data = this.rrData[instrumentId];
+
+            // REFACTOR: Perform the final calculation directly.
+            if (data.count > 0) {
+                result[ticker] = {
+                    average_ratio: data.ratio_sum / data.count
+                };
+            }
+        }
+
+        return result;
+    }
+
+    reset() {
+        this.rrData = {};
+        this.mappings = null;
+    }
+}
+
+module.exports = RiskRewardRatioPerAsset;

package/calculations/speculators/speculator_asset_sentiment.js

@@ -1,81 +1,81 @@
-/**
- * Aggregates and calculates average P/L, leverage, SL, and TP data for longs vs. shorts
- * on a per-asset basis for speculators.
- */
-const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
-
-class SpeculatorAssetSentiment {
-    constructor() {
-        this.assets = {};
-        this.mappings = null;
-    }
-
-    _initAsset(instrumentId) {
-        if (!this.assets[instrumentId]) {
-            this.assets[instrumentId] = {
-                long: { count: 0, pnl_sum: 0, leverage_sum: 0, sl_rate_sum: 0, tp_rate_sum: 0 },
-                short: { count: 0, pnl_sum: 0, leverage_sum: 0, sl_rate_sum: 0, tp_rate_sum: 0 }
-            };
-        }
-    }
-
-    process(portfolioData, userId, context) {
-        const positions = portfolioData.PublicPositions;
-        if (!positions || !Array.isArray(positions)) return;
-
-        for (const position of positions) {
-            const instrumentId = position.InstrumentID;
-            if (!instrumentId) continue;
-
-            this._initAsset(instrumentId);
-
-            const direction = position.IsBuy ? 'long' : 'short';
-            const stats = this.assets[instrumentId][direction];
-
-            stats.count++;
-            stats.pnl_sum += position.NetProfit;
-            stats.leverage_sum += position.Leverage;
-
-            if (position.StopLossRate && position.StopLossRate > 0) {
-                stats.sl_rate_sum += position.StopLossRate;
-            }
-            if (position.TakeProfitRate && position.TakeProfitRate > 0) {
-                stats.tp_rate_sum += position.TakeProfitRate;
-            }
-        }
-    }
-
-    async getResult() {
-        if (!this.mappings) {
-            this.mappings = await loadInstrumentMappings();
-        }
-
-        const finalResult = {};
-
-        for (const instrumentId in this.assets) {
-            const ticker = this.mappings.instrumentToTicker[instrumentId] || instrumentId.toString();
-            finalResult[ticker] = {};
-
-            for (const direction in this.assets[instrumentId]) {
-                const stats = this.assets[instrumentId][direction];
-                // REFACTOR: Perform final calculations.
-                finalResult[ticker][direction] = {
-                    count: stats.count,
-                    average_pnl: stats.count > 0 ? stats.pnl_sum / stats.count : 0,
-                    average_leverage: stats.count > 0 ? stats.leverage_sum / stats.count : 0,
-                    average_sl_rate: stats.count > 0 ? stats.sl_rate_sum / stats.count : 0,
-                    average_tp_rate: stats.count > 0 ? stats.tp_rate_sum / stats.count : 0,
-                };
-            }
-        }
-        
-        return finalResult;
-    }
-
-    reset() {
-        this.assets = {};
-        this.mappings = null;
-    }
-}
-
-module.exports = SpeculatorAssetSentiment;
+/**
+ * Aggregates and calculates average P/L, leverage, SL, and TP data for longs vs. shorts
+ * on a per-asset basis for speculators.
+ */
+const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
+
+class SpeculatorAssetSentiment {
+    constructor() {
+        this.assets = {};
+        this.mappings = null;
+    }
+
+    _initAsset(instrumentId) {
+        if (!this.assets[instrumentId]) {
+            this.assets[instrumentId] = {
+                long: { count: 0, pnl_sum: 0, leverage_sum: 0, sl_rate_sum: 0, tp_rate_sum: 0 },
+                short: { count: 0, pnl_sum: 0, leverage_sum: 0, sl_rate_sum: 0, tp_rate_sum: 0 }
+            };
+        }
+    }
+
+    process(portfolioData, yesterdayPortfolio, userId, context) {
+        const positions = portfolioData.PublicPositions;
+        if (!positions || !Array.isArray(positions)) return;
+
+        for (const position of positions) {
+            const instrumentId = position.InstrumentID;
+            if (!instrumentId) continue;
+
+            this._initAsset(instrumentId);
+
+            const direction = position.IsBuy ? 'long' : 'short';
+            const stats = this.assets[instrumentId][direction];
+
+            stats.count++;
+            stats.pnl_sum += position.NetProfit;
+            stats.leverage_sum += position.Leverage;
+
+            if (position.StopLossRate && position.StopLossRate > 0) {
+                stats.sl_rate_sum += position.StopLossRate;
+            }
+            if (position.TakeProfitRate && position.TakeProfitRate > 0) {
+                stats.tp_rate_sum += position.TakeProfitRate;
+            }
+        }
+    }
+
+    async getResult() {
+        if (!this.mappings) {
+            this.mappings = await loadInstrumentMappings();
+        }
+
+        const finalResult = {};
+
+        for (const instrumentId in this.assets) {
+            const ticker = this.mappings.instrumentToTicker[instrumentId] || instrumentId.toString();
+            finalResult[ticker] = {};
+
+            for (const direction in this.assets[instrumentId]) {
+                const stats = this.assets[instrumentId][direction];
+                // REFACTOR: Perform final calculations.
+                finalResult[ticker][direction] = {
+                    count: stats.count,
+                    average_pnl: stats.count > 0 ? stats.pnl_sum / stats.count : 0,
+                    average_leverage: stats.count > 0 ? stats.leverage_sum / stats.count : 0,
+                    average_sl_rate: stats.count > 0 ? stats.sl_rate_sum / stats.count : 0,
+                    average_tp_rate: stats.count > 0 ? stats.tp_rate_sum / stats.count : 0,
+                };
+            }
+        }
+        
+        return finalResult;
+    }
+
+    reset() {
+        this.assets = {};
+        this.mappings = null;
+    }
+}
+
+module.exports = SpeculatorAssetSentiment;