bulltrackers-module 1.0.554 → 1.0.556

package/functions/alert-system/helpers/alert_helpers.js

@@ -18,7 +18,7 @@ async function processAlertForPI(db, logger, piCid, alertType, computationMetada
     
     // 2. Find all users subscribed to this PI and alert type
     // Use computationName (e.g., 'RiskScoreIncrease') to map to alertConfig keys
-    const subscriptions = await findSubscriptionsForPI(db, logger, piCid, alertType.computationName);
+    const subscriptions = await findSubscriptionsForPI(db, logger, piCid, alertType.computationName, computationDate, dependencies);
     
     if (subscriptions.length === 0) {
       logger.log('INFO', `[processAlertForPI] No subscriptions found for PI ${piCid}, alert type ${alertType.id}`);
@@ -65,7 +65,6 @@ async function processAlertForPI(db, logger, piCid, alertType, computationMetada
       };
       
       // Use writeWithMigration to write to new path (with legacy fallback)
-      // notifications is a subcollection, so we need isCollection: true and documentId
       const writePromise = writeWithMigration(
         db,
         'signedInUsers',
@@ -92,10 +91,18 @@ async function processAlertForPI(db, logger, piCid, alertType, computationMetada
     // Wait for all notifications to be written
     await Promise.all(notificationPromises);
     
-    // 7. Update global rootdata collection for computation system
-    const { updateAlertHistoryRootData } = require('../../generic-api/user-api/helpers/rootdata/rootdata_aggregation_helpers');
-    const triggeredUserCids = subscriptions.map(s => s.userCid);
-    await updateAlertHistoryRootData(db, logger, piCid, alertType, computationMetadata, computationDate, triggeredUserCids);
+    // 5. Notify the PI themselves if they are a signed-in user (Optional feature)
+    await notifyPIIfSignedIn(db, logger, piCid, alertType, subscriptions.length);
+
+    // 6. Update global rootdata collection for computation system
+    // (Wrap in try-catch to prevent crashing the alert if metrics fail)
+    try {
+        const { updateAlertHistoryRootData } = require('../../generic-api/user-api/helpers/rootdata/rootdata_aggregation_helpers');
+        const triggeredUserCids = subscriptions.map(s => s.userCid);
+        await updateAlertHistoryRootData(db, logger, piCid, alertType, computationMetadata, computationDate, triggeredUserCids);
+    } catch (e) {
+        logger.log('WARN', `[processAlertForPI] Failed to update history rootdata: ${e.message}`);
+    }
     
     logger.log('SUCCESS', `[processAlertForPI] Created ${notificationPromises.length} notifications for PI ${piCid}, alert type ${alertType.id}`);
     
@@ -107,20 +114,19 @@ async function processAlertForPI(db, logger, piCid, alertType, computationMetada
 
 /**
  * Find all users who should receive alerts for a PI and alert type
- * Reads from actual watchlist structure: watchlists/{userCid}/lists/{watchlistId}
+ * Uses WatchlistMembershipData/{date} to find users, then reads watchlists from SignedInUsers/{cid}/watchlists
  */
-async function findSubscriptionsForPI(db, logger, piCid, alertTypeId) {
+async function findSubscriptionsForPI(db, logger, piCid, alertTypeId, computationDate, dependencies = {}) {
   const subscriptions = [];
   
   // Map computation names to watchlist alertConfig keys
-  // The alertTypeId is actually the computation name (e.g., 'RiskScoreIncrease')
   const computationToConfigKey = {
     'RiskScoreIncrease': 'increasedRisk',
     'SignificantVolatility': 'volatilityChanges',
     'NewSectorExposure': 'newSector',
     'PositionInvestedIncrease': 'increasedPositionSize',
     'NewSocialPost': 'newSocialPost',
-    'TestSystemProbe': 'increasedRisk' // Hack: Map to 'increasedRisk' so you receive it if you have Risk alerts on
+    'TestSystemProbe': 'increasedRisk' // Hack: Map to 'increasedRisk' key
   };
   
   const configKey = computationToConfigKey[alertTypeId];
@@ -129,7 +135,121 @@ async function findSubscriptionsForPI(db, logger, piCid, alertTypeId) {
     return subscriptions;
   }
   
-  // Get all watchlists
+  // Step 1: Load WatchlistMembershipData/{date} to find which users have this PI in their watchlist
+  const piCidStr = String(piCid);
+  let userCids = [];
+  
+  try {
+    const membershipRef = db.collection('WatchlistMembershipData').doc(computationDate);
+    const membershipDoc = await membershipRef.get();
+    
+    if (membershipDoc.exists) {
+      const membershipData = membershipDoc.data();
+      const piMembership = membershipData[piCidStr];
+      
+      if (piMembership && piMembership.users && Array.isArray(piMembership.users)) {
+        userCids = piMembership.users.map(cid => String(cid));
+        logger.log('INFO', `[findSubscriptionsForPI] Found ${userCids.length} users with PI ${piCid} in watchlist from WatchlistMembershipData/${computationDate}`);
+      } else {
+        logger.log('INFO', `[findSubscriptionsForPI] No users found for PI ${piCid} in WatchlistMembershipData/${computationDate}`);
+        return subscriptions;
+      }
+    } else {
+      logger.log('WARN', `[findSubscriptionsForPI] WatchlistMembershipData/${computationDate} not found, falling back to scanning all watchlists`);
+      // Fallback to legacy method if membership data doesn't exist
+      return await findSubscriptionsForPILegacy(db, logger, piCid, alertTypeId, configKey);
+    }
+  } catch (error) {
+    logger.log('ERROR', `[findSubscriptionsForPI] Error loading WatchlistMembershipData: ${error.message}`);
+    // Fallback to legacy method on error
+    return await findSubscriptionsForPILegacy(db, logger, piCid, alertTypeId, configKey);
+  }
+  
+  // Step 2: For each user, read their watchlists from SignedInUsers/{cid}/watchlists
+  const { readWithMigration } = require('../../generic-api/user-api/helpers/core/path_resolution_helpers');
+  const { collectionRegistry } = dependencies;
+  const config = dependencies.config || {};
+  
+  for (const userCidStr of userCids) {
+    try {
+      const userCid = Number(userCidStr);
+      
+      // Read all watchlists for this user from new path
+      const watchlistsResult = await readWithMigration(
+        db,
+        'signedInUsers',
+        'watchlists',
+        { cid: userCid },
+        {
+          isCollection: true,
+          dataType: 'watchlists',
+          config,
+          logger,
+          collectionRegistry: collectionRegistry
+        }
+      );
+      
+      if (!watchlistsResult) {
+        continue;
+      }
+      
+      // Get watchlists from snapshot or data
+      let watchlists = [];
+      if (watchlistsResult.snapshot && !watchlistsResult.snapshot.empty) {
+        watchlists = watchlistsResult.snapshot.docs.map(doc => ({
+          id: doc.id,
+          ...doc.data()
+        }));
+      } else if (watchlistsResult.data) {
+        // If it's a single document, wrap it
+        watchlists = [watchlistsResult.data];
+      }
+      
+      // Step 3: Check each watchlist for the PI and alert config
+      for (const watchlistData of watchlists) {
+        if (watchlistData.type === 'static' && watchlistData.items && Array.isArray(watchlistData.items)) {
+          for (const item of watchlistData.items) {
+            if (Number(item.cid) === Number(piCid)) {
+              // Check if this alert type is enabled
+              const isTestProbe = alertTypeId === 'TestSystemProbe';
+              const isEnabled = item.alertConfig && item.alertConfig[configKey] === true;
+              
+              // If it's the probe OR the user explicitly enabled it
+              if (isTestProbe || isEnabled) {
+                subscriptions.push({
+                  userCid: userCid,
+                  piCid: piCid,
+                  piUsername: item.username || `PI-${piCid}`,
+                  watchlistId: watchlistData.id || watchlistData.watchlistId,
+                  watchlistName: watchlistData.name || 'Unnamed Watchlist',
+                  alertConfig: item.alertConfig
+                });
+                break; // Found in this watchlist, no need to check other items
+              }
+            }
+          }
+        }
+      }
+    } catch (error) {
+      logger.log('WARN', `[findSubscriptionsForPI] Error reading watchlists for user ${userCidStr}: ${error.message}`);
+      // Continue with next user
+      continue;
+    }
+  }
+  
+  logger.log('INFO', `[findSubscriptionsForPI] Found ${subscriptions.length} subscriptions for PI ${piCid}, alert type ${alertTypeId}`);
+  return subscriptions;
+}
+
+/**
+ * Legacy fallback method - scans all watchlists (used if WatchlistMembershipData is not available)
+ */
+async function findSubscriptionsForPILegacy(db, logger, piCid, alertTypeId, configKey) {
+  const subscriptions = [];
+  
+  logger.log('INFO', `[findSubscriptionsForPILegacy] Using legacy method to find subscriptions for PI ${piCid}`);
+  
+  // Get all watchlists from legacy path
   const watchlistsCollection = db.collection('watchlists');
   const watchlistsSnapshot = await watchlistsCollection.get();
   
@@ -144,8 +264,10 @@ async function findSubscriptionsForPI(db, logger, piCid, alertTypeId) {
       if (listData.type === 'static' && listData.items && Array.isArray(listData.items)) {
         for (const item of listData.items) {
           if (Number(item.cid) === Number(piCid)) {
-            // Check if this alert type is enabled for this PI in this watchlist
-            if (item.alertConfig && item.alertConfig[configKey] === true) {
+            const isTestProbe = alertTypeId === 'TestSystemProbe';
+            const isEnabled = item.alertConfig && item.alertConfig[configKey] === true;
+            
+            if (isTestProbe || isEnabled) {
               subscriptions.push({
                 userCid: userCid,
                 piCid: piCid,
@@ -154,19 +276,14 @@ async function findSubscriptionsForPI(db, logger, piCid, alertTypeId) {
                 watchlistName: listData.name || 'Unnamed Watchlist',
                 alertConfig: item.alertConfig
               });
-              break; // Found in this watchlist, no need to check other items
+              break;
             }
           }
         }
       }
-      
-      // Check dynamic watchlists - if the PI matches the computation result, check alertConfig
-      // Note: Dynamic watchlists are handled separately as they're based on computation results
-      // For now, we only process static watchlists here
     }
   }
   
-  logger.log('INFO', `[findSubscriptionsForPI] Found ${subscriptions.length} subscriptions for PI ${piCid}, alert type ${alertTypeId}`);
   return subscriptions;
 }
 
@@ -178,10 +295,6 @@ function shouldTriggerAlert(subscription, alertTypeId) {
   if (!subscription.thresholds || Object.keys(subscription.thresholds).length === 0) {
     return true;
   }
-  
-  // Threshold checking logic would go here
-  // For now, we'll implement basic threshold checks in the trigger function
-  // This is a placeholder for future enhancement
   return true;
 }
 
@@ -195,9 +308,7 @@ async function getPIUsername(db, piCid) {
     const { getPIUsernameFromMasterList } = require('../../generic-api/user-api/helpers/core/user_status_helpers');
     const username = await getPIUsernameFromMasterList(db, piCid, null, null);
     
-    if (username) {
-      return username;
-    }
+    if (username) return username;
     
     // Fallback: try to get from any subscription
     const subscriptionsSnapshot = await db.collection('watchlist_subscriptions')
@@ -221,18 +332,14 @@ async function getPIUsername(db, piCid) {
  */
 async function notifyPIIfSignedIn(db, logger, piCid, alertType, alertCount) {
   try {
-    // Check if this PI is a signed-in user
-    const userRef = db.collection('signed_in_users').doc(String(piCid));
+    const userRef = db.collection('signedInUsers').doc(String(piCid));
     const userDoc = await userRef.get();
     
-    if (!userDoc.exists) {
-      return; // Not a signed-in user
-    }
-    
-    // Create a notification for the PI
-    const notificationRef = db.collection('user_alerts')
+    if (!userDoc.exists) return; 
+
+    const notificationRef = db.collection('signedInUsers')
       .doc(String(piCid))
-      .collection('triggered')
+      .collection('user_alerts_metrics') // Changed from user_alerts/triggered to avoid collision
       .doc(`trigger_${Date.now()}_${alertType.id}`);
     
     await notificationRef.set({
@@ -246,8 +353,8 @@ async function notifyPIIfSignedIn(db, logger, piCid, alertType, alertCount) {
     
     logger.log('INFO', `[notifyPIIfSignedIn] Notified PI ${piCid} that ${alertCount} users received ${alertType.id} alert`);
   } catch (error) {
-    logger.log('WARN', `[notifyPIIfSignedIn] Error notifying PI ${piCid}`, error);
-    // Don't throw - this is optional
+    // Silent fail - non-critical
+    logger.log('DEBUG', `[notifyPIIfSignedIn] Skipped for PI ${piCid}`);
   }
 }
 
@@ -290,25 +397,17 @@ function tryDecompress(data) {
 
 /**
  * Read and decompress computation results
- * Handles two result formats:
- * 1. { cids: [...], metadata: {...} } - Global metadata
- * 2. { cids: [...], userId1: {...}, userId2: {...} } - Per-user metadata
  */
 function readComputationResults(docData) {
   try {
-    // Try to decompress if needed
     const decompressed = tryDecompress(docData);
     
-    // If decompressed is an object with cids, return it
     if (decompressed && typeof decompressed === 'object') {
-      // Handle structure: { cids: [...], metadata: {...} }
       if (decompressed.cids && Array.isArray(decompressed.cids)) {
-        // Check if there's per-user data (keys that are numbers)
         const userDataKeys = Object.keys(decompressed)
           .filter(key => key !== 'cids' && key !== 'metadata' && /^\d+$/.test(key));
         
         if (userDataKeys.length > 0) {
-          // Format 2: Per-user metadata stored as { cids: [...], userId: {...} }
           return {
             cids: decompressed.cids,
             perUserData: userDataKeys.reduce((acc, key) => {
@@ -318,7 +417,6 @@ function readComputationResults(docData) {
             globalMetadata: decompressed.metadata || {}
           };
         } else {
-          // Format 1: Global metadata
           return {
             cids: decompressed.cids,
             metadata: decompressed.metadata || {}
@@ -326,7 +424,6 @@ function readComputationResults(docData) {
         }
       }
       
-      // If it's a flat object with CID keys but no cids array, extract them
       const cids = Object.keys(decompressed)
         .filter(key => /^\d+$/.test(key))
         .map(key => Number(key));
@@ -344,7 +441,6 @@ function readComputationResults(docData) {
         };
       }
     }
-    
     return { cids: [], metadata: {}, perUserData: {} };
   } catch (error) {
     console.error('[readComputationResults] Error reading results', error);
@@ -357,9 +453,7 @@ function readComputationResults(docData) {
  */
 async function readComputationResultsWithShards(db, docData, docRef) {
   try {
-    // Check if data is sharded
     if (docData._sharded === true && docData._shardCount) {
-      // Data is stored in shards - read all shards and merge
       const shardsCol = docRef.collection('_shards');
       const shardsSnapshot = await shardsCol.get();
       
@@ -373,8 +467,6 @@ async function readComputationResultsWithShards(db, docData, docRef) {
         return readComputationResults(mergedData);
       }
     }
-    
-    // Data is in the main document (compressed or not)
     return readComputationResults(docData);
   } catch (error) {
     console.error('[readComputationResultsWithShards] Error reading sharded results', error);
@@ -387,6 +479,6 @@ module.exports = {
   findSubscriptionsForPI,
   getPIUsername,
   readComputationResults,
-  readComputationResultsWithShards
-};
-
+  readComputationResultsWithShards,
+  notifyPIIfSignedIn // Exporting this as well since it's defined
+};

package/functions/computation-system/helpers/computation_dispatcher.js

@@ -132,7 +132,6 @@ async function getStableDateSession(config, dependencies, passToRun, dateLimitSt
     return allDates;
 }
 
-// =============================================================================
 // MAIN ENTRY POINT
 // =============================================================================
 async function dispatchComputationPass(config, dependencies, computationManifest, reqBody = {}) {
@@ -144,14 +143,100 @@ async function dispatchComputationPass(config, dependencies, computationManifest
     else if (action === 'SWEEP') {
         return handleSweepDispatch(config, dependencies, computationManifest, reqBody);
     }
-    // [NEW] Handler for Final Forensics Reporting
     else if (action === 'REPORT') {
         return handleFinalSweepReporting(config, dependencies, computationManifest, reqBody);
     }
+    // [NEW] FORCE RUN HANDLER
+    else if (action === 'FORCE_RUN') {
+        return handleForceRun(config, dependencies, computationManifest, reqBody);
+    }
     
     return handleStandardDispatch(config, dependencies, computationManifest, reqBody);
 }
 
+// =============================================================================
+// NEW: Force Run Handler (Bypasses Checks)
+// =============================================================================
+async function handleForceRun(config, dependencies, computationManifest, reqBody) {
+    const { logger } = dependencies;
+    const pubsubUtils = new PubSubUtils(dependencies);
+    const computationName = reqBody.computation; // Required
+    const dateInput = reqBody.date;              // Optional (YYYY-MM-DD)
+    
+    if (!computationName) {
+        throw new Error('Force Run requires "computation" name.');
+    }
+
+    // 1. Verify Computation Exists
+    const manifestItem = computationManifest.find(c => normalizeName(c.name) === normalizeName(computationName));
+    if (!manifestItem) {
+        throw new Error(`Computation '${computationName}' not found in manifest.`);
+    }
+
+    // 2. Determine Target Dates
+    let targetDates = [];
+    if (dateInput) {
+        // Single Date Mode
+        targetDates = [dateInput];
+    } else {
+        // All Dates Mode (Backfill)
+        logger.log('INFO', `[ForceRun] No date provided. Calculating date range for ${computationName}...`);
+        const earliestDates = await getEarliestDataDates(config, dependencies);
+        // Calculate from system start until today
+        targetDates = getExpectedDateStrings(earliestDates.absoluteEarliest, new Date());
+    }
+    
+    logger.log('WARN', `[ForceRun] 🚨 MANUALLY Triggering ${computationName} for ${targetDates.length} dates. Pass: ${manifestItem.pass}`);
+
+    // 3. Construct Tasks
+    const dispatchId = crypto.randomUUID();
+    const tasks = targetDates.map(date => {
+        const traceId = crypto.randomBytes(16).toString('hex');
+        const spanId = crypto.randomBytes(8).toString('hex');
+        return {
+            action: 'RUN_COMPUTATION_DATE',
+            computation: manifestItem.name,
+            date: date,
+            pass: manifestItem.pass || "1",
+            dispatchId: dispatchId,
+            triggerReason: 'MANUAL_FORCE_API',
+            resources: reqBody.resources || 'standard',
+            // Trace context allows you to find these specific runs in Cloud Trace
+            traceContext: { traceId, spanId, sampled: true }
+        };
+    });
+
+    // 4. Batch Publish (Chunked to stay under Pub/Sub limits)
+    const CHUNK_SIZE = 250; // Safe batch size
+    const topic = (reqBody.resources === 'high-mem') 
+        ? (config.computationTopicHighMem || 'computation-tasks-highmem')
+        : (config.computationTopicStandard || 'computation-tasks');
+        
+    let dispatchedCount = 0;
+    const chunks = [];
+    for (let i = 0; i < tasks.length; i += CHUNK_SIZE) {
+        chunks.push(tasks.slice(i, i + CHUNK_SIZE));
+    }
+
+    // Publish chunks sequentially to avoid memory spikes
+    for (const chunk of chunks) {
+        await pubsubUtils.batchPublishTasks(dependencies, {
+            topicName: topic,
+            tasks: chunk,
+            taskType: 'manual-force-run'
+        });
+        dispatchedCount += chunk.length;
+    }
+
+    return { 
+        status: 'FORCED',
+        computation: computationName,
+        mode: dateInput ? 'SINGLE_DATE' : 'ALL_DATES',
+        datesTriggered: dispatchedCount,
+        targetTopic: topic
+    };
+}
+
 // =============================================================================
 // NEW: Final Sweep Reporting Handler
 // =============================================================================

package/functions/computation-system/scripts/force_run.js

@@ -0,0 +1,72 @@
+/**
+ * Force Run Control Script
+ * Usage: 
+ * node scripts/force_run.js <ComputationName> [YYYY-MM-DD]
+ * * Examples:
+ * node scripts/force_run.js TestSystemProbe 2026-01-02  (Runs specific day)
+ * node scripts/force_run.js TestSystemProbe             (Runs ALL days from start)
+ */
+
+require('dotenv').config(); // Load environment variables
+const { PubSub } = require('@google-cloud/pubsub');
+
+// CONFIGURATION
+const PROJECT_ID = process.env.GCP_PROJECT_ID || 'stocks-12345';
+const TOPIC_NAME = process.env.PUBSUB_TOPIC_DISPATCH || 'dispatch-topic'; // Must match orchestrator_config.js
+const SYSTEM_START_DATE = '2026-01-01'; // The beginning of time for your system
+
+async function main() {
+  const args = process.argv.slice(2);
+  const computationName = args[0];
+  const specificDate = args[1];
+
+  if (!computationName) {
+    console.error('❌ Error: Computation Name is required.');
+    console.log('Usage: node scripts/force_run.js <ComputationName> [YYYY-MM-DD]');
+    process.exit(1);
+  }
+
+  const pubsub = new PubSub({ projectId: PROJECT_ID });
+  const topic = pubsub.topic(TOPIC_NAME);
+
+  // 1. Logic: Single Date vs. All Dates
+  if (specificDate) {
+    await triggerComputation(topic, computationName, specificDate);
+  } else {
+    console.log(`⚠️  No date provided. Triggering REPLAY for ${computationName} from ${SYSTEM_START_DATE} to Today...`);
+    
+    let currentDate = new Date(SYSTEM_START_DATE);
+    const today = new Date();
+
+    while (currentDate <= today) {
+      const dateStr = currentDate.toISOString().split('T')[0];
+      await triggerComputation(topic, computationName, dateStr);
+      
+      // Move to next day
+      currentDate.setDate(currentDate.getDate() + 1);
+      
+      // Small throttle to prevent flooding Pub/Sub quota if years of data
+      await new Promise(r => setTimeout(r, 100)); 
+    }
+  }
+}
+
+async function triggerComputation(topic, computation, date) {
+  const payload = {
+    computationName: computation,
+    date: date,
+    force: true,      // Tells Orchestrator to ignore "Already Complete" status
+    source: 'manual-cli' // Audit trail
+  };
+
+  const dataBuffer = Buffer.from(JSON.stringify(payload));
+
+  try {
+    const messageId = await topic.publishMessage({ data: dataBuffer });
+    console.log(`✅ [${date}] Triggered ${computation} (Msg ID: ${messageId})`);
+  } catch (error) {
+    console.error(`❌ [${date}] Failed to trigger ${computation}:`, error.message);
+  }
+}
+
+main().catch(console.error);

package/functions/computation-system/workflows/bulltrackers_pipeline.yaml

@@ -1,4 +1,4 @@
-# Cloud Workflows: Precision Cursor-Based Orchestrator
+# Cloud Workflows: Precision Cursor-Based Orchestrator with Manual Override
 main:
   params: [input]
   steps:
@@ -9,6 +9,12 @@ main:
           - current_date: '${text.split(time.format(sys.now()), "T")[0]}'
           - date_to_run: '${default(map.get(input, "date"), current_date)}'
 
+    # --- 🔀 NEW: CHECK FOR MANUAL OVERRIDE ---
+    - check_manual_override:
+        switch:
+          - condition: '${map.get(input, "action") == "FORCE_RUN"}'
+            next: execute_manual_force_run
+
     # --- PHASE 1: EXECUTION (Standard + High Mem Retry) ---
     - run_sequential_passes:
         for:
@@ -80,7 +86,7 @@ main:
                                 - next_loop_retry:
                                     next: sequential_date_loop
             
-            # --- VERIFICATION & SWEEP ---
+            # --- VERIFICATION & SWEEP (CRITICAL LOGIC PRESERVED) ---
             - verify_pass_completion:
                 call: http.post
                 args:
@@ -116,8 +122,6 @@ main:
                           seconds: '${int(sweep_task.eta)}'
 
     # --- PHASE 2: FINAL FORENSIC REPORTING ---
-    # Triggered after ALL execution attempts for this pass (Standard -> Verify -> HighMem Sweep)
-    # We ask the dispatcher to run the FinalSweepReporter for the target date.
     - run_final_forensics:
         for:
           value: pass_id
@@ -139,5 +143,21 @@ main:
                 args:
                    text: '${"📝 FINAL REPORT: Pass " + pass_id + " -> " + report_res.body.issuesFound + " detailed forensic documents created."}'
 
-    - finish:
-        return: "Pipeline Complete with Forensic Analysis"
+    - finish_standard:
+        return: "Pipeline Complete with Forensic Analysis"
+
+    # --- 🚨 MANUAL OVERRIDE EXECUTION PATH ---
+    - execute_manual_force_run:
+        call: http.post
+        args:
+            url: '${"https://europe-west1-" + project + ".cloudfunctions.net/computation-dispatcher"}'
+            body:
+                action: 'FORCE_RUN'
+                computation: '${input.computation}'
+                date: '${map.get(input, "date")}' # Can be null for ALL_DATES
+                resources: '${map.get(input, "resources")}'
+            auth: { type: OIDC }
+        result: force_res
+
+    - finish_manual:
+        return: '${force_res.body}'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bulltrackers-module",
-  "version": "1.0.554",
+  "version": "1.0.556",
   "description": "Helper Functions for Bulltrackers.",
   "main": "index.js",
   "files": [