powr-sdk-api 4.3.10 → 4.3.12

package/dist/managers/tasks.js

@@ -475,11 +475,35 @@ class TasksManager {
 
       // Log workflow execution
       await this.logWorkflowExecution(workflow, results);
+
+      // For one-time workflows, deactivate after execution
+      if (workflow.schedule && !this.isCronExpression(workflow.schedule)) {
+        try {
+          const db = await getDb();
+          await db.collection("tasks").updateOne({
+            _id: workflow._id
+          }, {
+            $set: {
+              isActive: false
+            }
+          });
+          console.log(`🔄 Deactivated one-time workflow: ${workflow.name}`);
+        } catch (error) {
+          console.error("❌ Failed to deactivate workflow:", error);
+        }
+      }
+
+      // Determine overall success - consider it successful if at least one action executed successfully
+      const executedActions = results.filter(r => r.type === 'action' && !r.skipped);
+      const successfulActions = executedActions.filter(r => r.success);
+      const overallSuccess = executedActions.length === 0 || successfulActions.length > 0;
       return {
-        success: workflowSuccess,
+        success: overallSuccess,
         workflowName: workflow.name,
         stepsExecuted: results.length,
-        results: results
+        results: results,
+        actionsExecuted: executedActions.length,
+        actionsSuccessful: successfulActions.length
       };
     } catch (error) {
       console.error(`❌ Workflow execution failed: ${workflow.name}`, error);
@@ -554,15 +578,35 @@ class TasksManager {
       return true; // No condition, always execute
     }
 
-    // Simple condition evaluation
-    // For now, support basic conditions like "step1 === true"
+    // Parse condition like "step1.result === 'rain'" or "step1.result !== 'rain'"
     const condition = step.condition;
+
+    // Extract step ID and condition
+    const stepMatch = condition.match(/step(\d+)\.result\s*(===|!==)\s*['"]([^'"]+)['"]/);
+    if (stepMatch) {
+      const stepId = stepMatch[1];
+      const operator = stepMatch[2];
+      const expectedValue = stepMatch[3];
+      const stepResult = previousResults.find(r => r.stepId === stepId);
+      if (stepResult && stepResult.result) {
+        var _stepResult$result$da;
+        // Get actual value from the result structure
+        const actualValue = stepResult.result.actualValue || ((_stepResult$result$da = stepResult.result.data) === null || _stepResult$result$da === void 0 ? void 0 : _stepResult$result$da.currentWeather) || stepResult.result.condition || 'unknown';
+        console.log(`🔍 Condition check: ${actualValue} ${operator} ${expectedValue}`);
+        if (operator === '===') {
+          return actualValue.toLowerCase() === expectedValue.toLowerCase();
+        } else if (operator === '!==') {
+          return actualValue.toLowerCase() !== expectedValue.toLowerCase();
+        }
+      }
+    }
+
+    // Fallback: check for simple boolean conditions
     if (condition.includes('step1') && condition.includes('=== true')) {
       const step1Result = previousResults.find(r => r.stepId === 'step1');
       return step1Result && step1Result.conditionMet === true;
     }
-
-    // Add more condition parsing as needed
+    console.log(`⚠️ Could not parse condition: ${condition}, defaulting to execute`);
     return true; // Default to execute if condition parsing fails
   }
 
@@ -589,12 +633,20 @@ class TasksManager {
   async logWorkflowExecution(workflow, results) {
     try {
       const db = await getDb();
+
+      // Calculate overall success
+      const executedActions = results.filter(r => r.type === 'action' && !r.skipped);
+      const successfulActions = executedActions.filter(r => r.success);
+      const overallSuccess = executedActions.length === 0 || successfulActions.length > 0;
       await db.collection("workflow_executions").insertOne({
         workflowId: workflow._id,
         workflowName: workflow.name,
         userId: workflow.userId,
         projectId: workflow.projectId,
         results: results,
+        success: overallSuccess,
+        actionsExecuted: executedActions.length,
+        actionsSuccessful: successfulActions.length,
         executedAt: new Date()
       });
     } catch (error) {
@@ -602,6 +654,61 @@ class TasksManager {
     }
   }
 
+  // Get execution history for a task
+  async getTaskExecutions(taskId, userId, projectId, isAdmin = false) {
+    try {
+      const db = await getDb();
+
+      // First verify the task exists and user has access
+      let taskQuery = {
+        _id: new ObjectId(taskId)
+      };
+      if (isAdmin) {
+        taskQuery.projectId = projectId;
+      } else {
+        taskQuery.userId = userId;
+        taskQuery.projectId = projectId;
+      }
+      const task = await db.collection("tasks").findOne(taskQuery);
+      if (!task) {
+        return {
+          success: false,
+          message: "Task not found"
+        };
+      }
+
+      // Get execution history based on task type
+      let executions = [];
+      if (task.type === 'workflow') {
+        // Get workflow executions
+        executions = await db.collection("workflow_executions").find({
+          workflowId: new ObjectId(taskId)
+        }).sort({
+          executedAt: -1
+        }).limit(50) // Limit to last 50 executions
+        .toArray();
+      } else {
+        // Get task executions
+        executions = await db.collection("task_executions").find({
+          taskId: new ObjectId(taskId)
+        }).sort({
+          executedAt: -1
+        }).limit(50) // Limit to last 50 executions
+        .toArray();
+      }
+      return {
+        success: true,
+        executions
+      };
+    } catch (error) {
+      console.error("❌ Failed to get task executions:", error);
+      return {
+        success: false,
+        message: error.message
+      };
+    }
+  }
+
   // Check if a string is a valid timestamp
   isTimestamp(value) {
     try {
@@ -612,6 +719,15 @@ class TasksManager {
     }
   }
 
+  // Check if a string is a cron expression
+  isCronExpression(value) {
+    if (!value || typeof value !== 'string') return false;
+
+    // Basic cron pattern: 5 or 6 fields separated by spaces
+    const cronPattern = /^(\*|\d+|\d+-\d+|\d+\/\d+)(\s+(\*|\d+|\d+-\d+|\d+\/\d+)){4,5}$/;
+    return cronPattern.test(value.trim());
+  }
+
   // Check if a string is a cron expression
   isCronExpression(value) {
     try {

package/dist/routes/tasks.js

@@ -275,6 +275,32 @@ router.delete("/:taskId", async (req, res) => {
   }
 });
 
+// GET /tasks/:taskId/executions - Get execution history for a task
+router.get("/:taskId/executions", async (req, res) => {
+  try {
+    const taskId = req.params.taskId;
+    const isAdmin = req.user.access === 100;
+    const result = await tasksManager.getTaskExecutions(taskId, req.user.powrId, req.projectId, isAdmin);
+    if (result.success) {
+      res.json({
+        success: true,
+        executions: result.executions
+      });
+    } else {
+      res.status(400).json({
+        success: false,
+        message: result.message
+      });
+    }
+  } catch (error) {
+    console.error("❌ Error retrieving task executions:", error);
+    res.status(500).json({
+      success: false,
+      message: "Failed to retrieve task executions"
+    });
+  }
+});
+
 // POST /tasks/execute-scheduled - Execute all scheduled tasks (called by Atlas)
 router.post("/execute-scheduled", async (req, res) => {
   try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "powr-sdk-api",
-  "version": "4.3.10",
+  "version": "4.3.12",
   "description": "Shared API core library for PowrStack projects",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",