aiden-shared-calculations-unified 1.0.22 → 1.0.23

package/calculations/activity/historical/daily_user_activity_tracker.js

@@ -0,0 +1,144 @@
+/**
+ * @fileoverview Tracks user activity by comparing portfolio snapshots.
+ * This is a historical calculation that defines an "active user" as someone
+ * who has opened, closed, or reallocated a position within the last 24 hours.
+ *
+ * This provides the "Daily Active Users" count for the monitored cohort.
+ * This depreciates the user activity sampler cloud function which was inefficient for the api usage and now provides this data for free
+ */
+
+class DailyUserActivityTracker {
+    constructor() {
+        this.activeUserIds = new Set();
+        this.activityEvents = {
+            new_position: 0,
+            closed_position: 0,
+            reallocation: 0
+        };
+    }
+
+    /**
+     * Helper to get a simplified map of positions for comparison.
+     * @param {object} portfolio - A user's full portfolio object.
+     * @returns {object} { posMap: Map<InstrumentID, {invested: number}>, hasAggregated: boolean }
+     */
+    _getPortfolioMaps(portfolio) {
+        // Prioritize AggregatedPositions, but fall back to PublicPositions
+        const positions = portfolio?.AggregatedPositions || portfolio?.PublicPositions;
+        if (!positions || !Array.isArray(positions)) {
+            return { posMap: new Map(), hasAggregated: false };
+        }
+
+        const posMap = new Map();
+        for (const pos of positions) {
+            const key = pos.InstrumentID;
+            if (key) {
+                posMap.set(key, {
+                    // 'InvestedAmount' or 'Invested' is the portfolio percentage
+                    // We use this for reallocation logic.
+                    invested: pos.InvestedAmount || pos.Invested || pos.Amount || 0
+                });
+            }
+        }
+        // Return the map and a flag indicating if we can trust the 'invested' field
+        return { posMap, hasAggregated: !!portfolio.AggregatedPositions };
+    }
+
+    /**
+     * Processes a single user's daily data.
+     */
+    process(todayPortfolio, yesterdayPortfolio, userId) {
+        // This calculation requires both days to find changes.
+        if (!todayPortfolio || !yesterdayPortfolio) {
+            return;
+        }
+
+        const { posMap: yPosMap, hasAggregated: yHasAgg } = this._getPortfolioMaps(yesterdayPortfolio);
+        const { posMap: tPosMap, hasAggregated: tHasAgg } = this._getPortfolioMaps(todayPortfolio);
+
+        // Skip if user has no positions on either day
+        if (tPosMap.size === 0 && yPosMap.size === 0) {
+            return;
+        }
+
+        const yIds = new Set(yPosMap.keys());
+        const tIds = new Set(tPosMap.keys());
+        let isActive = false;
+
+        // 1. Check for new positions (high-confidence activity)
+        for (const tId of tIds) {
+            if (!yIds.has(tId)) {
+                isActive = true;
+                this.activityEvents.new_position++;
+                break; // Found activity, no need to check more
+            }
+        }
+
+        if (isActive) {
+            this.activeUserIds.add(userId);
+            return;
+        }
+
+        // 2. Check for closed positions (high-confidence activity)
+        for (const yId of yIds) {
+            if (!tIds.has(yId)) {
+                isActive = true;
+                this.activityEvents.closed_position++;
+                break; // Found activity
+            }
+        }
+
+        if (isActive) {
+            this.activeUserIds.add(userId);
+            return;
+        }
+
+        // 3. Check for reallocation (only possible if we have AggregatedPositions for both days)
+        // This checks for changes in the 'Invested' percentage
+        if (yHasAgg && tHasAgg) {
+            for (const tId of tIds) {
+                // We know tId is also in yIds from the checks above
+                const tInvested = tPosMap.get(tId).invested;
+                const yInvested = yPosMap.get(yId).invested;
+
+                // Check for a meaningful change (e.g., > 0.01% to avoid float noise)
+                if (Math.abs(tInvested - yInvested) > 0.0001) {
+                    isActive = true;
+                    this.activityEvents.reallocation++;
+                    break; // Found activity
+                }
+            }
+        }
+
+        if (isActive) {
+            this.activeUserIds.add(userId);
+        }
+    }
+
+    /**
+     * Returns the final aggregated counts for the day.
+     */
+    getResult() {
+        return {
+            // This is the main metric for your graph
+            rawActiveUserCount: this.activeUserIds.size,
+            
+            // This is a bonus metric to see *what* users are doing
+            activityBreakdown: this.activityEvents
+        };
+    }
+
+    /**
+     * Resets the counters for the next run.
+     */
+    reset() {
+        this.activeUserIds.clear();
+        this.activityEvents = {
+            new_position: 0,
+            closed_position: 0,
+            reallocation: 0
+        };
+    }
+}
+
+module.exports = DailyUserActivityTracker;

package/package.json

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