collabdocchat 1.2.13 → 2.0.0

package/server/utils/workflow-engine.js

@@ -0,0 +1,479 @@
+import { Workflow, WorkflowExecution, Approval } from '../models/Workflow.js';
+import User from '../models/User.js';
+import axios from 'axios';
+
+class WorkflowEngine {
+  constructor() {
+    this.executionQueue = [];
+    this.isProcessing = false;
+  }
+
+  // 触发工作流
+  async triggerWorkflow(workflowId, triggerData, triggeredBy) {
+    const workflow = await Workflow.findById(workflowId);
+    
+    if (!workflow) {
+      throw new Error('工作流不存在');
+    }
+
+    if (workflow.status !== 'active') {
+      throw new Error('工作流未激活');
+    }
+
+    // 检查触发条件
+    if (workflow.trigger.conditions && workflow.trigger.conditions.length > 0) {
+      const conditionsMet = this.checkConditions(workflow.trigger.conditions, triggerData);
+      if (!conditionsMet) {
+        console.log('触发条件不满足，跳过执行');
+        return null;
+      }
+    }
+
+    // 创建执行记录
+    const execution = new WorkflowExecution({
+      workflow: workflowId,
+      triggeredBy,
+      triggerType: workflow.trigger.type,
+      triggerData,
+      status: 'pending',
+      startedAt: new Date(),
+      steps: workflow.steps.map((step, index) => ({
+        stepIndex: index,
+        stepName: step.name,
+        status: 'pending'
+      }))
+    });
+
+    await execution.save();
+
+    // 添加到执行队列
+    this.executionQueue.push(execution._id);
+    
+    // 开始处理队列
+    this.processQueue();
+
+    return execution;
+  }
+
+  // 处理执行队列
+  async processQueue() {
+    if (this.isProcessing || this.executionQueue.length === 0) {
+      return;
+    }
+
+    this.isProcessing = true;
+
+    while (this.executionQueue.length > 0) {
+      const executionId = this.executionQueue.shift();
+      try {
+        await this.executeWorkflow(executionId);
+      } catch (error) {
+        console.error('工作流执行失败:', error);
+      }
+    }
+
+    this.isProcessing = false;
+  }
+
+  // 执行工作流
+  async executeWorkflow(executionId) {
+    const execution = await WorkflowExecution.findById(executionId)
+      .populate('workflow');
+
+    if (!execution) {
+      throw new Error('执行记录不存在');
+    }
+
+    const workflow = execution.workflow;
+
+    execution.status = 'running';
+    await execution.save();
+
+    this.addLog(execution, 'info', '工作流开始执行');
+
+    try {
+      // 按顺序执行步骤
+      for (let i = 0; i < workflow.steps.length; i++) {
+        const step = workflow.steps[i];
+        execution.currentStep = i;
+        await execution.save();
+
+        // 检查步骤执行条件
+        if (step.executeIf && step.executeIf.length > 0) {
+          const shouldExecute = this.checkConditions(step.executeIf, execution.triggerData);
+          if (!shouldExecute) {
+            this.addLog(execution, 'info', `步骤 ${i + 1}: ${step.name} - 条件不满足，跳过`);
+            execution.steps[i].status = 'skipped';
+            await execution.save();
+            continue;
+          }
+        }
+
+        this.addLog(execution, 'info', `步骤 ${i + 1}: ${step.name} - 开始执行`);
+        execution.steps[i].status = 'running';
+        execution.steps[i].startedAt = new Date();
+        await execution.save();
+
+        try {
+          const result = await this.executeStep(step, execution);
+          
+          execution.steps[i].status = 'completed';
+          execution.steps[i].completedAt = new Date();
+          execution.steps[i].result = result;
+          await execution.save();
+
+          this.addLog(execution, 'info', `步骤 ${i + 1}: ${step.name} - 执行成功`);
+        } catch (error) {
+          execution.steps[i].status = 'failed';
+          execution.steps[i].completedAt = new Date();
+          execution.steps[i].error = error.message;
+          await execution.save();
+
+          this.addLog(execution, 'error', `步骤 ${i + 1}: ${step.name} - 执行失败: ${error.message}`);
+
+          // 处理失败
+          if (step.onFailure === 'stop') {
+            throw error;
+          } else if (step.onFailure === 'retry' && step.retryCount > 0) {
+            // 重试逻辑
+            for (let retry = 0; retry < step.retryCount; retry++) {
+              this.addLog(execution, 'info', `步骤 ${i + 1}: ${step.name} - 重试 ${retry + 1}/${step.retryCount}`);
+              try {
+                const result = await this.executeStep(step, execution);
+                execution.steps[i].status = 'completed';
+                execution.steps[i].result = result;
+                await execution.save();
+                break;
+              } catch (retryError) {
+                if (retry === step.retryCount - 1) {
+                  throw retryError;
+                }
+              }
+            }
+          }
+          // continue: 继续执行下一步
+        }
+      }
+
+      // 工作流执行完成
+      execution.status = 'completed';
+      execution.completedAt = new Date();
+      await execution.save();
+
+      // 更新工作流统计
+      await Workflow.findByIdAndUpdate(workflow._id, {
+        $inc: { 'stats.totalExecutions': 1, 'stats.successfulExecutions': 1 },
+        $set: { 'stats.lastExecutedAt': new Date() }
+      });
+
+      this.addLog(execution, 'info', '工作流执行完成');
+    } catch (error) {
+      execution.status = 'failed';
+      execution.completedAt = new Date();
+      execution.error = error.message;
+      await execution.save();
+
+      // 更新工作流统计
+      await Workflow.findByIdAndUpdate(workflow._id, {
+        $inc: { 'stats.totalExecutions': 1, 'stats.failedExecutions': 1 },
+        $set: { 'stats.lastExecutedAt': new Date() }
+      });
+
+      this.addLog(execution, 'error', `工作流执行失败: ${error.message}`);
+    }
+  }
+
+  // 执行单个步骤
+  async executeStep(step, execution) {
+    switch (step.type) {
+      case 'approval':
+        return await this.executeApprovalStep(step, execution);
+      case 'notification':
+        return await this.executeNotificationStep(step, execution);
+      case 'assignment':
+        return await this.executeAssignmentStep(step, execution);
+      case 'webhook':
+        return await this.executeWebhookStep(step, execution);
+      case 'delay':
+        return await this.executeDelayStep(step, execution);
+      case 'condition':
+        return await this.executeConditionStep(step, execution);
+      case 'script':
+        return await this.executeScriptStep(step, execution);
+      default:
+        throw new Error(`未知的步骤类型: ${step.type}`);
+    }
+  }
+
+  // 执行审批步骤
+  async executeApprovalStep(step, execution) {
+    const { approvers, approvalType } = step.config;
+
+    if (!approvers || approvers.length === 0) {
+      throw new Error('未配置审批人');
+    }
+
+    // 创建审批记录
+    const approvals = await Promise.all(
+      approvers.map(approverId => 
+        new Approval({
+          execution: execution._id,
+          workflow: execution.workflow,
+          stepIndex: execution.currentStep,
+          approver: approverId,
+          status: 'pending'
+        }).save()
+      )
+    );
+
+    // 等待审批（这里简化处理，实际应该通过事件驱动）
+    // 在实际应用中，应该暂停执行，等待审批完成后继续
+    return {
+      type: 'approval',
+      approvals: approvals.map(a => a._id),
+      status: 'waiting'
+    };
+  }
+
+  // 执行通知步骤
+  async executeNotificationStep(step, execution) {
+    const { notificationType, recipients, message } = step.config;
+
+    if (!recipients || recipients.length === 0) {
+      throw new Error('未配置通知接收人');
+    }
+
+    const users = await User.find({ _id: { $in: recipients } });
+
+    // 发送通知（这里简化处理）
+    for (const user of users) {
+      console.log(`发送${notificationType}通知给 ${user.username}: ${message}`);
+      // 实际应该调用通知服务
+    }
+
+    return {
+      type: 'notification',
+      notificationType,
+      recipientCount: users.length,
+      message
+    };
+  }
+
+  // 执行分配步骤
+  async executeAssignmentStep(step, execution) {
+    const { assignee } = step.config;
+
+    if (!assignee) {
+      throw new Error('未配置分配对象');
+    }
+
+    // 这里应该根据实际业务逻辑进行任务分配
+    return {
+      type: 'assignment',
+      assignee,
+      assignedAt: new Date()
+    };
+  }
+
+  // 执行 Webhook 步骤
+  async executeWebhookStep(step, execution) {
+    const { url, method, headers, body } = step.config;
+
+    if (!url) {
+      throw new Error('未配置 Webhook URL');
+    }
+
+    const response = await axios({
+      method: method || 'POST',
+      url,
+      headers: headers || {},
+      data: body || execution.triggerData
+    });
+
+    return {
+      type: 'webhook',
+      url,
+      method,
+      statusCode: response.status,
+      response: response.data
+    };
+  }
+
+  // 执行延迟步骤
+  async executeDelayStep(step, execution) {
+    const { delayMinutes } = step.config;
+
+    if (!delayMinutes || delayMinutes <= 0) {
+      throw new Error('延迟时间配置无效');
+    }
+
+    // 实际应该使用定时任务
+    await new Promise(resolve => setTimeout(resolve, delayMinutes * 60 * 1000));
+
+    return {
+      type: 'delay',
+      delayMinutes,
+      completedAt: new Date()
+    };
+  }
+
+  // 执行条件步骤
+  async executeConditionStep(step, execution) {
+    const { conditions } = step.config;
+
+    if (!conditions || conditions.length === 0) {
+      throw new Error('未配置条件');
+    }
+
+    const result = this.checkConditions(conditions, execution.triggerData);
+
+    return {
+      type: 'condition',
+      result,
+      conditions
+    };
+  }
+
+  // 执行脚本步骤
+  async executeScriptStep(step, execution) {
+    const { script } = step.config;
+
+    if (!script) {
+      throw new Error('未配置脚本');
+    }
+
+    // 注意：eval 有安全风险，生产环境应该使用沙箱环境
+    // 这里仅作示例
+    try {
+      const result = eval(script);
+      return {
+        type: 'script',
+        result
+      };
+    } catch (error) {
+      throw new Error(`脚本执行失败: ${error.message}`);
+    }
+  }
+
+  // 检查条件
+  checkConditions(conditions, data) {
+    return conditions.every(condition => {
+      const { field, operator, value } = condition;
+      const fieldValue = this.getFieldValue(data, field);
+
+      switch (operator) {
+        case 'equals':
+          return fieldValue === value;
+        case 'not_equals':
+          return fieldValue !== value;
+        case 'contains':
+          return String(fieldValue).includes(value);
+        case 'greater_than':
+          return fieldValue > value;
+        case 'less_than':
+          return fieldValue < value;
+        case 'in':
+          return Array.isArray(value) && value.includes(fieldValue);
+        case 'not_in':
+          return Array.isArray(value) && !value.includes(fieldValue);
+        default:
+          return false;
+      }
+    });
+  }
+
+  // 获取字段值（支持嵌套）
+  getFieldValue(data, field) {
+    const keys = field.split('.');
+    let value = data;
+    for (const key of keys) {
+      if (value && typeof value === 'object') {
+        value = value[key];
+      } else {
+        return undefined;
+      }
+    }
+    return value;
+  }
+
+  // 添加日志
+  async addLog(execution, level, message, data = null) {
+    execution.logs.push({
+      timestamp: new Date(),
+      level,
+      message,
+      data
+    });
+    await execution.save();
+  }
+
+  // 处理审批决策
+  async handleApprovalDecision(approvalId, decision, comment, userId) {
+    const approval = await Approval.findById(approvalId)
+      .populate('execution')
+      .populate('workflow');
+
+    if (!approval) {
+      throw new Error('审批记录不存在');
+    }
+
+    if (approval.approver.toString() !== userId) {
+      throw new Error('无权处理此审批');
+    }
+
+    if (approval.status !== 'pending') {
+      throw new Error('审批已处理');
+    }
+
+    approval.status = decision;
+    approval.comment = comment;
+    approval.decidedAt = new Date();
+    await approval.save();
+
+    // 检查是否所有审批都已完成
+    const execution = approval.execution;
+    const workflow = approval.workflow;
+    const step = workflow.steps[approval.stepIndex];
+
+    const allApprovals = await Approval.find({
+      execution: execution._id,
+      stepIndex: approval.stepIndex
+    });
+
+    let shouldContinue = false;
+
+    if (step.config.approvalType === 'any') {
+      // 任意一人批准即可
+      shouldContinue = allApprovals.some(a => a.status === 'approved');
+    } else if (step.config.approvalType === 'all') {
+      // 所有人都需要批准
+      shouldContinue = allApprovals.every(a => a.status === 'approved');
+    } else if (step.config.approvalType === 'sequential') {
+      // 按顺序审批
+      const currentIndex = allApprovals.findIndex(a => a._id.toString() === approvalId);
+      if (decision === 'approved' && currentIndex < allApprovals.length - 1) {
+        // 继续下一个审批人
+        shouldContinue = false;
+      } else {
+        shouldContinue = decision === 'approved';
+      }
+    }
+
+    if (decision === 'rejected') {
+      // 审批被拒绝，工作流失败
+      execution.status = 'failed';
+      execution.error = '审批被拒绝';
+      await execution.save();
+    } else if (shouldContinue) {
+      // 审批通过，继续执行
+      // 这里应该触发继续执行工作流
+      this.executionQueue.push(execution._id);
+      this.processQueue();
+    }
+
+    return approval;
+  }
+}
+
+export default new WorkflowEngine();
+