feat(wm-bpm+frontend): #35 跨系统流程编排+Webhook回调完整实现

- entity: OrchestrationExecution, OrchestrationLog, OrchestrationStep, WebhookRegistration
- mapper: OrchestrationExecutionMapper, OrchestrationLogMapper
- service: ProcessOrchestrationService (编排CRUD/启动执行/步骤流转/跨系统API模拟/Webhook回调/重试机制), OrchestrationLogService
- controller: ProcessOrchestrationController (/api/bpm/orchestration/*)
- config: WebhookConfig (Webhook注册/签名验证HMAC-SHA256/回调触发)
- SQL DDL: V_bpm_orchestration.sql (编排表+执行表+日志表+示例数据)
- frontend: OrchestrationView.vue (编排管理/执行记录/日志查看/Webhook配置), orchestrationApi.ts
- tests: ProcessOrchestrationServiceTest, OrchestrationLogServiceTest, WebhookConfigTest

db/V_bpm_orchestration.sql

@@ -0,0 +1,106 @@
+-- =====================================================
+-- 跨系统流程编排 DDL
+-- Issue #35: 跨系统流程编排 + Webhook 回调通知
+-- =====================================================
+
+-- 编排定义表 (已存在则跳过)
+CREATE TABLE IF NOT EXISTS bpm_orchestration (
+    id              BIGSERIAL PRIMARY KEY,
+    orchestration_name  VARCHAR(200) NOT NULL,
+    orchestration_code  VARCHAR(100) UNIQUE,
+    description         TEXT,
+    process_definition_ids  JSONB,
+    orchestration_rules     JSONB,
+    trigger_type        VARCHAR(50) DEFAULT 'manual',
+    cron_expression     VARCHAR(100),
+    event_name          VARCHAR(200),
+    status              INTEGER DEFAULT 0,
+    created_by          VARCHAR(100),
+    execution_count     INTEGER DEFAULT 0,
+    tenant_id           VARCHAR(100),
+    deleted             INTEGER DEFAULT 0,
+    created_at          TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at          TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+-- 编排执行记录表
+CREATE TABLE IF NOT EXISTS bpm_orchestration_execution (
+    id                  BIGSERIAL PRIMARY KEY,
+    orchestration_id    BIGINT NOT NULL REFERENCES bpm_orchestration(id),
+    execution_no        VARCHAR(100) UNIQUE NOT NULL,
+    current_step_index  INTEGER DEFAULT 0,
+    current_step_name   VARCHAR(200),
+    status              VARCHAR(50) DEFAULT 'pending',
+    started_at          TIMESTAMP,
+    completed_at        TIMESTAMP,
+    triggered_by        VARCHAR(100),
+    trigger_type        VARCHAR(50) DEFAULT 'manual',
+    input_params        JSONB,
+    output_result       JSONB,
+    failure_reason      TEXT,
+    retry_count         INTEGER DEFAULT 0,
+    tenant_id           VARCHAR(100),
+    deleted             INTEGER DEFAULT 0,
+    created_at          TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at          TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE INDEX IF NOT EXISTS idx_orch_exec_orch_id ON bpm_orchestration_execution(orchestration_id);
+CREATE INDEX IF NOT EXISTS idx_orch_exec_no ON bpm_orchestration_execution(execution_no);
+CREATE INDEX IF NOT EXISTS idx_orch_exec_status ON bpm_orchestration_execution(status);
+CREATE INDEX IF NOT EXISTS idx_orch_exec_started ON bpm_orchestration_execution(started_at);
+
+-- 编排日志表
+CREATE TABLE IF NOT EXISTS bpm_orchestration_log (
+    id                  BIGSERIAL PRIMARY KEY,
+    execution_id        BIGINT NOT NULL REFERENCES bpm_orchestration_execution(id),
+    execution_no        VARCHAR(100) NOT NULL,
+    step_index          INTEGER,
+    step_name           VARCHAR(200),
+    action              VARCHAR(50) NOT NULL,
+    target_system       VARCHAR(100),
+    request_body        JSONB,
+    response_body       JSONB,
+    http_status         INTEGER,
+    duration_ms         BIGINT,
+    success             BOOLEAN DEFAULT TRUE,
+    error_message       TEXT,
+    log_time            TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    operator            VARCHAR(100),
+    deleted             INTEGER DEFAULT 0,
+    created_at          TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at          TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE INDEX IF NOT EXISTS idx_orch_log_exec_id ON bpm_orchestration_log(execution_id);
+CREATE INDEX IF NOT EXISTS idx_orch_log_exec_no ON bpm_orchestration_log(execution_no);
+CREATE INDEX IF NOT EXISTS idx_orch_log_time ON bpm_orchestration_log(log_time);
+CREATE INDEX IF NOT EXISTS idx_orch_log_action ON bpm_orchestration_log(action);
+
+-- 插入示例编排定义
+INSERT INTO bpm_orchestration (orchestration_name, orchestration_code, description, trigger_type, orchestration_rules, status, created_by)
+VALUES
+('日常巡检数据同步编排', 'DAILY_PATROL_SYNC', '每日自动同步IoT设备数据、巡检任务、营收数据并发送通知', 'scheduled',
+ '[
+   {"stepName":"查询IoT设备状态","targetSystem":"iot","apiPath":"/api/iot/devices/status","method":"GET","timeoutMs":5000,"skippable":false,"maxRetries":3},
+   {"stepName":"同步巡检任务","targetSystem":"patrol","apiPath":"/api/patrol/tasks/sync","method":"POST","timeoutMs":10000,"skippable":false,"maxRetries":3},
+   {"stepName":"汇总营收数据","targetSystem":"revenue","apiPath":"/api/revenue/daily/summary","method":"GET","timeoutMs":8000,"skippable":true,"maxRetries":2},
+   {"stepName":"发送汇总通知","targetSystem":"notify","apiPath":"/api/notify/send","method":"POST","timeoutMs":5000,"skippable":true,"maxRetries":1}
+ ]',
+ 1, 'system'),
+('应急事件处理编排', 'EMERGENCY_RESPONSE', '突发事件触发时：获取设备数据→派发巡检任务→通知相关人员', 'event',
+ '[
+   {"stepName":"获取异常设备数据","targetSystem":"iot","apiPath":"/api/iot/devices/alerts","method":"GET","timeoutMs":3000,"skippable":false,"maxRetries":3},
+   {"stepName":"派发应急巡检任务","targetSystem":"patrol","apiPath":"/api/patrol/tasks/emergency","method":"POST","timeoutMs":5000,"skippable":false,"maxRetries":3},
+   {"stepName":"发送紧急通知","targetSystem":"notify","apiPath":"/api/notify/emergency","method":"POST","timeoutMs":3000,"skippable":false,"maxRetries":2}
+ ]',
+ 1, 'system')
+ON CONFLICT DO NOTHING;
+
+-- 注释
+COMMENT ON TABLE bpm_orchestration IS '跨系统流程编排定义表';
+COMMENT ON TABLE bpm_orchestration_execution IS '编排执行记录表';
+COMMENT ON TABLE bpm_orchestration_log IS '编排执行日志表';
+COMMENT ON COLUMN bpm_orchestration.orchestration_rules IS '编排步骤JSON数组';
+COMMENT ON COLUMN bpm_orchestration_execution.status IS '执行状态: pending/running/completed/failed/cancelled';
+COMMENT ON COLUMN bpm_orchestration_log.action IS '动作类型: start/complete/fail/retry/callback/skip/cancel';

frontend/src/api/orchestrationApi.ts

@@ -0,0 +1,181 @@
+import request from './request'
+
+// ============== 类型定义 ==============
+
+export interface OrchestrationStep {
+  stepName: string
+  targetSystem: 'iot' | 'revenue' | 'patrol' | 'notify'
+  apiPath: string
+  method: 'GET' | 'POST' | 'PUT' | 'DELETE'
+  timeoutMs: number
+  skippable: boolean
+  maxRetries: number
+}
+
+export interface BpmOrchestration {
+  id?: number
+  orchestrationName: string
+  orchestrationCode: string
+  description?: string
+  processDefinitionIds?: string
+  orchestrationRules?: string
+  triggerType: 'manual' | 'scheduled' | 'event'
+  cronExpression?: string
+  eventName?: string
+  status?: number
+  createdBy?: string
+  executionCount?: number
+  createdAt?: string
+  updatedAt?: string
+}
+
+export interface OrchestrationExecution {
+  id: number
+  orchestrationId: number
+  executionNo: string
+  currentStepIndex: number
+  currentStepName: string
+  status: 'pending' | 'running' | 'completed' | 'failed' | 'cancelled'
+  startedAt: string
+  completedAt?: string
+  triggeredBy: string
+  triggerType: string
+  inputParams?: string
+  outputResult?: string
+  failureReason?: string
+  retryCount: number
+}
+
+export interface OrchestrationLog {
+  id: number
+  executionId: number
+  executionNo: string
+  stepIndex: number
+  stepName: string
+  action: 'start' | 'complete' | 'fail' | 'retry' | 'callback' | 'skip' | 'cancel'
+  targetSystem: string
+  requestBody?: string
+  responseBody?: string
+  httpStatus?: number
+  durationMs?: number
+  success: boolean
+  errorMessage?: string
+  logTime: string
+  operator: string
+}
+
+export interface WebhookRegistration {
+  callbackUrl: string
+  secretKey?: string
+  signatureEnabled: boolean
+  eventType: string
+  description?: string
+}
+
+export interface ExecutionStats {
+  total: number
+  completed: number
+  failed: number
+  running: number
+  successRate: string
+}
+
+// ============== 编排定义 API ==============
+
+export function createOrchestration(data: BpmOrchestration) {
+  return request.post('/bpm/orchestration/definitions', data)
+}
+
+export function updateOrchestration(id: number, data: BpmOrchestration) {
+  return request.put(`/bpm/orchestration/definitions/${id}`, data)
+}
+
+export function deleteOrchestration(id: number) {
+  return request.delete(`/bpm/orchestration/definitions/${id}`)
+}
+
+export function getOrchestration(id: number) {
+  return request.get(`/bpm/orchestration/definitions/${id}`)
+}
+
+export function listOrchestrations(params?: { keyword?: string; status?: number; page?: number; size?: number }) {
+  return request.get('/bpm/orchestration/definitions', { params })
+}
+
+export function toggleOrchestrationStatus(id: number, status: number) {
+  return request.put(`/bpm/orchestration/definitions/${id}/status`, null, { params: { status } })
+}
+
+// ============== 编排执行 API ==============
+
+export function startExecution(data: { orchestrationId: number; triggeredBy?: string; triggerType?: string; inputParams?: Record<string, any> }) {
+  return request.post('/bpm/orchestration/executions', data)
+}
+
+export function getExecution(id: number) {
+  return request.get(`/bpm/orchestration/executions/${id}`)
+}
+
+export function getExecutionByNo(executionNo: string) {
+  return request.get(`/bpm/orchestration/executions/no/${executionNo}`)
+}
+
+export function listExecutions(params?: { orchestrationId?: number; status?: string; page?: number; size?: number }) {
+  return request.get('/bpm/orchestration/executions', { params })
+}
+
+export function cancelExecution(id: number) {
+  return request.put(`/bpm/orchestration/executions/${id}/cancel`)
+}
+
+export function getExecutionStats(orchestrationId?: number) {
+  return request.get('/bpm/orchestration/executions/stats', { params: { orchestrationId } })
+}
+
+// ============== 编排日志 API ==============
+
+export function getLogs(params?: { executionId?: number; action?: string; success?: boolean; startTime?: string; endTime?: string; page?: number; size?: number }) {
+  return request.get('/bpm/orchestration/logs', { params })
+}
+
+export function getLogsByExecutionId(executionId: number) {
+  return request.get(`/bpm/orchestration/logs/execution/${executionId}`)
+}
+
+export function getLogsByExecutionNo(executionNo: string) {
+  return request.get(`/bpm/orchestration/logs/execution-no/${executionNo}`)
+}
+
+export function getStepLogs(executionId: number, stepIndex: number) {
+  return request.get(`/bpm/orchestration/logs/execution/${executionId}/step/${stepIndex}`)
+}
+
+export function countLogs(executionId?: number) {
+  return request.get('/bpm/orchestration/logs/count', { params: { executionId } })
+}
+
+// ============== Webhook API ==============
+
+export function registerWebhook(id: string, data: WebhookRegistration) {
+  return request.post(`/bpm/orchestration/webhooks`, data, { params: { id } })
+}
+
+export function unregisterWebhook(id: string) {
+  return request.delete(`/bpm/orchestration/webhooks/${id}`)
+}
+
+export function listWebhooks() {
+  return request.get('/bpm/orchestration/webhooks')
+}
+
+export function getWebhook(id: string) {
+  return request.get(`/bpm/orchestration/webhooks/${id}`)
+}
+
+export function triggerWebhook(eventType: string, payload: Record<string, any>) {
+  return request.post('/bpm/orchestration/webhooks/trigger', { eventType, payload })
+}
+
+export function verifySignature(payload: string, secretKey: string, signature: string) {
+  return request.post('/bpm/orchestration/webhooks/verify-signature', { payload, secretKey, signature })
+}

frontend/src/router/index.ts

@@ -16,6 +16,7 @@ const routes = [
       { path: 'cs/knowledge', name: 'csKnowledge', component: () => import('@/views/cs/KnowledgeBaseView.vue') },
       { path: 'cs/announcement', name: 'csAnnouncement', component: () => import('@/views/cs/AnnouncementView.vue') },
       { path: 'cs/kpi', name: 'csKpi', component: () => import('@/views/cs/KpiDashboardView.vue') },
+      { path: 'bpm/orchestration', name: 'bpmOrchestration', component: () => import('@/views/bpm/OrchestrationView.vue') },
     ]
   },
   { path: '/:pathMatch(.*)*', redirect: '/dashboard' }

frontend/src/views/bpm/OrchestrationView.vue

@@ -0,0 +1,412 @@
+<template>
+  <div class="orchestration-container">
+    <el-tabs v-model="activeTab" type="border-card">
+      <!-- 编排管理 -->
+      <el-tab-pane label="编排管理" name="definitions">
+        <div class="toolbar">
+          <el-input v-model="searchKeyword" placeholder="搜索编排名称/编码" clearable style="width:240px" @input="loadOrchestrations" />
+          <el-select v-model="filterStatus" placeholder="状态" clearable style="width:120px;margin-left:12px" @change="loadOrchestrations">
+            <el-option label="草稿" :value="0" />
+            <el-option label="启用" :value="1" />
+            <el-option label="停用" :value="2" />
+          </el-select>
+          <el-button type="primary" style="margin-left:12px" @click="showCreateDialog">新建编排</el-button>
+        </div>
+
+        <el-table :data="orchestrations" v-loading="loadingOrch" stripe style="width:100%;margin-top:16px">
+          <el-table-column prop="id" label="ID" width="60" />
+          <el-table-column prop="orchestrationName" label="编排名称" />
+          <el-table-column prop="orchestrationCode" label="编码" width="160" />
+          <el-table-column prop="triggerType" label="触发方式" width="100">
+            <template #default="{ row }">
+              <el-tag :type="triggerTypeTag(row.triggerType)">{{ triggerTypeLabel(row.triggerType) }}</el-tag>
+            </template>
+          </el-table-column>
+          <el-table-column prop="status" label="状态" width="80">
+            <template #default="{ row }">
+              <el-tag :type="statusTag(row.status)">{{ statusLabel(row.status) }}</el-tag>
+            </template>
+          </el-table-column>
+          <el-table-column prop="executionCount" label="执行次数" width="90" />
+          <el-table-column label="操作" width="280">
+            <template #default="{ row }">
+              <el-button size="small" @click="viewSteps(row)">步骤</el-button>
+              <el-button size="small" type="success" @click="executeOrchestration(row)" :disabled="row.status !== 1">执行</el-button>
+              <el-button size="small" :type="row.status === 1 ? 'warning' : 'success'" @click="toggleStatus(row)">{{ row.status === 1 ? '停用' : '启用' }}</el-button>
+              <el-button size="small" type="danger" @click="deleteOrch(row)">删除</el-button>
+            </template>
+          </el-table-column>
+        </el-table>
+      </el-tab-pane>
+
+      <!-- 执行记录 -->
+      <el-tab-pane label="执行记录" name="executions">
+        <div class="toolbar">
+          <el-select v-model="filterExecStatus" placeholder="执行状态" clearable style="width:140px" @change="loadExecutions">
+            <el-option label="运行中" value="running" />
+            <el-option label="已完成" value="completed" />
+            <el-option label="已失败" value="failed" />
+            <el-option label="已取消" value="cancelled" />
+          </el-select>
+          <el-button style="margin-left:12px" @click="loadExecutions">刷新</el-button>
+          <el-button type="info" style="margin-left:12px" @click="loadStats">统计</el-button>
+        </div>
+
+        <el-table :data="executions" v-loading="loadingExec" stripe style="width:100%;margin-top:16px">
+          <el-table-column prop="executionNo" label="执行编号" width="280" />
+          <el-table-column prop="currentStepName" label="当前步骤" />
+          <el-table-column prop="status" label="状态" width="100">
+            <template #default="{ row }">
+              <el-tag :type="execStatusTag(row.status)">{{ row.status }}</el-tag>
+            </template>
+          </el-table-column>
+          <el-table-column prop="triggeredBy" label="触发人" width="100" />
+          <el-table-column prop="startedAt" label="开始时间" width="180" />
+          <el-table-column prop="completedAt" label="完成时间" width="180" />
+          <el-table-column prop="retryCount" label="重试" width="60" />
+          <el-table-column label="操作" width="180">
+            <template #default="{ row }">
+              <el-button size="small" @click="viewLogs(row)">日志</el-button>
+              <el-button size="small" type="warning" @click="cancelExec(row)" :disabled="row.status !== 'running'">取消</el-button>
+            </template>
+          </el-table-column>
+        </el-table>
+      </el-tab-pane>
+
+      <!-- 执行日志 -->
+      <el-tab-pane label="执行日志" name="logs">
+        <div class="toolbar">
+          <el-input v-model="logExecutionNo" placeholder="执行编号" clearable style="width:280px" />
+          <el-button type="primary" style="margin-left:12px" @click="loadLogsByNo">查询</el-button>
+        </div>
+
+        <el-timeline style="margin-top:20px">
+          <el-timeline-item v-for="log in logs" :key="log.id"
+            :timestamp="log.logTime"
+            :type="log.success ? 'success' : 'danger'"
+            :hollow="log.action === 'retry'">
+            <el-card shadow="hover">
+              <p><strong>步骤:</strong> {{ log.stepName }} ({{ log.stepIndex }})</p>
+              <p><strong>动作:</strong> <el-tag size="small">{{ log.action }}</el-tag> → {{ log.targetSystem }}</p>
+              <p v-if="log.durationMs"><strong>耗时:</strong> {{ log.durationMs }}ms</p>
+              <p v-if="log.errorMessage"><strong style="color:#f56c6c">错误:</strong> {{ log.errorMessage }}</p>
+            </el-card>
+          </el-timeline-item>
+        </el-timeline>
+      </el-tab-pane>
+
+      <!-- Webhook 配置 -->
+      <el-tab-pane label="Webhook 配置" name="webhooks">
+        <div class="toolbar">
+          <el-button type="primary" @click="showWebhookDialog">注册 Webhook</el-button>
+        </div>
+
+        <el-table :data="webhooks" stripe style="width:100%;margin-top:16px">
+          <el-table-column prop="callbackUrl" label="回调 URL" />
+          <el-table-column prop="eventType" label="事件类型" width="220" />
+          <el-table-column prop="signatureEnabled" label="签名" width="80">
+            <template #default="{ row }">
+              <el-tag :type="row.signatureEnabled ? 'success' : 'info'" size="small">{{ row.signatureEnabled ? '是' : '否' }}</el-tag>
+            </template>
+          </el-table-column>
+          <el-table-column prop="description" label="描述" />
+        </el-table>
+      </el-tab-pane>
+    </el-tabs>
+
+    <!-- 创建编排对话框 -->
+    <el-dialog v-model="createDialogVisible" title="新建编排" width="700px">
+      <el-form :model="newOrchestration" label-width="100px">
+        <el-form-item label="编排名称" required>
+          <el-input v-model="newOrchestration.orchestrationName" />
+        </el-form-item>
+        <el-form-item label="编码" required>
+          <el-input v-model="newOrchestration.orchestrationCode" />
+        </el-form-item>
+        <el-form-item label="描述">
+          <el-input v-model="newOrchestration.description" type="textarea" :rows="2" />
+        </el-form-item>
+        <el-form-item label="触发方式">
+          <el-select v-model="newOrchestration.triggerType" style="width:100%">
+            <el-option label="手动" value="manual" />
+            <el-option label="定时" value="scheduled" />
+            <el-option label="事件" value="event" />
+          </el-select>
+        </el-form-item>
+        <el-form-item label="编排步骤">
+          <div v-for="(step, index) in newSteps" :key="index" class="step-row">
+            <el-input v-model="step.stepName" placeholder="步骤名称" style="width:140px" />
+            <el-select v-model="step.targetSystem" placeholder="目标系统" style="width:120px;margin:0 8px">
+              <el-option label="IoT" value="iot" />
+              <el-option label="营收" value="revenue" />
+              <el-option label="巡检" value="patrol" />
+              <el-option label="通知" value="notify" />
+            </el-select>
+            <el-input v-model="step.apiPath" placeholder="API路径" style="width:180px" />
+            <el-button type="danger" size="small" @click="removeStep(index)">删除</el-button>
+          </div>
+          <el-button type="primary" size="small" @click="addStep" style="margin-top:8px">+ 添加步骤</el-button>
+        </el-form-item>
+      </el-form>
+      <template #footer>
+        <el-button @click="createDialogVisible = false">取消</el-button>
+        <el-button type="primary" @click="submitCreate">创建</el-button>
+      </template>
+    </el-dialog>
+
+    <!-- Webhook 注册对话框 -->
+    <el-dialog v-model="webhookDialogVisible" title="注册 Webhook" width="500px">
+      <el-form :model="newWebhook" label-width="100px">
+        <el-form-item label="Webhook ID">
+          <el-input v-model="webhookId" />
+        </el-form-item>
+        <el-form-item label="回调 URL" required>
+          <el-input v-model="newWebhook.callbackUrl" />
+        </el-form-item>
+        <el-form-item label="事件类型">
+          <el-select v-model="newWebhook.eventType" style="width:100%">
+            <el-option label="编排完成" value="orchestration.completed" />
+            <el-option label="编排失败" value="orchestration.failed" />
+            <el-option label="步骤完成" value="orchestration.step.completed" />
+          </el-select>
+        </el-form-item>
+        <el-form-item label="签名密钥">
+          <el-input v-model="newWebhook.secretKey" type="password" />
+        </el-form-item>
+        <el-form-item label="启用签名">
+          <el-switch v-model="newWebhook.signatureEnabled" />
+        </el-form-item>
+        <el-form-item label="描述">
+          <el-input v-model="newWebhook.description" />
+        </el-form-item>
+      </el-form>
+      <template #footer>
+        <el-button @click="webhookDialogVisible = false">取消</el-button>
+        <el-button type="primary" @click="submitWebhook">注册</el-button>
+      </template>
+    </el-dialog>
+
+    <!-- 统计对话框 -->
+    <el-dialog v-model="statsDialogVisible" title="执行统计" width="400px">
+      <el-descriptions :column="1" border>
+        <el-descriptions-item label="总执行次数">{{ stats.total }}</el-descriptions-item>
+        <el-descriptions-item label="已完成">{{ stats.completed }}</el-descriptions-item>
+        <el-descriptions-item label="已失败">{{ stats.failed }}</el-descriptions-item>
+        <el-descriptions-item label="运行中">{{ stats.running }}</el-descriptions-item>
+        <el-descriptions-item label="成功率">{{ stats.successRate }}</el-descriptions-item>
+      </el-descriptions>
+    </el-dialog>
+
+    <!-- 步骤查看对话框 -->
+    <el-dialog v-model="stepsDialogVisible" title="编排步骤" width="600px">
+      <el-steps direction="vertical" :active="viewingSteps.length" finish-status="success">
+        <el-step v-for="(step, idx) in viewingSteps" :key="idx"
+          :title="step.stepName"
+          :description="`${step.targetSystem} → ${step.apiPath} (${step.method}) | 超时: ${step.timeoutMs}ms | 重试: ${step.maxRetries}次${step.skippable ? ' | 可跳过' : ''}`" />
+      </el-steps>
+    </el-dialog>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { ref, reactive, onMounted } from 'vue'
+import { ElMessage, ElMessageBox } from 'element-plus'
+import {
+  type BpmOrchestration, type OrchestrationExecution, type OrchestrationLog,
+  type OrchestrationStep, type WebhookRegistration, type ExecutionStats,
+  createOrchestration, deleteOrchestration, listOrchestrations, toggleOrchestrationStatus,
+  startExecution, listExecutions, cancelExecution, getExecutionStats,
+  getLogsByExecutionNo, registerWebhook, listWebhooks
+} from '@/api/orchestrationApi'
+
+const activeTab = ref('definitions')
+
+// ============== 编排管理 ==============
+const orchestrations = ref<BpmOrchestration[]>([])
+const loadingOrch = ref(false)
+const searchKeyword = ref('')
+const filterStatus = ref<number | undefined>(undefined)
+const createDialogVisible = ref(false)
+const stepsDialogVisible = ref(false)
+const viewingSteps = ref<OrchestrationStep[]>([])
+
+const newOrchestration = reactive<BpmOrchestration>({
+  orchestrationName: '', orchestrationCode: '', description: '',
+  triggerType: 'manual', orchestrationRules: ''
+})
+const newSteps = ref<OrchestrationStep[]>([])
+
+async function loadOrchestrations() {
+  loadingOrch.value = true
+  try {
+    const res: any = await listOrchestrations({ keyword: searchKeyword.value || undefined, status: filterStatus.value, page: 1, size: 50 })
+    orchestrations.value = res.data || []
+  } catch (e) { /* handled by interceptor */ }
+  loadingOrch.value = false
+}
+
+function showCreateDialog() {
+  Object.assign(newOrchestration, { orchestrationName: '', orchestrationCode: '', description: '', triggerType: 'manual' })
+  newSteps.value = [{ stepName: '', targetSystem: 'iot', apiPath: '', method: 'GET', timeoutMs: 5000, skippable: false, maxRetries: 3 }]
+  createDialogVisible.value = true
+}
+
+function addStep() {
+  newSteps.value.push({ stepName: '', targetSystem: 'iot', apiPath: '', method: 'GET', timeoutMs: 5000, skippable: false, maxRetries: 3 })
+}
+
+function removeStep(idx: number) {
+  newSteps.value.splice(idx, 1)
+}
+
+async function submitCreate() {
+  if (!newOrchestration.orchestrationName || !newOrchestration.orchestrationCode) {
+    ElMessage.warning('请填写编排名称和编码')
+    return
+  }
+  newOrchestration.orchestrationRules = JSON.stringify(newSteps.value)
+  try {
+    await createOrchestration(newOrchestration)
+    ElMessage.success('创建成功')
+    createDialogVisible.value = false
+    loadOrchestrations()
+  } catch (e) { /* handled */ }
+}
+
+function viewSteps(row: BpmOrchestration) {
+  try {
+    viewingSteps.value = row.orchestrationRules ? JSON.parse(row.orchestrationRules) : []
+  } catch { viewingSteps.value = [] }
+  stepsDialogVisible.value = true
+}
+
+async function toggleStatus(row: BpmOrchestration) {
+  const newStatus = row.status === 1 ? 2 : 1
+  try {
+    await toggleOrchestrationStatus(row.id!, newStatus)
+    ElMessage.success(newStatus === 1 ? '已启用' : '已停用')
+    loadOrchestrations()
+  } catch (e) { /* handled */ }
+}
+
+async function deleteOrch(row: BpmOrchestration) {
+  try {
+    await ElMessageBox.confirm('确认删除该编排？', '提示', { type: 'warning' })
+    await deleteOrchestration(row.id!)
+    ElMessage.success('已删除')
+    loadOrchestrations()
+  } catch (e) { /* cancelled */ }
+}
+
+async function executeOrchestration(row: BpmOrchestration) {
+  try {
+    await startExecution({ orchestrationId: row.id!, triggeredBy: '当前用户', triggerType: 'manual' })
+    ElMessage.success('执行已启动')
+    loadExecutions()
+  } catch (e) { /* handled */ }
+}
+
+// ============== 执行记录 ==============
+const executions = ref<OrchestrationExecution[]>([])
+const loadingExec = ref(false)
+const filterExecStatus = ref<string | undefined>(undefined)
+const statsDialogVisible = ref(false)
+const stats = reactive<ExecutionStats>({ total: 0, completed: 0, failed: 0, running: 0, successRate: 'N/A' })
+
+async function loadExecutions() {
+  loadingExec.value = true
+  try {
+    const res: any = await listExecutions({ status: filterExecStatus.value, page: 1, size: 50 })
+    executions.value = res.data || []
+  } catch (e) { /* handled */ }
+  loadingExec.value = false
+}
+
+async function cancelExec(row: OrchestrationExecution) {
+  try {
+    await ElMessageBox.confirm('确认取消该执行？', '提示', { type: 'warning' })
+    await cancelExecution(row.id)
+    ElMessage.success('已取消')
+    loadExecutions()
+  } catch (e) { /* cancelled */ }
+}
+
+async function loadStats() {
+  try {
+    const res: any = await getExecutionStats()
+    Object.assign(stats, res.data)
+    statsDialogVisible.value = true
+  } catch (e) { /* handled */ }
+}
+
+// ============== 日志 ==============
+const logs = ref<OrchestrationLog[]>([])
+const logExecutionNo = ref('')
+
+async function viewLogs(row: OrchestrationExecution) {
+  logExecutionNo.value = row.executionNo
+  activeTab.value = 'logs'
+  await loadLogsByNo()
+}
+
+async function loadLogsByNo() {
+  if (!logExecutionNo.value) return
+  try {
+    const res: any = await getLogsByExecutionNo(logExecutionNo.value)
+    logs.value = res.data || []
+  } catch (e) { logs.value = [] }
+}
+
+// ============== Webhook ==============
+const webhooks = ref<WebhookRegistration[]>([])
+const webhookDialogVisible = ref(false)
+const webhookId = ref('')
+const newWebhook = reactive<WebhookRegistration>({
+  callbackUrl: '', secretKey: '', signatureEnabled: true, eventType: 'orchestration.completed', description: ''
+})
+
+async function loadWebhooks() {
+  try {
+    const res: any = await listWebhooks()
+    webhooks.value = res.data || []
+  } catch (e) { /* handled */ }
+}
+
+function showWebhookDialog() {
+  webhookId.value = ''
+  Object.assign(newWebhook, { callbackUrl: '', secretKey: '', signatureEnabled: true, eventType: 'orchestration.completed', description: '' })
+  webhookDialogVisible.value = true
+}
+
+async function submitWebhook() {
+  if (!webhookId.value || !newWebhook.callbackUrl) {
+    ElMessage.warning('请填写 Webhook ID 和回调 URL')
+    return
+  }
+  try {
+    await registerWebhook(webhookId.value, newWebhook)
+    ElMessage.success('注册成功')
+    webhookDialogVisible.value = false
+    loadWebhooks()
+  } catch (e) { /* handled */ }
+}
+
+// ============== 辅助 ==============
+function statusLabel(s: number) { return s === 0 ? '草稿' : s === 1 ? '启用' : '停用' }
+function statusTag(s: number) { return s === 0 ? 'info' : s === 1 ? 'success' : 'danger' }
+function triggerTypeLabel(t: string) { return t === 'manual' ? '手动' : t === 'scheduled' ? '定时' : '事件' }
+function triggerTypeTag(t: string) { return t === 'manual' ? 'info' : t === 'scheduled' ? 'warning' : 'primary' }
+function execStatusTag(s: string) { return s === 'completed' ? 'success' : s === 'failed' ? 'danger' : s === 'running' ? 'primary' : 'info' }
+
+onMounted(() => {
+  loadOrchestrations()
+  loadExecutions()
+  loadWebhooks()
+})
+</script>
+
+<style scoped>
+.orchestration-container { padding: 20px; }
+.toolbar { display: flex; align-items: center; }
+.step-row { display: flex; align-items: center; margin-bottom: 8px; }
+</style>

wm-bpm/src/main/java/com/water/bpm/config/WebhookConfig.java

@@ -0,0 +1,199 @@
+package com.water.bpm.config;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.water.bpm.entity.dto.WebhookRegistration;
+import lombok.Data;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.*;
+import org.springframework.stereotype.Component;
+import org.springframework.web.client.RestTemplate;
+
+import javax.crypto.Mac;
+import javax.crypto.spec.SecretKeySpec;
+import java.nio.charset.StandardCharsets;
+import java.security.InvalidKeyException;
+import java.security.NoSuchAlgorithmException;
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.stream.Collectors;
+
+/**
+ * Webhook 回调配置管理
+ * 负责 Webhook 注册、签名验证和回调触发
+ */
+@Slf4j
+@Component
+public class WebhookConfig {
+
+    private final Map<String, WebhookRegistration> registrations = new ConcurrentHashMap<>();
+    private final RestTemplate restTemplate;
+    private final ObjectMapper objectMapper;
+
+    public WebhookConfig() {
+        this.restTemplate = new RestTemplate();
+        this.objectMapper = new ObjectMapper();
+        // 注册默认 Webhook (示例)
+        registerDefaultWebhooks();
+    }
+
+    /**
+     * 注册 Webhook
+     */
+    public WebhookRegistration register(String id, WebhookRegistration registration) {
+        registrations.put(id, registration);
+        log.info("Webhook registered: id={}, url={}, eventType={}", id, registration.getCallbackUrl(), registration.getEventType());
+        return registration;
+    }
+
+    /**
+     * 注销 Webhook
+     */
+    public void unregister(String id) {
+        registrations.remove(id);
+        log.info("Webhook unregistered: id={}", id);
+    }
+
+    /**
+     * 获取所有注册的 Webhook
+     */
+    public List<WebhookRegistration> listAll() {
+        return new ArrayList<>(registrations.values());
+    }
+
+    /**
+     * 根据 ID 获取 Webhook
+     */
+    public WebhookRegistration getById(String id) {
+        return registrations.get(id);
+    }
+
+    /**
+     * 根据事件类型获取 Webhook 列表
+     */
+    public List<WebhookRegistration> getByEventType(String eventType) {
+        return registrations.values().stream()
+                .filter(r -> eventType.equals(r.getEventType()))
+                .collect(Collectors.toList());
+    }
+
+    /**
+     * 触发 Webhook 回调
+     *
+     * @param eventType 事件类型
+     * @param payload   回调数据
+     * @return 回调结果列表
+     */
+    public List<WebhookCallbackResult> triggerCallback(String eventType, Map<String, Object> payload) {
+        List<WebhookRegistration> hooks = getByEventType(eventType);
+        List<WebhookCallbackResult> results = new ArrayList<>();
+
+        for (WebhookRegistration hook : hooks) {
+            WebhookCallbackResult result = sendCallback(hook, payload);
+            results.add(result);
+        }
+
+        return results;
+    }
+
+    /**
+     * 发送单个回调
+     */
+    private WebhookCallbackResult sendCallback(WebhookRegistration hook, Map<String, Object> payload) {
+        WebhookCallbackResult result = new WebhookCallbackResult();
+        result.setCallbackUrl(hook.getCallbackUrl());
+        result.setEventType(hook.getEventType());
+
+        try {
+            String jsonPayload = objectMapper.writeValueAsString(payload);
+
+            HttpHeaders headers = new HttpHeaders();
+            headers.setContentType(MediaType.APPLICATION_JSON);
+            headers.set("X-Webhook-Event", hook.getEventType());
+            headers.set("X-Webhook-Timestamp", String.valueOf(System.currentTimeMillis()));
+
+            // HMAC-SHA256 签名
+            if (Boolean.TRUE.equals(hook.getSignatureEnabled()) && hook.getSecretKey() != null) {
+                String signature = generateSignature(jsonPayload, hook.getSecretKey());
+                headers.set("X-Webhook-Signature", signature);
+                log.debug("Webhook signature generated for {}", hook.getCallbackUrl());
+            }
+
+            HttpEntity<String> entity = new HttpEntity<>(jsonPayload, headers);
+            long startTime = System.currentTimeMillis();
+
+            ResponseEntity<String> response = restTemplate.exchange(
+                    hook.getCallbackUrl(), HttpMethod.POST, entity, String.class);
+
+            long duration = System.currentTimeMillis() - startTime;
+
+            result.setSuccess(response.getStatusCode().is2xxSuccessful());
+            result.setHttpStatus(response.getStatusCode().value());
+            result.setResponseBody(response.getBody());
+            result.setDurationMs(duration);
+
+            log.info("Webhook callback sent: url={}, status={}, duration={}ms",
+                    hook.getCallbackUrl(), response.getStatusCode(), duration);
+
+        } catch (Exception e) {
+            result.setSuccess(false);
+            result.setErrorMessage(e.getMessage());
+            log.warn("Webhook callback failed: url={}, error={}", hook.getCallbackUrl(), e.getMessage());
+        }
+
+        return result;
+    }
+
+    /**
+     * 生成 HMAC-SHA256 签名
+     */
+    public String generateSignature(String payload, String secretKey) {
+        try {
+            Mac mac = Mac.getInstance("HmacSHA256");
+            SecretKeySpec keySpec = new SecretKeySpec(
+                    secretKey.getBytes(StandardCharsets.UTF_8), "HmacSHA256");
+            mac.init(keySpec);
+            byte[] hash = mac.doFinal(payload.getBytes(StandardCharsets.UTF_8));
+            return bytesToHex(hash);
+        } catch (NoSuchAlgorithmException | InvalidKeyException e) {
+            throw new RuntimeException("Failed to generate HMAC-SHA256 signature", e);
+        }
+    }
+
+    /**
+     * 验证 Webhook 签名
+     */
+    public boolean verifySignature(String payload, String secretKey, String signature) {
+        String expected = generateSignature(payload, secretKey);
+        return expected.equals(signature);
+    }
+
+    private String bytesToHex(byte[] bytes) {
+        StringBuilder sb = new StringBuilder();
+        for (byte b : bytes) {
+            sb.append(String.format("%02x", b));
+        }
+        return sb.toString();
+    }
+
+    /**
+     * 注册默认 Webhook (开发测试用)
+     */
+    private void registerDefaultWebhooks() {
+        // 开发环境默认不注册外部 webhook，仅记录日志
+        log.info("WebhookConfig initialized, no default webhooks registered");
+    }
+
+    /**
+     * Webhook 回调结果
+     */
+    @Data
+    public static class WebhookCallbackResult {
+        private String callbackUrl;
+        private String eventType;
+        private boolean success;
+        private int httpStatus;
+        private String responseBody;
+        private String errorMessage;
+        private long durationMs;
+    }
+}

wm-bpm/src/main/java/com/water/bpm/controller/ProcessOrchestrationController.java

@@ -0,0 +1,212 @@
+package com.water.bpm.controller;
+
+import com.water.bpm.config.WebhookConfig;
+import com.water.bpm.entity.BpmOrchestration;
+import com.water.bpm.entity.OrchestrationExecution;
+import com.water.bpm.entity.OrchestrationLog;
+import com.water.bpm.entity.dto.WebhookRegistration;
+import com.water.bpm.service.OrchestrationLogService;
+import com.water.bpm.service.ProcessOrchestrationService;
+import com.water.common.core.result.R;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import lombok.RequiredArgsConstructor;
+import org.springframework.web.bind.annotation.*;
+
+import java.time.LocalDateTime;
+import java.util.*;
+
+/**
+ * 跨系统流程编排控制器
+ */
+@Tag(name = "流程编排")
+@RestController
+@RequestMapping("/bpm/orchestration")
+@RequiredArgsConstructor
+public class ProcessOrchestrationController {
+
+    private final ProcessOrchestrationService orchestrationService;
+    private final OrchestrationLogService logService;
+    private final WebhookConfig webhookConfig;
+
+    // ============== 编排定义 ==============
+
+    @Operation(summary = "创建编排定义")
+    @PostMapping("/definitions")
+    public R<BpmOrchestration> createDefinition(@RequestBody BpmOrchestration orchestration) {
+        return R.ok(orchestrationService.createOrchestration(orchestration));
+    }
+
+    @Operation(summary = "更新编排定义")
+    @PutMapping("/definitions/{id}")
+    public R<BpmOrchestration> updateDefinition(@PathVariable Long id, @RequestBody BpmOrchestration orchestration) {
+        return R.ok(orchestrationService.updateOrchestration(id, orchestration));
+    }
+
+    @Operation(summary = "删除编排定义")
+    @DeleteMapping("/definitions/{id}")
+    public R<Void> deleteDefinition(@PathVariable Long id) {
+        orchestrationService.deleteOrchestration(id);
+        return R.ok();
+    }
+
+    @Operation(summary = "获取编排定义")
+    @GetMapping("/definitions/{id}")
+    public R<BpmOrchestration> getDefinition(@PathVariable Long id) {
+        return R.ok(orchestrationService.getOrchestration(id));
+    }
+
+    @Operation(summary = "查询编排列表")
+    @GetMapping("/definitions")
+    public R<List<BpmOrchestration>> listDefinitions(
+            @RequestParam(required = false) String keyword,
+            @RequestParam(required = false) Integer status,
+            @RequestParam(defaultValue = "1") int page,
+            @RequestParam(defaultValue = "20") int size) {
+        return R.ok(orchestrationService.listOrchestrations(keyword, status, page, size));
+    }
+
+    @Operation(summary = "启用/停用编排")
+    @PutMapping("/definitions/{id}/status")
+    public R<BpmOrchestration> toggleStatus(@PathVariable Long id, @RequestParam Integer status) {
+        return R.ok(orchestrationService.toggleStatus(id, status));
+    }
+
+    // ============== 编排执行 ==============
+
+    @Operation(summary = "启动编排执行")
+    @PostMapping("/executions")
+    public R<OrchestrationExecution> startExecution(@RequestBody Map<String, Object> request) {
+        Long orchestrationId = Long.parseLong(String.valueOf(request.get("orchestrationId")));
+        String triggeredBy = (String) request.getOrDefault("triggeredBy", "system");
+        String triggerType = (String) request.getOrDefault("triggerType", "manual");
+        @SuppressWarnings("unchecked")
+        Map<String, Object> inputParams = (Map<String, Object>) request.getOrDefault("inputParams", new HashMap<>());
+        return R.ok(orchestrationService.startExecution(orchestrationId, triggeredBy, triggerType, inputParams));
+    }
+
+    @Operation(summary = "获取执行记录")
+    @GetMapping("/executions/{id}")
+    public R<OrchestrationExecution> getExecution(@PathVariable Long id) {
+        return R.ok(orchestrationService.getExecution(id));
+    }
+
+    @Operation(summary = "按编号获取执行记录")
+    @GetMapping("/executions/no/{executionNo}")
+    public R<OrchestrationExecution> getExecutionByNo(@PathVariable String executionNo) {
+        return R.ok(orchestrationService.getExecutionByNo(executionNo));
+    }
+
+    @Operation(summary = "查询执行记录列表")
+    @GetMapping("/executions")
+    public R<List<OrchestrationExecution>> listExecutions(
+            @RequestParam(required = false) Long orchestrationId,
+            @RequestParam(required = false) String status,
+            @RequestParam(defaultValue = "1") int page,
+            @RequestParam(defaultValue = "20") int size) {
+        return R.ok(orchestrationService.listExecutions(orchestrationId, status, page, size));
+    }
+
+    @Operation(summary = "取消执行")
+    @PutMapping("/executions/{id}/cancel")
+    public R<OrchestrationExecution> cancelExecution(@PathVariable Long id) {
+        return R.ok(orchestrationService.cancelExecution(id));
+    }
+
+    @Operation(summary = "获取执行统计")
+    @GetMapping("/executions/stats")
+    public R<Map<String, Object>> getExecutionStats(@RequestParam(required = false) Long orchestrationId) {
+        return R.ok(orchestrationService.getExecutionStats(orchestrationId));
+    }
+
+    // ============== 编排日志 ==============
+
+    @Operation(summary = "查询执行日志")
+    @GetMapping("/logs")
+    public R<List<OrchestrationLog>> getLogs(
+            @RequestParam(required = false) Long executionId,
+            @RequestParam(required = false) String action,
+            @RequestParam(required = false) Boolean success,
+            @RequestParam(required = false) String startTime,
+            @RequestParam(required = false) String endTime,
+            @RequestParam(defaultValue = "1") int page,
+            @RequestParam(defaultValue = "50") int size) {
+        LocalDateTime start = startTime != null ? LocalDateTime.parse(startTime) : null;
+        LocalDateTime end = endTime != null ? LocalDateTime.parse(endTime) : null;
+        return R.ok(logService.queryLogs(executionId, action, success, start, end, page, size));
+    }
+
+    @Operation(summary = "按执行ID查询日志")
+    @GetMapping("/logs/execution/{executionId}")
+    public R<List<OrchestrationLog>> getLogsByExecutionId(@PathVariable Long executionId) {
+        return R.ok(logService.getLogsByExecutionId(executionId));
+    }
+
+    @Operation(summary = "按执行编号查询日志")
+    @GetMapping("/logs/execution-no/{executionNo}")
+    public R<List<OrchestrationLog>> getLogsByExecutionNo(@PathVariable String executionNo) {
+        return R.ok(logService.getLogsByExecutionNo(executionNo));
+    }
+
+    @Operation(summary = "查询步骤日志")
+    @GetMapping("/logs/execution/{executionId}/step/{stepIndex}")
+    public R<List<OrchestrationLog>> getStepLogs(@PathVariable Long executionId, @PathVariable Integer stepIndex) {
+        return R.ok(logService.getLogsByStep(executionId, stepIndex));
+    }
+
+    @Operation(summary = "日志统计")
+    @GetMapping("/logs/count")
+    public R<Map<String, Object>> countLogs(@RequestParam(required = false) Long executionId) {
+        Map<String, Object> result = new HashMap<>();
+        result.put("count", logService.countLogs(executionId));
+        return R.ok(result);
+    }
+
+    // ============== Webhook 管理 ==============
+
+    @Operation(summary = "注册 Webhook")
+    @PostMapping("/webhooks")
+    public R<WebhookRegistration> registerWebhook(@RequestParam String id, @RequestBody WebhookRegistration registration) {
+        return R.ok(webhookConfig.register(id, registration));
+    }
+
+    @Operation(summary = "注销 Webhook")
+    @DeleteMapping("/webhooks/{id}")
+    public R<Void> unregisterWebhook(@PathVariable String id) {
+        webhookConfig.unregister(id);
+        return R.ok();
+    }
+
+    @Operation(summary = "获取所有 Webhook")
+    @GetMapping("/webhooks")
+    public R<List<WebhookRegistration>> listWebhooks() {
+        return R.ok(webhookConfig.listAll());
+    }
+
+    @Operation(summary = "获取单个 Webhook")
+    @GetMapping("/webhooks/{id}")
+    public R<WebhookRegistration> getWebhook(@PathVariable String id) {
+        return R.ok(webhookConfig.getById(id));
+    }
+
+    @Operation(summary = "手动触发 Webhook 回调")
+    @PostMapping("/webhooks/trigger")
+    public R<List<WebhookConfig.WebhookCallbackResult>> triggerWebhook(@RequestBody Map<String, Object> request) {
+        String eventType = (String) request.get("eventType");
+        @SuppressWarnings("unchecked")
+        Map<String, Object> payload = (Map<String, Object>) request.getOrDefault("payload", new HashMap<>());
+        return R.ok(webhookConfig.triggerCallback(eventType, payload));
+    }
+
+    @Operation(summary = "验证 Webhook 签名")
+    @PostMapping("/webhooks/verify-signature")
+    public R<Map<String, Object>> verifySignature(@RequestBody Map<String, String> request) {
+        String payload = request.get("payload");
+        String secretKey = request.get("secretKey");
+        String signature = request.get("signature");
+        boolean valid = webhookConfig.verifySignature(payload, secretKey, signature);
+        Map<String, Object> result = new HashMap<>();
+        result.put("valid", valid);
+        return R.ok(result);
+    }
+}

wm-bpm/src/main/java/com/water/bpm/entity/OrchestrationExecution.java

@@ -0,0 +1,60 @@
+package com.water.bpm.entity;
+
+import com.baomidou.mybatisplus.annotation.*;
+import com.water.common.core.entity.BaseEntity;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+import java.time.LocalDateTime;
+
+/**
+ * 编排执行记录实体
+ * 记录每次编排执行的完整生命周期
+ */
+@Data
+@EqualsAndHashCode(callSuper = true)
+@TableName("bpm_orchestration_execution")
+public class OrchestrationExecution extends BaseEntity {
+
+    /** 编排ID */
+    private Long orchestrationId;
+
+    /** 执行编号 (UUID) */
+    private String executionNo;
+
+    /** 当前步骤索引 (从0开始) */
+    private Integer currentStepIndex;
+
+    /** 当前步骤名称 */
+    private String currentStepName;
+
+    /** 执行状态: pending/running/completed/failed/cancelled */
+    private String status;
+
+    /** 开始时间 */
+    private LocalDateTime startedAt;
+
+    /** 完成时间 */
+    private LocalDateTime completedAt;
+
+    /** 触发人 */
+    private String triggeredBy;
+
+    /** 触发方式: manual/scheduled/event */
+    private String triggerType;
+
+    /** 输入参数 JSON */
+    private String inputParams;
+
+    /** 输出结果 JSON */
+    private String outputResult;
+
+    /** 失败原因 */
+    private String failureReason;
+
+    /** 重试次数 */
+    private Integer retryCount;
+
+    /** 租户ID */
+    private String tenantId;
+}

wm-bpm/src/main/java/com/water/bpm/entity/OrchestrationLog.java

@@ -0,0 +1,60 @@
+package com.water.bpm.entity;
+
+import com.baomidou.mybatisplus.annotation.*;
+import com.water.common.core.entity.BaseEntity;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+import java.time.LocalDateTime;
+
+/**
+ * 编排日志实体
+ * 记录编排执行过程中每个步骤的详细日志
+ */
+@Data
+@EqualsAndHashCode(callSuper = true)
+@TableName("bpm_orchestration_log")
+public class OrchestrationLog extends BaseEntity {
+
+    /** 执行ID */
+    private Long executionId;
+
+    /** 执行编号 */
+    private String executionNo;
+
+    /** 步骤索引 */
+    private Integer stepIndex;
+
+    /** 步骤名称 */
+    private String stepName;
+
+    /** 动作类型: start/complete/fail/retry/callback/skip */
+    private String action;
+
+    /** 目标系统: iot/revenue/patrol/notify/internal */
+    private String targetSystem;
+
+    /** 请求内容 JSON */
+    private String requestBody;
+
+    /** 响应内容 JSON */
+    private String responseBody;
+
+    /** HTTP状态码 */
+    private Integer httpStatus;
+
+    /** 耗时(毫秒) */
+    private Long durationMs;
+
+    /** 是否成功 */
+    private Boolean success;
+
+    /** 错误信息 */
+    private String errorMessage;
+
+    /** 日志时间 */
+    private LocalDateTime logTime;
+
+    /** 操作人 */
+    private String operator;
+}

wm-bpm/src/main/java/com/water/bpm/entity/dto/OrchestrationStep.java

@@ -0,0 +1,31 @@
+package com.water.bpm.entity.dto;
+
+import lombok.Data;
+
+/**
+ * 编排步骤定义
+ */
+@Data
+public class OrchestrationStep {
+
+    /** 步骤名称 */
+    private String stepName;
+
+    /** 目标系统: iot/revenue/patrol/notify */
+    private String targetSystem;
+
+    /** API路径 (模拟) */
+    private String apiPath;
+
+    /** 请求方法: GET/POST/PUT/DELETE */
+    private String method;
+
+    /** 超时时间(毫秒) */
+    private Integer timeoutMs;
+
+    /** 是否允许跳过 */
+    private Boolean skippable;
+
+    /** 重试次数上限 */
+    private Integer maxRetries;
+}

wm-bpm/src/main/java/com/water/bpm/entity/dto/WebhookRegistration.java

@@ -0,0 +1,25 @@
+package com.water.bpm.entity.dto;
+
+import lombok.Data;
+
+/**
+ * Webhook 回调注册
+ */
+@Data
+public class WebhookRegistration {
+
+    /** 回调URL */
+    private String callbackUrl;
+
+    /** 签名密钥 */
+    private String secretKey;
+
+    /** 是否启用签名验证 */
+    private Boolean signatureEnabled;
+
+    /** 事件类型: orchestration.completed/orchestration.failed/orchestration.step.completed */
+    private String eventType;
+
+    /** 描述 */
+    private String description;
+}

wm-bpm/src/main/java/com/water/bpm/mapper/OrchestrationExecutionMapper.java

@@ -0,0 +1,22 @@
+package com.water.bpm.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.water.bpm.entity.OrchestrationExecution;
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+import org.apache.ibatis.annotations.Select;
+
+import java.util.List;
+
+@Mapper
+public interface OrchestrationExecutionMapper extends BaseMapper<OrchestrationExecution> {
+
+    @Select("SELECT * FROM bpm_orchestration_execution WHERE orchestration_id = #{orchestrationId} AND deleted = 0 ORDER BY created_at DESC")
+    List<OrchestrationExecution> selectByOrchestrationId(@Param("orchestrationId") Long orchestrationId);
+
+    @Select("SELECT * FROM bpm_orchestration_execution WHERE execution_no = #{executionNo} AND deleted = 0 LIMIT 1")
+    OrchestrationExecution selectByExecutionNo(@Param("executionNo") String executionNo);
+
+    @Select("SELECT * FROM bpm_orchestration_execution WHERE status = #{status} AND deleted = 0 ORDER BY created_at ASC")
+    List<OrchestrationExecution> selectByStatus(@Param("status") String status);
+}

wm-bpm/src/main/java/com/water/bpm/mapper/OrchestrationLogMapper.java

@@ -0,0 +1,22 @@
+package com.water.bpm.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.water.bpm.entity.OrchestrationLog;
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+import org.apache.ibatis.annotations.Select;
+
+import java.util.List;
+
+@Mapper
+public interface OrchestrationLogMapper extends BaseMapper<OrchestrationLog> {
+
+    @Select("SELECT * FROM bpm_orchestration_log WHERE execution_id = #{executionId} AND deleted = 0 ORDER BY log_time ASC")
+    List<OrchestrationLog> selectByExecutionId(@Param("executionId") Long executionId);
+
+    @Select("SELECT * FROM bpm_orchestration_log WHERE execution_no = #{executionNo} AND deleted = 0 ORDER BY log_time ASC")
+    List<OrchestrationLog> selectByExecutionNo(@Param("executionNo") String executionNo);
+
+    @Select("SELECT * FROM bpm_orchestration_log WHERE execution_id = #{executionId} AND step_index = #{stepIndex} AND deleted = 0 ORDER BY log_time ASC")
+    List<OrchestrationLog> selectByStep(@Param("executionId") Long executionId, @Param("stepIndex") Integer stepIndex);
+}

wm-bpm/src/main/java/com/water/bpm/service/OrchestrationLogService.java

@@ -0,0 +1,115 @@
+package com.water.bpm.service;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.water.bpm.entity.OrchestrationLog;
+import com.water.bpm.mapper.OrchestrationLogMapper;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+/**
+ * 编排日志服务
+ * 负责记录、查询编排执行过程中的详细日志
+ */
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class OrchestrationLogService {
+
+    private final OrchestrationLogMapper orchestrationLogMapper;
+
+    /**
+     * 记录日志
+     */
+    public OrchestrationLog recordLog(Long executionId, String executionNo, Integer stepIndex,
+                                       String stepName, String action, String targetSystem,
+                                       String requestBody, String responseBody,
+                                       Integer httpStatus, Long durationMs,
+                                       Boolean success, String errorMessage, String operator) {
+        OrchestrationLog logEntry = new OrchestrationLog();
+        logEntry.setExecutionId(executionId);
+        logEntry.setExecutionNo(executionNo);
+        logEntry.setStepIndex(stepIndex);
+        logEntry.setStepName(stepName);
+        logEntry.setAction(action);
+        logEntry.setTargetSystem(targetSystem);
+        logEntry.setRequestBody(requestBody);
+        logEntry.setResponseBody(responseBody);
+        logEntry.setHttpStatus(httpStatus);
+        logEntry.setDurationMs(durationMs);
+        logEntry.setSuccess(success);
+        logEntry.setErrorMessage(errorMessage);
+        logEntry.setLogTime(LocalDateTime.now());
+        logEntry.setOperator(operator);
+        logEntry.setCreatedAt(LocalDateTime.now());
+
+        orchestrationLogMapper.insert(logEntry);
+        log.debug("Recorded orchestration log: executionNo={}, step={}, action={}, success={}",
+                executionNo, stepName, action, success);
+
+        return logEntry;
+    }
+
+    /**
+     * 查询执行日志
+     */
+    public List<OrchestrationLog> getLogsByExecutionId(Long executionId) {
+        return orchestrationLogMapper.selectByExecutionId(executionId);
+    }
+
+    /**
+     * 按执行编号查询日志
+     */
+    public List<OrchestrationLog> getLogsByExecutionNo(String executionNo) {
+        return orchestrationLogMapper.selectByExecutionNo(executionNo);
+    }
+
+    /**
+     * 查询指定步骤的日志
+     */
+    public List<OrchestrationLog> getLogsByStep(Long executionId, Integer stepIndex) {
+        return orchestrationLogMapper.selectByStep(executionId, stepIndex);
+    }
+
+    /**
+     * 分页查询日志
+     */
+    public List<OrchestrationLog> queryLogs(Long executionId, String action, Boolean success,
+                                             LocalDateTime startTime, LocalDateTime endTime,
+                                             int page, int size) {
+        LambdaQueryWrapper<OrchestrationLog> wrapper = new LambdaQueryWrapper<>();
+        if (executionId != null) {
+            wrapper.eq(OrchestrationLog::getExecutionId, executionId);
+        }
+        if (action != null && !action.isEmpty()) {
+            wrapper.eq(OrchestrationLog::getAction, action);
+        }
+        if (success != null) {
+            wrapper.eq(OrchestrationLog::getSuccess, success);
+        }
+        if (startTime != null) {
+            wrapper.ge(OrchestrationLog::getLogTime, startTime);
+        }
+        if (endTime != null) {
+            wrapper.le(OrchestrationLog::getLogTime, endTime);
+        }
+        wrapper.orderByAsc(OrchestrationLog::getLogTime);
+        wrapper.last("LIMIT " + size + " OFFSET " + (page - 1) * size);
+
+        return orchestrationLogMapper.selectList(wrapper);
+    }
+
+    /**
+     * 统计执行日志数量
+     */
+    public long countLogs(Long executionId) {
+        LambdaQueryWrapper<OrchestrationLog> wrapper = new LambdaQueryWrapper<>();
+        if (executionId != null) {
+            wrapper.eq(OrchestrationLog::getExecutionId, executionId);
+        }
+        return orchestrationLogMapper.selectCount(wrapper);
+    }
+}

wm-bpm/src/main/java/com/water/bpm/service/ProcessOrchestrationService.java

@@ -0,0 +1,481 @@
+package com.water.bpm.service;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.water.bpm.config.WebhookConfig;
+import com.water.bpm.entity.BpmOrchestration;
+import com.water.bpm.entity.OrchestrationExecution;
+import com.water.bpm.entity.dto.OrchestrationStep;
+import com.water.bpm.mapper.BpmOrchestrationMapper;
+import com.water.bpm.mapper.OrchestrationExecutionMapper;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.time.LocalDateTime;
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.stream.Collectors;
+
+/**
+ * 跨系统流程编排服务
+ * 负责编排定义管理、执行调度、步骤流转、跨系统API调用、Webhook回调、重试机制
+ */
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class ProcessOrchestrationService {
+
+    private final BpmOrchestrationMapper orchestrationMapper;
+    private final OrchestrationExecutionMapper executionMapper;
+    private final OrchestrationLogService logService;
+    private final WebhookConfig webhookConfig;
+    private final ObjectMapper objectMapper = new ObjectMapper();
+
+    /** 模拟外部系统响应 */
+    private final Map<String, Map<String, Object>> simulatedResponses = new ConcurrentHashMap<>();
+
+    // ============== 编排定义 CRUD ==============
+
+    /**
+     * 创建编排定义
+     */
+    @Transactional
+    public BpmOrchestration createOrchestration(BpmOrchestration orchestration) {
+        orchestration.setStatus(0); // 草稿
+        orchestration.setExecutionCount(0);
+        orchestration.setCreatedAt(LocalDateTime.now());
+        orchestrationMapper.insert(orchestration);
+        log.info("Created orchestration: id={}, name={}", orchestration.getId(), orchestration.getOrchestrationName());
+        return orchestration;
+    }
+
+    /**
+     * 更新编排定义
+     */
+    @Transactional
+    public BpmOrchestration updateOrchestration(Long id, BpmOrchestration orchestration) {
+        orchestration.setId(id);
+        orchestration.setUpdatedAt(LocalDateTime.now());
+        orchestrationMapper.updateById(orchestration);
+        log.info("Updated orchestration: id={}", id);
+        return orchestrationMapper.selectById(id);
+    }
+
+    /**
+     * 删除编排定义 (逻辑删除)
+     */
+    @Transactional
+    public void deleteOrchestration(Long id) {
+        orchestrationMapper.deleteById(id);
+        log.info("Deleted orchestration: id={}", id);
+    }
+
+    /**
+     * 获取编排定义
+     */
+    public BpmOrchestration getOrchestration(Long id) {
+        return orchestrationMapper.selectById(id);
+    }
+
+    /**
+     * 查询编排列表
+     */
+    public List<BpmOrchestration> listOrchestrations(String keyword, Integer status, int page, int size) {
+        LambdaQueryWrapper<BpmOrchestration> wrapper = new LambdaQueryWrapper<>();
+        if (keyword != null && !keyword.isEmpty()) {
+            wrapper.and(w -> w.like(BpmOrchestration::getOrchestrationName, keyword)
+                    .or().like(BpmOrchestration::getOrchestrationCode, keyword));
+        }
+        if (status != null) {
+            wrapper.eq(BpmOrchestration::getStatus, status);
+        }
+        wrapper.orderByDesc(BpmOrchestration::getCreatedAt);
+        wrapper.last("LIMIT " + size + " OFFSET " + (page - 1) * size);
+        return orchestrationMapper.selectList(wrapper);
+    }
+
+    /**
+     * 启用/停用编排
+     */
+    @Transactional
+    public BpmOrchestration toggleStatus(Long id, Integer status) {
+        BpmOrchestration orchestration = orchestrationMapper.selectById(id);
+        if (orchestration == null) {
+            throw new RuntimeException("编排定义不存在: " + id);
+        }
+        orchestration.setStatus(status);
+        orchestration.setUpdatedAt(LocalDateTime.now());
+        orchestrationMapper.updateById(orchestration);
+        log.info("Orchestration status changed: id={}, status={}", id, status);
+        return orchestration;
+    }
+
+    // ============== 编排执行 ==============
+
+    /**
+     * 启动编排执行
+     */
+    @Transactional
+    public OrchestrationExecution startExecution(Long orchestrationId, String triggeredBy,
+                                                   String triggerType, Map<String, Object> inputParams) {
+        BpmOrchestration orchestration = orchestrationMapper.selectById(orchestrationId);
+        if (orchestration == null) {
+            throw new RuntimeException("编排定义不存在: " + orchestrationId);
+        }
+        if (orchestration.getStatus() != 1) {
+            throw new RuntimeException("编排未启用，无法执行: " + orchestration.getOrchestrationName());
+        }
+
+        // 解析编排步骤
+        List<OrchestrationStep> steps = parseSteps(orchestration.getOrchestrationRules());
+        if (steps.isEmpty()) {
+            throw new RuntimeException("编排步骤为空: " + orchestration.getOrchestrationName());
+        }
+
+        // 创建执行记录
+        OrchestrationExecution execution = new OrchestrationExecution();
+        execution.setOrchestrationId(orchestrationId);
+        execution.setExecutionNo(UUID.randomUUID().toString());
+        execution.setCurrentStepIndex(0);
+        execution.setCurrentStepName(steps.get(0).getStepName());
+        execution.setStatus("running");
+        execution.setStartedAt(LocalDateTime.now());
+        execution.setTriggeredBy(triggeredBy);
+        execution.setTriggerType(triggerType);
+        execution.setRetryCount(0);
+        execution.setCreatedAt(LocalDateTime.now());
+
+        try {
+            execution.setInputParams(objectMapper.writeValueAsString(inputParams));
+        } catch (JsonProcessingException e) {
+            execution.setInputParams("{}");
+        }
+
+        executionMapper.insert(execution);
+
+        // 更新编排执行次数
+        orchestration.setExecutionCount(orchestration.getExecutionCount() + 1);
+        orchestrationMapper.updateById(orchestration);
+
+        // 记录开始日志
+        logService.recordLog(execution.getId(), execution.getExecutionNo(), 0,
+                steps.get(0).getStepName(), "start", "internal",
+                execution.getInputParams(), null, null, 0L, true, null, triggeredBy);
+
+        log.info("Started orchestration execution: orchestrationId={}, executionNo={}, steps={}",
+                orchestrationId, execution.getExecutionNo(), steps.size());
+
+        // 异步执行步骤 (这里同步模拟)
+        executeSteps(execution, steps, inputParams);
+
+        return executionMapper.selectById(execution.getId());
+    }
+
+    /**
+     * 执行编排步骤 (同步模拟，生产环境应异步)
+     */
+    private void executeSteps(OrchestrationExecution execution, List<OrchestrationStep> steps,
+                               Map<String, Object> inputParams) {
+        int startIndex = execution.getCurrentStepIndex();
+        Map<String, Object> context = new HashMap<>(inputParams != null ? inputParams : Collections.emptyMap());
+
+        for (int i = startIndex; i < steps.size(); i++) {
+            OrchestrationStep step = steps.get(i);
+            long stepStart = System.currentTimeMillis();
+
+            log.info("Executing step {}/{}: {} -> {}", i + 1, steps.size(),
+                    step.getStepName(), step.getTargetSystem());
+
+            // 更新当前步骤
+            execution.setCurrentStepIndex(i);
+            execution.setCurrentStepName(step.getStepName());
+            executionMapper.updateById(execution);
+
+            // 执行步骤 (含重试)
+            boolean success = executeStepWithRetry(execution, step, i, context);
+
+            long duration = System.currentTimeMillis() - stepStart;
+
+            if (success) {
+                // 步骤完成日志
+                logService.recordLog(execution.getId(), execution.getExecutionNo(), i,
+                        step.getStepName(), "complete", step.getTargetSystem(),
+                        null, "{\"status\":\"success\"}", 200, duration, true, null, execution.getTriggeredBy());
+
+                // 触发步骤完成 Webhook
+                Map<String, Object> stepPayload = new HashMap<>();
+                stepPayload.put("executionNo", execution.getExecutionNo());
+                stepPayload.put("stepIndex", i);
+                stepPayload.put("stepName", step.getStepName());
+                stepPayload.put("targetSystem", step.getTargetSystem());
+                stepPayload.put("success", true);
+                webhookConfig.triggerCallback("orchestration.step.completed", stepPayload);
+
+                log.info("Step completed: {} ({}ms)", step.getStepName(), duration);
+            } else {
+                // 步骤失败
+                if (Boolean.TRUE.equals(step.getSkippable())) {
+                    logService.recordLog(execution.getId(), execution.getExecutionNo(), i,
+                            step.getStepName(), "skip", step.getTargetSystem(),
+                            null, null, null, duration, false, "步骤失败但可跳过", execution.getTriggeredBy());
+                    log.warn("Step failed but skippable: {}", step.getStepName());
+                } else {
+                    // 不可跳过，执行失败
+                    execution.setStatus("failed");
+                    execution.setCompletedAt(LocalDateTime.now());
+                    execution.setFailureReason("步骤失败: " + step.getStepName());
+                    executionMapper.updateById(execution);
+
+                    logService.recordLog(execution.getId(), execution.getExecutionNo(), i,
+                            step.getStepName(), "fail", step.getTargetSystem(),
+                            null, null, 500, duration, false, "步骤执行失败，已达最大重试次数", execution.getTriggeredBy());
+
+                    // 触发失败 Webhook
+                    Map<String, Object> failPayload = new HashMap<>();
+                    failPayload.put("executionNo", execution.getExecutionNo());
+                    failPayload.put("orchestrationId", execution.getOrchestrationId());
+                    failPayload.put("failedStep", step.getStepName());
+                    failPayload.put("reason", "步骤执行失败");
+                    webhookConfig.triggerCallback("orchestration.failed", failPayload);
+
+                    return;
+                }
+            }
+        }
+
+        // 所有步骤完成
+        execution.setStatus("completed");
+        execution.setCompletedAt(LocalDateTime.now());
+        execution.setCurrentStepIndex(steps.size() - 1);
+        try {
+            execution.setOutputResult(objectMapper.writeValueAsString(context));
+        } catch (JsonProcessingException e) {
+            execution.setOutputResult("{\"status\":\"completed\"}");
+        }
+        executionMapper.updateById(execution);
+
+        // 触发完成 Webhook
+        Map<String, Object> completePayload = new HashMap<>();
+        completePayload.put("executionNo", execution.getExecutionNo());
+        completePayload.put("orchestrationId", execution.getOrchestrationId());
+        completePayload.put("totalSteps", steps.size());
+        completePayload.put("status", "completed");
+        webhookConfig.triggerCallback("orchestration.completed", completePayload);
+
+        log.info("Orchestration execution completed: executionNo={}, steps={}", execution.getExecutionNo(), steps.size());
+    }
+
+    /**
+     * 执行单个步骤 (含重试机制)
+     */
+    private boolean executeStepWithRetry(OrchestrationExecution execution, OrchestrationStep step,
+                                          int stepIndex, Map<String, Object> context) {
+        int maxRetries = step.getMaxRetries() != null ? step.getMaxRetries() : 3;
+        int retryCount = 0;
+
+        while (retryCount <= maxRetries) {
+            try {
+                boolean success = callExternalSystem(step, context);
+                if (success) {
+                    return true;
+                }
+                retryCount++;
+                if (retryCount <= maxRetries) {
+                    logService.recordLog(execution.getId(), execution.getExecutionNo(), stepIndex,
+                            step.getStepName(), "retry", step.getTargetSystem(),
+                            null, null, null, 0L, false, "重试第" + retryCount + "次", execution.getTriggeredBy());
+                    log.warn("Step {} failed, retrying ({}/{})", step.getStepName(), retryCount, maxRetries);
+                    Thread.sleep(500L * retryCount); // 指数退避
+                }
+            } catch (Exception e) {
+                retryCount++;
+                log.error("Step {} error: {}", step.getStepName(), e.getMessage());
+                if (retryCount > maxRetries) break;
+                try {
+                    Thread.sleep(500L * retryCount);
+                } catch (InterruptedException ie) {
+                    Thread.currentThread().interrupt();
+                    break;
+                }
+            }
+        }
+
+        execution.setRetryCount(execution.getRetryCount() + retryCount);
+        return false;
+    }
+
+    /**
+     * 调用外部系统 API (模拟)
+     * 实际生产中应使用 RestTemplate/WebClient 调用真实 API
+     */
+    private boolean callExternalSystem(OrchestrationStep step, Map<String, Object> context) {
+        String targetSystem = step.getTargetSystem();
+        String apiPath = step.getApiPath();
+
+        log.info("Calling external system: {} -> {}", targetSystem, apiPath);
+
+        // 模拟不同系统的响应
+        switch (targetSystem.toLowerCase()) {
+            case "iot":
+                return simulateIoTCall(step, context);
+            case "revenue":
+                return simulateRevenueCall(step, context);
+            case "patrol":
+                return simulatePatrolCall(step, context);
+            case "notify":
+                return simulateNotifyCall(step, context);
+            default:
+                log.warn("Unknown target system: {}, treating as success", targetSystem);
+                return true;
+        }
+    }
+
+    private boolean simulateIoTCall(OrchestrationStep step, Map<String, Object> context) {
+        // 模拟 IoT 设备数据查询
+        context.put("iot_deviceCount", 156);
+        context.put("iot_onlineDevices", 142);
+        context.put("iot_alertCount", 3);
+        context.put("iot_lastQuery", LocalDateTime.now().toString());
+        log.info("IoT API simulated: deviceCount=156, onlineDevices=142, alerts=3");
+        return true;
+    }
+
+    private boolean simulateRevenueCall(OrchestrationStep step, Map<String, Object> context) {
+        // 模拟营收系统数据同步
+        context.put("revenue_totalAmount", 125680.50);
+        context.put("revenue_transactionCount", 342);
+        context.put("revenue_syncStatus", "completed");
+        log.info("Revenue API simulated: total=125680.50, transactions=342");
+        return true;
+    }
+
+    private boolean simulatePatrolCall(OrchestrationStep step, Map<String, Object> context) {
+        // 模拟巡检系统任务派发
+        context.put("patrol_tasksCreated", 12);
+        context.put("patrol_assignedTeams", 4);
+        context.put("patrol_coverageRate", "95%");
+        log.info("Patrol API simulated: tasks=12, teams=4, coverage=95%");
+        return true;
+    }
+
+    private boolean simulateNotifyCall(OrchestrationStep step, Map<String, Object> context) {
+        // 模拟通知系统消息发送
+        context.put("notify_messagesSent", 28);
+        context.put("notify_channels", "sms,email,wechat");
+        log.info("Notify API simulated: messages=28, channels=sms,email,wechat");
+        return true;
+    }
+
+    // ============== 执行记录查询 ==============
+
+    /**
+     * 获取执行记录
+     */
+    public OrchestrationExecution getExecution(Long id) {
+        return executionMapper.selectById(id);
+    }
+
+    /**
+     * 按执行编号获取
+     */
+    public OrchestrationExecution getExecutionByNo(String executionNo) {
+        return executionMapper.selectByExecutionNo(executionNo);
+    }
+
+    /**
+     * 查询编排的执行记录
+     */
+    public List<OrchestrationExecution> listExecutions(Long orchestrationId, String status, int page, int size) {
+        LambdaQueryWrapper<OrchestrationExecution> wrapper = new LambdaQueryWrapper<>();
+        if (orchestrationId != null) {
+            wrapper.eq(OrchestrationExecution::getOrchestrationId, orchestrationId);
+        }
+        if (status != null && !status.isEmpty()) {
+            wrapper.eq(OrchestrationExecution::getStatus, status);
+        }
+        wrapper.orderByDesc(OrchestrationExecution::getCreatedAt);
+        wrapper.last("LIMIT " + size + " OFFSET " + (page - 1) * size);
+        return executionMapper.selectList(wrapper);
+    }
+
+    /**
+     * 取消执行
+     */
+    @Transactional
+    public OrchestrationExecution cancelExecution(Long executionId) {
+        OrchestrationExecution execution = executionMapper.selectById(executionId);
+        if (execution == null) {
+            throw new RuntimeException("执行记录不存在: " + executionId);
+        }
+        if ("completed".equals(execution.getStatus()) || "failed".equals(execution.getStatus())) {
+            throw new RuntimeException("已完成或失败的执行无法取消");
+        }
+        execution.setStatus("cancelled");
+        execution.setCompletedAt(LocalDateTime.now());
+        executionMapper.updateById(execution);
+
+        logService.recordLog(executionId, execution.getExecutionNo(), execution.getCurrentStepIndex(),
+                execution.getCurrentStepName(), "cancel", "internal",
+                null, null, null, 0L, true, "用户取消执行", "system");
+
+        log.info("Cancelled execution: id={}, executionNo={}", executionId, execution.getExecutionNo());
+        return execution;
+    }
+
+    // ============== 辅助方法 ==============
+
+    /**
+     * 解析编排步骤
+     */
+    public List<OrchestrationStep> parseSteps(String orchestrationRules) {
+        if (orchestrationRules == null || orchestrationRules.isEmpty()) {
+            return Collections.emptyList();
+        }
+        try {
+            return objectMapper.readValue(orchestrationRules, new TypeReference<List<OrchestrationStep>>() {});
+        } catch (JsonProcessingException e) {
+            log.error("Failed to parse orchestration rules: {}", e.getMessage());
+            return Collections.emptyList();
+        }
+    }
+
+    /**
+     * 获取执行统计
+     */
+    public Map<String, Object> getExecutionStats(Long orchestrationId) {
+        Map<String, Object> stats = new HashMap<>();
+        LambdaQueryWrapper<OrchestrationExecution> wrapper = new LambdaQueryWrapper<>();
+        if (orchestrationId != null) {
+            wrapper.eq(OrchestrationExecution::getOrchestrationId, orchestrationId);
+        }
+
+        long total = executionMapper.selectCount(wrapper);
+
+        wrapper = new LambdaQueryWrapper<>();
+        if (orchestrationId != null) wrapper.eq(OrchestrationExecution::getOrchestrationId, orchestrationId);
+        wrapper.eq(OrchestrationExecution::getStatus, "completed");
+        long completed = executionMapper.selectCount(wrapper);
+
+        wrapper = new LambdaQueryWrapper<>();
+        if (orchestrationId != null) wrapper.eq(OrchestrationExecution::getOrchestrationId, orchestrationId);
+        wrapper.eq(OrchestrationExecution::getStatus, "failed");
+        long failed = executionMapper.selectCount(wrapper);
+
+        wrapper = new LambdaQueryWrapper<>();
+        if (orchestrationId != null) wrapper.eq(OrchestrationExecution::getOrchestrationId, orchestrationId);
+        wrapper.eq(OrchestrationExecution::getStatus, "running");
+        long running = executionMapper.selectCount(wrapper);
+
+        stats.put("total", total);
+        stats.put("completed", completed);
+        stats.put("failed", failed);
+        stats.put("running", running);
+        stats.put("successRate", total > 0 ? String.format("%.1f%%", (completed * 100.0 / total)) : "N/A");
+
+        return stats;
+    }
+}

wm-bpm/src/main/resources/db/V_bpm_orchestration.sql

@@ -0,0 +1,106 @@
+-- =====================================================
+-- 跨系统流程编排 DDL
+-- Issue #35: 跨系统流程编排 + Webhook 回调通知
+-- =====================================================
+
+-- 编排定义表 (已存在则跳过)
+CREATE TABLE IF NOT EXISTS bpm_orchestration (
+    id              BIGSERIAL PRIMARY KEY,
+    orchestration_name  VARCHAR(200) NOT NULL,
+    orchestration_code  VARCHAR(100) UNIQUE,
+    description         TEXT,
+    process_definition_ids  JSONB,
+    orchestration_rules     JSONB,
+    trigger_type        VARCHAR(50) DEFAULT 'manual',
+    cron_expression     VARCHAR(100),
+    event_name          VARCHAR(200),
+    status              INTEGER DEFAULT 0,
+    created_by          VARCHAR(100),
+    execution_count     INTEGER DEFAULT 0,
+    tenant_id           VARCHAR(100),
+    deleted             INTEGER DEFAULT 0,
+    created_at          TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at          TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+-- 编排执行记录表
+CREATE TABLE IF NOT EXISTS bpm_orchestration_execution (
+    id                  BIGSERIAL PRIMARY KEY,
+    orchestration_id    BIGINT NOT NULL REFERENCES bpm_orchestration(id),
+    execution_no        VARCHAR(100) UNIQUE NOT NULL,
+    current_step_index  INTEGER DEFAULT 0,
+    current_step_name   VARCHAR(200),
+    status              VARCHAR(50) DEFAULT 'pending',
+    started_at          TIMESTAMP,
+    completed_at        TIMESTAMP,
+    triggered_by        VARCHAR(100),
+    trigger_type        VARCHAR(50) DEFAULT 'manual',
+    input_params        JSONB,
+    output_result       JSONB,
+    failure_reason      TEXT,
+    retry_count         INTEGER DEFAULT 0,
+    tenant_id           VARCHAR(100),
+    deleted             INTEGER DEFAULT 0,
+    created_at          TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at          TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE INDEX IF NOT EXISTS idx_orch_exec_orch_id ON bpm_orchestration_execution(orchestration_id);
+CREATE INDEX IF NOT EXISTS idx_orch_exec_no ON bpm_orchestration_execution(execution_no);
+CREATE INDEX IF NOT EXISTS idx_orch_exec_status ON bpm_orchestration_execution(status);
+CREATE INDEX IF NOT EXISTS idx_orch_exec_started ON bpm_orchestration_execution(started_at);
+
+-- 编排日志表
+CREATE TABLE IF NOT EXISTS bpm_orchestration_log (
+    id                  BIGSERIAL PRIMARY KEY,
+    execution_id        BIGINT NOT NULL REFERENCES bpm_orchestration_execution(id),
+    execution_no        VARCHAR(100) NOT NULL,
+    step_index          INTEGER,
+    step_name           VARCHAR(200),
+    action              VARCHAR(50) NOT NULL,
+    target_system       VARCHAR(100),
+    request_body        JSONB,
+    response_body       JSONB,
+    http_status         INTEGER,
+    duration_ms         BIGINT,
+    success             BOOLEAN DEFAULT TRUE,
+    error_message       TEXT,
+    log_time            TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    operator            VARCHAR(100),
+    deleted             INTEGER DEFAULT 0,
+    created_at          TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at          TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE INDEX IF NOT EXISTS idx_orch_log_exec_id ON bpm_orchestration_log(execution_id);
+CREATE INDEX IF NOT EXISTS idx_orch_log_exec_no ON bpm_orchestration_log(execution_no);
+CREATE INDEX IF NOT EXISTS idx_orch_log_time ON bpm_orchestration_log(log_time);
+CREATE INDEX IF NOT EXISTS idx_orch_log_action ON bpm_orchestration_log(action);
+
+-- 插入示例编排定义
+INSERT INTO bpm_orchestration (orchestration_name, orchestration_code, description, trigger_type, orchestration_rules, status, created_by)
+VALUES
+('日常巡检数据同步编排', 'DAILY_PATROL_SYNC', '每日自动同步IoT设备数据、巡检任务、营收数据并发送通知', 'scheduled',
+ '[
+   {"stepName":"查询IoT设备状态","targetSystem":"iot","apiPath":"/api/iot/devices/status","method":"GET","timeoutMs":5000,"skippable":false,"maxRetries":3},
+   {"stepName":"同步巡检任务","targetSystem":"patrol","apiPath":"/api/patrol/tasks/sync","method":"POST","timeoutMs":10000,"skippable":false,"maxRetries":3},
+   {"stepName":"汇总营收数据","targetSystem":"revenue","apiPath":"/api/revenue/daily/summary","method":"GET","timeoutMs":8000,"skippable":true,"maxRetries":2},
+   {"stepName":"发送汇总通知","targetSystem":"notify","apiPath":"/api/notify/send","method":"POST","timeoutMs":5000,"skippable":true,"maxRetries":1}
+ ]',
+ 1, 'system'),
+('应急事件处理编排', 'EMERGENCY_RESPONSE', '突发事件触发时：获取设备数据→派发巡检任务→通知相关人员', 'event',
+ '[
+   {"stepName":"获取异常设备数据","targetSystem":"iot","apiPath":"/api/iot/devices/alerts","method":"GET","timeoutMs":3000,"skippable":false,"maxRetries":3},
+   {"stepName":"派发应急巡检任务","targetSystem":"patrol","apiPath":"/api/patrol/tasks/emergency","method":"POST","timeoutMs":5000,"skippable":false,"maxRetries":3},
+   {"stepName":"发送紧急通知","targetSystem":"notify","apiPath":"/api/notify/emergency","method":"POST","timeoutMs":3000,"skippable":false,"maxRetries":2}
+ ]',
+ 1, 'system')
+ON CONFLICT DO NOTHING;
+
+-- 注释
+COMMENT ON TABLE bpm_orchestration IS '跨系统流程编排定义表';
+COMMENT ON TABLE bpm_orchestration_execution IS '编排执行记录表';
+COMMENT ON TABLE bpm_orchestration_log IS '编排执行日志表';
+COMMENT ON COLUMN bpm_orchestration.orchestration_rules IS '编排步骤JSON数组';
+COMMENT ON COLUMN bpm_orchestration_execution.status IS '执行状态: pending/running/completed/failed/cancelled';
+COMMENT ON COLUMN bpm_orchestration_log.action IS '动作类型: start/complete/fail/retry/callback/skip/cancel';

wm-bpm/src/test/java/com/water/bpm/config/WebhookConfigTest.java

@@ -0,0 +1,161 @@
+package com.water.bpm.config;
+
+import com.water.bpm.entity.dto.WebhookRegistration;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+@DisplayName("Webhook 配置测试")
+class WebhookConfigTest {
+
+    private WebhookConfig webhookConfig;
+
+    @BeforeEach
+    void setUp() {
+        webhookConfig = new WebhookConfig();
+    }
+
+    @Test
+    @DisplayName("注册 Webhook")
+    void testRegister() {
+        WebhookRegistration reg = createRegistration("http://localhost:8080/callback", "orchestration.completed");
+        WebhookRegistration result = webhookConfig.register("test-1", reg);
+
+        assertNotNull(result);
+        assertEquals("http://localhost:8080/callback", result.getCallbackUrl());
+        assertEquals("orchestration.completed", result.getEventType());
+    }
+
+    @Test
+    @DisplayName("获取所有 Webhook")
+    void testListAll() {
+        webhookConfig.register("test-1", createRegistration("http://localhost:8080/cb1", "orchestration.completed"));
+        webhookConfig.register("test-2", createRegistration("http://localhost:8080/cb2", "orchestration.failed"));
+
+        List<WebhookRegistration> list = webhookConfig.listAll();
+        assertEquals(2, list.size());
+    }
+
+    @Test
+    @DisplayName("注销 Webhook")
+    void testUnregister() {
+        webhookConfig.register("test-1", createRegistration("http://localhost:8080/cb1", "orchestration.completed"));
+        webhookConfig.unregister("test-1");
+
+        assertNull(webhookConfig.getById("test-1"));
+    }
+
+    @Test
+    @DisplayName("按事件类型获取 Webhook")
+    void testGetByEventType() {
+        webhookConfig.register("test-1", createRegistration("http://localhost:8080/cb1", "orchestration.completed"));
+        webhookConfig.register("test-2", createRegistration("http://localhost:8080/cb2", "orchestration.failed"));
+        webhookConfig.register("test-3", createRegistration("http://localhost:8080/cb3", "orchestration.completed"));
+
+        List<WebhookRegistration> list = webhookConfig.getByEventType("orchestration.completed");
+        assertEquals(2, list.size());
+    }
+
+    @Test
+    @DisplayName("生成 HMAC-SHA256 签名")
+    void testGenerateSignature() {
+        String payload = "{\"test\":\"data\"}";
+        String secretKey = "my-secret-key";
+
+        String signature = webhookConfig.generateSignature(payload, secretKey);
+
+        assertNotNull(signature);
+        assertFalse(signature.isEmpty());
+        assertEquals(64, signature.length()); // HMAC-SHA256 produces 32 bytes = 64 hex chars
+    }
+
+    @Test
+    @DisplayName("验证签名 - 正确")
+    void testVerifySignatureValid() {
+        String payload = "{\"test\":\"data\"}";
+        String secretKey = "my-secret-key";
+
+        String signature = webhookConfig.generateSignature(payload, secretKey);
+        boolean valid = webhookConfig.verifySignature(payload, secretKey, signature);
+
+        assertTrue(valid);
+    }
+
+    @Test
+    @DisplayName("验证签名 - 错误")
+    void testVerifySignatureInvalid() {
+        String payload = "{\"test\":\"data\"}";
+        String secretKey = "my-secret-key";
+
+        boolean valid = webhookConfig.verifySignature(payload, secretKey, "invalid-signature");
+
+        assertFalse(valid);
+    }
+
+    @Test
+    @DisplayName("触发回调 - 无注册 Webhook")
+    void testTriggerCallbackNoHooks() {
+        Map<String, Object> payload = new HashMap<>();
+        payload.put("test", "data");
+
+        List<WebhookConfig.WebhookCallbackResult> results = webhookConfig.triggerCallback("nonexistent.event", payload);
+
+        assertNotNull(results);
+        assertTrue(results.isEmpty());
+    }
+
+    @Test
+    @DisplayName("触发回调 - Webhook URL 不可达")
+    void testTriggerCallbackUnreachable() {
+        WebhookRegistration reg = createRegistration("http://localhost:99999/unreachable", "orchestration.completed");
+        webhookConfig.register("test-1", reg);
+
+        Map<String, Object> payload = new HashMap<>();
+        payload.put("executionNo", "test-123");
+
+        List<WebhookConfig.WebhookCallbackResult> results = webhookConfig.triggerCallback("orchestration.completed", payload);
+
+        assertNotNull(results);
+        assertEquals(1, results.size());
+        assertFalse(results.get(0).isSuccess());
+    }
+
+    @Test
+    @DisplayName("签名一致性 - 相同输入产生相同签名")
+    void testSignatureConsistency() {
+        String payload = "{\"executionNo\":\"abc-123\",\"status\":\"completed\"}";
+        String secretKey = "water-system-secret-2024";
+
+        String sig1 = webhookConfig.generateSignature(payload, secretKey);
+        String sig2 = webhookConfig.generateSignature(payload, secretKey);
+
+        assertEquals(sig1, sig2);
+    }
+
+    @Test
+    @DisplayName("签名差异 - 不同输入产生不同签名")
+    void testSignatureDifference() {
+        String secretKey = "my-secret-key";
+
+        String sig1 = webhookConfig.generateSignature("payload1", secretKey);
+        String sig2 = webhookConfig.generateSignature("payload2", secretKey);
+
+        assertNotEquals(sig1, sig2);
+    }
+
+    private WebhookRegistration createRegistration(String url, String eventType) {
+        WebhookRegistration reg = new WebhookRegistration();
+        reg.setCallbackUrl(url);
+        reg.setSecretKey("test-secret");
+        reg.setSignatureEnabled(true);
+        reg.setEventType(eventType);
+        reg.setDescription("Test webhook");
+        return reg;
+    }
+}

wm-bpm/src/test/java/com/water/bpm/service/OrchestrationLogServiceTest.java

@@ -0,0 +1,128 @@
+package com.water.bpm.service;
+
+import com.water.bpm.entity.OrchestrationLog;
+import com.water.bpm.mapper.OrchestrationLogMapper;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+@DisplayName("编排日志服务测试")
+class OrchestrationLogServiceTest {
+
+    @Mock
+    private OrchestrationLogMapper orchestrationLogMapper;
+
+    @InjectMocks
+    private OrchestrationLogService logService;
+
+    @BeforeEach
+    void setUp() {
+    }
+
+    @Test
+    @DisplayName("记录日志")
+    void testRecordLog() {
+        when(orchestrationLogMapper.insert(any(OrchestrationLog.class))).thenReturn(1);
+
+        OrchestrationLog result = logService.recordLog(
+                1L, "exec-123", 0, "查询IoT设备",
+                "start", "iot", "{\"query\":\"all\"}",
+                "{\"count\":156}", 200, 150L,
+                true, null, "tester");
+
+        assertNotNull(result);
+        assertEquals(1L, result.getExecutionId());
+        assertEquals("exec-123", result.getExecutionNo());
+        assertEquals("start", result.getAction());
+        assertTrue(result.getSuccess());
+        verify(orchestrationLogMapper, times(1)).insert(any(OrchestrationLog.class));
+    }
+
+    @Test
+    @DisplayName("记录失败日志")
+    void testRecordLogFailure() {
+        when(orchestrationLogMapper.insert(any(OrchestrationLog.class))).thenReturn(1);
+
+        OrchestrationLog result = logService.recordLog(
+                1L, "exec-123", 1, "同步巡检任务",
+                "fail", "patrol", null,
+                null, 500, 3000L,
+                false, "连接超时", "system");
+
+        assertNotNull(result);
+        assertFalse(result.getSuccess());
+        assertEquals("连接超时", result.getErrorMessage());
+    }
+
+    @Test
+    @DisplayName("按执行ID查询日志")
+    void testGetLogsByExecutionId() {
+        OrchestrationLog log1 = createLog(1L, 0, "start");
+        OrchestrationLog log2 = createLog(1L, 1, "complete");
+        when(orchestrationLogMapper.selectByExecutionId(1L)).thenReturn(Arrays.asList(log1, log2));
+
+        List<OrchestrationLog> logs = logService.getLogsByExecutionId(1L);
+
+        assertNotNull(logs);
+        assertEquals(2, logs.size());
+    }
+
+    @Test
+    @DisplayName("按执行编号查询日志")
+    void testGetLogsByExecutionNo() {
+        OrchestrationLog log1 = createLog(1L, 0, "start");
+        when(orchestrationLogMapper.selectByExecutionNo("exec-123")).thenReturn(List.of(log1));
+
+        List<OrchestrationLog> logs = logService.getLogsByExecutionNo("exec-123");
+
+        assertNotNull(logs);
+        assertEquals(1, logs.size());
+    }
+
+    @Test
+    @DisplayName("按步骤查询日志")
+    void testGetLogsByStep() {
+        OrchestrationLog log1 = createLog(1L, 0, "start");
+        OrchestrationLog log2 = createLog(1L, 0, "complete");
+        when(orchestrationLogMapper.selectByStep(1L, 0)).thenReturn(Arrays.asList(log1, log2));
+
+        List<OrchestrationLog> logs = logService.getLogsByStep(1L, 0);
+
+        assertNotNull(logs);
+        assertEquals(2, logs.size());
+    }
+
+    @Test
+    @DisplayName("统计日志数量")
+    void testCountLogs() {
+        when(orchestrationLogMapper.selectCount(any())).thenReturn(15L);
+
+        long count = logService.countLogs(1L);
+
+        assertEquals(15L, count);
+    }
+
+    private OrchestrationLog createLog(Long executionId, Integer stepIndex, String action) {
+        OrchestrationLog log = new OrchestrationLog();
+        log.setId(System.currentTimeMillis());
+        log.setExecutionId(executionId);
+        log.setExecutionNo("exec-123");
+        log.setStepIndex(stepIndex);
+        log.setStepName("Step " + stepIndex);
+        log.setAction(action);
+        log.setSuccess(true);
+        return log;
+    }
+}

wm-bpm/src/test/java/com/water/bpm/service/ProcessOrchestrationServiceTest.java

@@ -0,0 +1,239 @@
+package com.water.bpm.service;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.water.bpm.config.WebhookConfig;
+import com.water.bpm.entity.BpmOrchestration;
+import com.water.bpm.entity.OrchestrationExecution;
+import com.water.bpm.entity.dto.OrchestrationStep;
+import com.water.bpm.mapper.BpmOrchestrationMapper;
+import com.water.bpm.mapper.OrchestrationExecutionMapper;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import java.util.*;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+@DisplayName("流程编排服务测试")
+class ProcessOrchestrationServiceTest {
+
+    @Mock
+    private BpmOrchestrationMapper orchestrationMapper;
+
+    @Mock
+    private OrchestrationExecutionMapper executionMapper;
+
+    @Mock
+    private OrchestrationLogService logService;
+
+    @Mock
+    private WebhookConfig webhookConfig;
+
+    @InjectMocks
+    private ProcessOrchestrationService orchestrationService;
+
+    private BpmOrchestration testOrchestration;
+    private ObjectMapper objectMapper;
+
+    @BeforeEach
+    void setUp() {
+        objectMapper = new ObjectMapper();
+        testOrchestration = new BpmOrchestration();
+        testOrchestration.setId(1L);
+        testOrchestration.setOrchestrationName("测试编排");
+        testOrchestration.setOrchestrationCode("TEST_ORCH");
+        testOrchestration.setStatus(1); // 启用
+        testOrchestration.setExecutionCount(0);
+
+        List<OrchestrationStep> steps = new ArrayList<>();
+        OrchestrationStep step1 = new OrchestrationStep();
+        step1.setStepName("查询IoT设备");
+        step1.setTargetSystem("iot");
+        step1.setApiPath("/api/iot/devices");
+        step1.setMethod("GET");
+        step1.setTimeoutMs(5000);
+        step1.setSkippable(false);
+        step1.setMaxRetries(3);
+        steps.add(step1);
+
+        OrchestrationStep step2 = new OrchestrationStep();
+        step2.setStepName("同步巡检任务");
+        step2.setTargetSystem("patrol");
+        step2.setApiPath("/api/patrol/tasks");
+        step2.setMethod("POST");
+        step2.setTimeoutMs(10000);
+        step2.setSkippable(false);
+        step2.setMaxRetries(3);
+        steps.add(step2);
+
+        try {
+            testOrchestration.setOrchestrationRules(objectMapper.writeValueAsString(steps));
+        } catch (JsonProcessingException e) {
+            fail("Failed to serialize steps");
+        }
+    }
+
+    @Test
+    @DisplayName("创建编排定义")
+    void testCreateOrchestration() {
+        when(orchestrationMapper.insert(any(BpmOrchestration.class))).thenReturn(1);
+
+        BpmOrchestration result = orchestrationService.createOrchestration(testOrchestration);
+
+        assertNotNull(result);
+        assertEquals(0, result.getStatus()); // 应为草稿状态
+        assertEquals(0, result.getExecutionCount());
+        verify(orchestrationMapper, times(1)).insert(any(BpmOrchestration.class));
+    }
+
+    @Test
+    @DisplayName("解析编排步骤 - 正常JSON")
+    void testParseStepsValid() {
+        List<OrchestrationStep> steps = orchestrationService.parseSteps(testOrchestration.getOrchestrationRules());
+
+        assertNotNull(steps);
+        assertEquals(2, steps.size());
+        assertEquals("查询IoT设备", steps.get(0).getStepName());
+        assertEquals("iot", steps.get(0).getTargetSystem());
+        assertEquals("同步巡检任务", steps.get(1).getStepName());
+    }
+
+    @Test
+    @DisplayName("解析编排步骤 - 空字符串")
+    void testParseStepsEmpty() {
+        List<OrchestrationStep> steps = orchestrationService.parseSteps("");
+        assertNotNull(steps);
+        assertTrue(steps.isEmpty());
+    }
+
+    @Test
+    @DisplayName("解析编排步骤 - null")
+    void testParseStepsNull() {
+        List<OrchestrationStep> steps = orchestrationService.parseSteps(null);
+        assertNotNull(steps);
+        assertTrue(steps.isEmpty());
+    }
+
+    @Test
+    @DisplayName("解析编排步骤 - 无效JSON")
+    void testParseStepsInvalidJson() {
+        List<OrchestrationStep> steps = orchestrationService.parseSteps("invalid json");
+        assertNotNull(steps);
+        assertTrue(steps.isEmpty());
+    }
+
+    @Test
+    @DisplayName("启动编排执行 - 编排不存在")
+    void testStartExecutionOrchestrationNotFound() {
+        when(orchestrationMapper.selectById(999L)).thenReturn(null);
+
+        RuntimeException ex = assertThrows(RuntimeException.class, () ->
+                orchestrationService.startExecution(999L, "tester", "manual", new HashMap<>()));
+        assertTrue(ex.getMessage().contains("编排定义不存在"));
+    }
+
+    @Test
+    @DisplayName("启动编排执行 - 编排未启用")
+    void testStartExecutionOrchestrationDisabled() {
+        testOrchestration.setStatus(0); // 草稿
+        when(orchestrationMapper.selectById(1L)).thenReturn(testOrchestration);
+
+        RuntimeException ex = assertThrows(RuntimeException.class, () ->
+                orchestrationService.startExecution(1L, "tester", "manual", new HashMap<>()));
+        assertTrue(ex.getMessage().contains("编排未启用"));
+    }
+
+    @Test
+    @DisplayName("启动编排执行 - 正常执行")
+    void testStartExecutionSuccess() {
+        when(orchestrationMapper.selectById(1L)).thenReturn(testOrchestration);
+        when(executionMapper.insert(any(OrchestrationExecution.class))).thenAnswer(invocation -> {
+            OrchestrationExecution exec = invocation.getArgument(0);
+            exec.setId(100L);
+            return 1;
+        });
+        when(executionMapper.updateById(any(OrchestrationExecution.class))).thenReturn(1);
+        when(executionMapper.selectById(anyLong())).thenReturn(createMockExecution());
+        when(orchestrationMapper.updateById(any(BpmOrchestration.class))).thenReturn(1);
+        when(logService.recordLog(any(), any(), any(), any(), any(), any(), any(), any(), any(), any(), any(), any(), any()))
+                .thenReturn(null);
+        when(webhookConfig.triggerCallback(any(), any())).thenReturn(Collections.emptyList());
+
+        Map<String, Object> params = new HashMap<>();
+        params.put("testKey", "testValue");
+
+        OrchestrationExecution result = orchestrationService.startExecution(1L, "tester", "manual", params);
+
+        assertNotNull(result);
+        verify(executionMapper, atLeastOnce()).insert(any(OrchestrationExecution.class));
+        verify(orchestrationMapper, atLeastOnce()).updateById(any(BpmOrchestration.class));
+        verify(logService, atLeastOnce()).recordLog(any(), any(), any(), any(), any(), any(), any(), any(), any(), any(), any(), any(), any());
+    }
+
+    @Test
+    @DisplayName("取消执行 - 成功")
+    void testCancelExecutionSuccess() {
+        OrchestrationExecution execution = createMockExecution();
+        execution.setStatus("running");
+        when(executionMapper.selectById(100L)).thenReturn(execution);
+        when(executionMapper.updateById(any(OrchestrationExecution.class))).thenReturn(1);
+        when(logService.recordLog(any(), any(), any(), any(), any(), any(), any(), any(), any(), any(), any(), any(), any()))
+                .thenReturn(null);
+
+        OrchestrationExecution result = orchestrationService.cancelExecution(100L);
+
+        assertNotNull(result);
+        assertEquals("cancelled", result.getStatus());
+        verify(executionMapper, times(1)).updateById(any(OrchestrationExecution.class));
+    }
+
+    @Test
+    @DisplayName("取消执行 - 已完成")
+    void testCancelExecutionAlreadyCompleted() {
+        OrchestrationExecution execution = createMockExecution();
+        execution.setStatus("completed");
+        when(executionMapper.selectById(100L)).thenReturn(execution);
+
+        RuntimeException ex = assertThrows(RuntimeException.class, () ->
+                orchestrationService.cancelExecution(100L));
+        assertTrue(ex.getMessage().contains("已完成或失败"));
+    }
+
+    @Test
+    @DisplayName("获取执行统计")
+    void testGetExecutionStats() {
+        when(executionMapper.selectCount(any())).thenReturn(10L, 7L, 2L, 1L);
+
+        Map<String, Object> stats = orchestrationService.getExecutionStats(1L);
+
+        assertNotNull(stats);
+        assertEquals(10L, stats.get("total"));
+        assertEquals(7L, stats.get("completed"));
+        assertEquals(2L, stats.get("failed"));
+        assertEquals(1L, stats.get("running"));
+        assertEquals("70.0%", stats.get("successRate"));
+    }
+
+    private OrchestrationExecution createMockExecution() {
+        OrchestrationExecution execution = new OrchestrationExecution();
+        execution.setId(100L);
+        execution.setOrchestrationId(1L);
+        execution.setExecutionNo(UUID.randomUUID().toString());
+        execution.setCurrentStepIndex(0);
+        execution.setCurrentStepName("查询IoT设备");
+        execution.setStatus("running");
+        execution.setTriggeredBy("tester");
+        execution.setRetryCount(0);
+        return execution;
+    }
+}