aiden-shared-calculations-unified 1.0.7 → 1.0.9

package/calculations/speculators/stop_loss_distance_by_ticker_short_long_breakdown.js

@@ -1,73 +1,73 @@
-/**
- * @fileoverview Calculates the average stop loss distance (percent and value)
- * for long and short positions, grouped by TICKER.
- */
-const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
-
-class StopLossDistanceByTicker {
-    constructor() {
-        this.instrumentData = {};
-        this.instrumentToTicker = null;
-    }
-
-    process(portfolioData, userId) {
-        if (!portfolioData || !portfolioData.PublicPositions) return;
-
-        for (const position of portfolioData.PublicPositions) {
-            const { InstrumentID, Leverage, StopLossRate, CurrentRate, IsBuy } = position;
-            if (Leverage <= 1 || StopLossRate <= 0.0001 || CurrentRate <= 0) continue;
-
-            const distance_value = IsBuy ? CurrentRate - StopLossRate : StopLossRate - CurrentRate;
-            const distance_percent = (distance_value / CurrentRate) * 100;
-
-            if (distance_percent > 0) {
-                const posType = IsBuy ? 'long' : 'short';
-                if (!this.instrumentData[InstrumentID]) this.instrumentData[InstrumentID] = {};
-                if (!this.instrumentData[InstrumentID][posType]) {
-                    this.instrumentData[InstrumentID][posType] = {
-                        distance_percent_sum: 0,
-                        distance_value_sum: 0,
-                        count: 0
-                    };
-                }
-                const agg = this.instrumentData[InstrumentID][posType];
-                agg.distance_percent_sum += distance_percent;
-                agg.distance_value_sum += distance_value;
-                agg.count++;
-            }
-        }
-    }
-
-    async getResult() {
-        if (Object.keys(this.instrumentData).length === 0) return {};
-        if (!this.instrumentToTicker) {
-            const mappings = await loadInstrumentMappings();
-            this.instrumentToTicker = mappings.instrumentToTicker;
-        }
-
-        const result = {};
-        for (const instrumentId in this.instrumentData) {
-            const ticker = this.instrumentToTicker[instrumentId] || `unknown_${instrumentId}`;
-            if (!result[ticker]) result[ticker] = {};
-
-            for (const posType in this.instrumentData[instrumentId]) {
-                const data = this.instrumentData[instrumentId][posType];
-                // REFACTOR: Perform final calculation and return in standardized format.
-                if (data.count > 0) {
-                    result[ticker][posType] = {
-                        average_distance_percent: data.distance_percent_sum / data.count,
-                        average_distance_value: data.distance_value_sum / data.count,
-                        count: data.count
-                    };
-                }
-            }
-        }
-        return result;
-    }
-
-    reset() {
-        this.instrumentData = {};
-    }
-}
-
-module.exports = StopLossDistanceByTicker;
+/**
+ * @fileoverview Calculates the average stop loss distance (percent and value)
+ * for long and short positions, grouped by TICKER.
+ */
+const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
+
+class StopLossDistanceByTicker {
+    constructor() {
+        this.instrumentData = {};
+        this.instrumentToTicker = null;
+    }
+
+    process(portfolioData, yesterdayPortfolio, userId, context) {
+        if (!portfolioData || !portfolioData.PublicPositions) return;
+
+        for (const position of portfolioData.PublicPositions) {
+            const { InstrumentID, Leverage, StopLossRate, CurrentRate, IsBuy } = position;
+            if (Leverage <= 1 || StopLossRate <= 0.0001 || CurrentRate <= 0) continue;
+
+            const distance_value = IsBuy ? CurrentRate - StopLossRate : StopLossRate - CurrentRate;
+            const distance_percent = (distance_value / CurrentRate) * 100;
+
+            if (distance_percent > 0) {
+                const posType = IsBuy ? 'long' : 'short';
+                if (!this.instrumentData[InstrumentID]) this.instrumentData[InstrumentID] = {};
+                if (!this.instrumentData[InstrumentID][posType]) {
+                    this.instrumentData[InstrumentID][posType] = {
+                        distance_percent_sum: 0,
+                        distance_value_sum: 0,
+                        count: 0
+                    };
+                }
+                const agg = this.instrumentData[InstrumentID][posType];
+                agg.distance_percent_sum += distance_percent;
+                agg.distance_value_sum += distance_value;
+                agg.count++;
+            }
+        }
+    }
+
+    async getResult() {
+        if (Object.keys(this.instrumentData).length === 0) return {};
+        if (!this.instrumentToTicker) {
+            const mappings = await loadInstrumentMappings();
+            this.instrumentToTicker = mappings.instrumentToTicker;
+        }
+
+        const result = {};
+        for (const instrumentId in this.instrumentData) {
+            const ticker = this.instrumentToTicker[instrumentId] || `unknown_${instrumentId}`;
+            if (!result[ticker]) result[ticker] = {};
+
+            for (const posType in this.instrumentData[instrumentId]) {
+                const data = this.instrumentData[instrumentId][posType];
+                // REFACTOR: Perform final calculation and return in standardized format.
+                if (data.count > 0) {
+                    result[ticker][posType] = {
+                        average_distance_percent: data.distance_percent_sum / data.count,
+                        average_distance_value: data.distance_value_sum / data.count,
+                        count: data.count
+                    };
+                }
+            }
+        }
+        return result;
+    }
+
+    reset() {
+        this.instrumentData = {};
+    }
+}
+
+module.exports = StopLossDistanceByTicker;

package/calculations/speculators/stop_loss_per_asset.js

@@ -1,55 +1,55 @@
-/**
- * @fileoverview Calculates the average stop loss level per asset.
- */
-const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
-
-class StopLossPerAsset {
-    constructor() {
-        this.stopLossData = {};
-        this.mappings = null;
-    }
-
-    process(portfolioData, userId) {
-        if (portfolioData && portfolioData.PublicPositions) {
-            for (const position of portfolioData.PublicPositions) {
-                const instrumentId = position.InstrumentID;
-                const stopLoss = position.StopLossRate;
-
-                if (stopLoss > 0) {
-                    if (!this.stopLossData[instrumentId]) {
-                        this.stopLossData[instrumentId] = { sum: 0, count: 0 };
-                    }
-                    this.stopLossData[instrumentId].sum += stopLoss;
-                    this.stopLossData[instrumentId].count++;
-                }
-            }
-        }
-    }
-
-    async getResult() {
-        if (!this.mappings) {
-            this.mappings = await loadInstrumentMappings();
-        }
-        const result = {};
-        for (const instrumentId in this.stopLossData) {
-            const ticker = this.mappings.instrumentToTicker[instrumentId] || instrumentId.toString();
-            const data = this.stopLossData[instrumentId];
-            
-            // REFACTOR: Perform final calculation directly.
-            if (data.count > 0) {
-                result[ticker] = {
-                    average_stop_loss: data.sum / data.count
-                };
-            }
-        }
-        
-        return result;
-    }
-
-    reset() {
-        this.stopLossData = {};
-        this.mappings = null;
-    }
-}
-
-module.exports = StopLossPerAsset;
+/**
+ * @fileoverview Calculates the average stop loss level per asset.
+ */
+const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
+
+class StopLossPerAsset {
+    constructor() {
+        this.stopLossData = {};
+        this.mappings = null;
+    }
+
+    process(portfolioData, yesterdayPortfolio, userId, context) {
+        if (portfolioData && portfolioData.PublicPositions) {
+            for (const position of portfolioData.PublicPositions) {
+                const instrumentId = position.InstrumentID;
+                const stopLoss = position.StopLossRate;
+
+                if (stopLoss > 0) {
+                    if (!this.stopLossData[instrumentId]) {
+                        this.stopLossData[instrumentId] = { sum: 0, count: 0 };
+                    }
+                    this.stopLossData[instrumentId].sum += stopLoss;
+                    this.stopLossData[instrumentId].count++;
+                }
+            }
+        }
+    }
+
+    async getResult() {
+        if (!this.mappings) {
+            this.mappings = await loadInstrumentMappings();
+        }
+        const result = {};
+        for (const instrumentId in this.stopLossData) {
+            const ticker = this.mappings.instrumentToTicker[instrumentId] || instrumentId.toString();
+            const data = this.stopLossData[instrumentId];
+            
+            // REFACTOR: Perform final calculation directly.
+            if (data.count > 0) {
+                result[ticker] = {
+                    average_stop_loss: data.sum / data.count
+                };
+            }
+        }
+        
+        return result;
+    }
+
+    reset() {
+        this.stopLossData = {};
+        this.mappings = null;
+    }
+}
+
+module.exports = StopLossPerAsset;

package/calculations/speculators/take_profit_per_asset.js

@@ -1,55 +1,55 @@
-/**
- * @fileoverview Calculates the average take profit level per asset.
- */
-const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
-
-class TakeProfitPerAsset {
-    constructor() {
-        this.takeProfitData = {};
-        this.mappings = null;
-    }
-
-    process(portfolioData, userId) {
-        if (portfolioData && portfolioData.PublicPositions) {
-            for (const position of portfolioData.PublicPositions) {
-                const instrumentId = position.InstrumentID;
-                const takeProfit = position.TakeProfitRate;
-
-                if (takeProfit > 0) {
-                    if (!this.takeProfitData[instrumentId]) {
-                        this.takeProfitData[instrumentId] = { sum: 0, count: 0 };
-                    }
-                    this.takeProfitData[instrumentId].sum += takeProfit;
-                    this.takeProfitData[instrumentId].count++;
-                }
-            }
-        }
-    }
-
-    async getResult() {
-        if (!this.mappings) {
-            this.mappings = await loadInstrumentMappings();
-        }
-        const result = {};
-        for (const instrumentId in this.takeProfitData) {
-            const ticker = this.mappings.instrumentToTicker[instrumentId] || instrumentId.toString();
-            const data = this.takeProfitData[instrumentId];
-
-            // REFACTOR: Perform final calculation directly.
-            if (data.count > 0) {
-                result[ticker] = {
-                    average_take_profit: data.sum / data.count
-                };
-            }
-        }
-
-        return result;
-    }
-
-    reset() {
-        this.takeProfitData = {};
-        this.mappings = null;
-    }
-}
-
-module.exports = TakeProfitPerAsset;
+/**
+ * @fileoverview Calculates the average take profit level per asset.
+ */
+const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
+
+class TakeProfitPerAsset {
+    constructor() {
+        this.takeProfitData = {};
+        this.mappings = null;
+    }
+
+    process(portfolioData, yesterdayPortfolio, userId, context) {
+        if (portfolioData && portfolioData.PublicPositions) {
+            for (const position of portfolioData.PublicPositions) {
+                const instrumentId = position.InstrumentID;
+                const takeProfit = position.TakeProfitRate;
+
+                if (takeProfit > 0) {
+                    if (!this.takeProfitData[instrumentId]) {
+                        this.takeProfitData[instrumentId] = { sum: 0, count: 0 };
+                    }
+                    this.takeProfitData[instrumentId].sum += takeProfit;
+                    this.takeProfitData[instrumentId].count++;
+                }
+            }
+        }
+    }
+
+    async getResult() {
+        if (!this.mappings) {
+            this.mappings = await loadInstrumentMappings();
+        }
+        const result = {};
+        for (const instrumentId in this.takeProfitData) {
+            const ticker = this.mappings.instrumentToTicker[instrumentId] || instrumentId.toString();
+            const data = this.takeProfitData[instrumentId];
+
+            // REFACTOR: Perform final calculation directly.
+            if (data.count > 0) {
+                result[ticker] = {
+                    average_take_profit: data.sum / data.count
+                };
+            }
+        }
+
+        return result;
+    }
+
+    reset() {
+        this.takeProfitData = {};
+        this.mappings = null;
+    }
+}
+
+module.exports = TakeProfitPerAsset;

package/calculations/speculators/tsl_per_asset.js

@@ -1,52 +1,52 @@
-/**
- * @fileoverview Counts how many users have TSL enabled vs. disabled per asset.
- */
-const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
-
-class TslPerAsset {
-    constructor() {
-        this.tslData = {};
-        this.mappings = null;
-    }
-
-    process(portfolioData, userId) {
-        if (portfolioData && portfolioData.PublicPositions) {
-            for (const position of portfolioData.PublicPositions) {
-                const instrumentId = position.InstrumentID;
-                const isTslEnabled = position.IsTslEnabled;
-
-                if (!this.tslData[instrumentId]) {
-                    this.tslData[instrumentId] = { enabled: 0, disabled: 0 };
-                }
-
-                if (isTslEnabled) {
-                    this.tslData[instrumentId].enabled++;
-                } else {
-                    this.tslData[instrumentId].disabled++;
-                }
-            }
-        }
-    }
-
-    async getResult() {
-        if (!this.mappings) {
-            this.mappings = await loadInstrumentMappings();
-        }
-        const result = {};
-        for (const instrumentId in this.tslData) {
-            const ticker = this.mappings.instrumentToTicker[instrumentId] || instrumentId.toString();
-            result[ticker] = this.tslData[instrumentId];
-        }
-        if (Object.keys(result).length === 0) return {};
-        return {
-            tsl_per_asset: result
-        };
-    }
-
-    reset() {
-        this.tslData = {};
-        this.mappings = null;
-    }
-}
-
+/**
+ * @fileoverview Counts how many users have TSL enabled vs. disabled per asset.
+ */
+const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
+
+class TslPerAsset {
+    constructor() {
+        this.tslData = {};
+        this.mappings = null;
+    }
+
+    process(portfolioData, yesterdayPortfolio, userId, context) {
+        if (portfolioData && portfolioData.PublicPositions) {
+            for (const position of portfolioData.PublicPositions) {
+                const instrumentId = position.InstrumentID;
+                const isTslEnabled = position.IsTslEnabled;
+
+                if (!this.tslData[instrumentId]) {
+                    this.tslData[instrumentId] = { enabled: 0, disabled: 0 };
+                }
+
+                if (isTslEnabled) {
+                    this.tslData[instrumentId].enabled++;
+                } else {
+                    this.tslData[instrumentId].disabled++;
+                }
+            }
+        }
+    }
+
+    async getResult() {
+        if (!this.mappings) {
+            this.mappings = await loadInstrumentMappings();
+        }
+        const result = {};
+        for (const instrumentId in this.tslData) {
+            const ticker = this.mappings.instrumentToTicker[instrumentId] || instrumentId.toString();
+            result[ticker] = this.tslData[instrumentId];
+        }
+        if (Object.keys(result).length === 0) return {};
+        return {
+            tsl_per_asset: result
+        };
+    }
+
+    reset() {
+        this.tslData = {};
+        this.mappings = null;
+    }
+}
+
 module.exports = TslPerAsset;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aiden-shared-calculations-unified",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "description": "Shared calculation modules for the BullTrackers Computation System.",
   "main": "index.js",
   "files": [