784 lines
33 KiB
Python
784 lines
33 KiB
Python
#!/usr/bin/env python
|
||
# -*- coding: utf-8 -*-
|
||
|
||
"""
|
||
机器人调度处理器模块
|
||
提供与机器人调度操作相关的各种处理器
|
||
"""
|
||
|
||
import json
|
||
import asyncio
|
||
import aiohttp
|
||
import uuid
|
||
from typing import Dict, Any, List, Optional
|
||
from services.execution.task_context import TaskContext
|
||
from .base import BlockHandler, register_handler
|
||
from config.settings import settings
|
||
from utils.logger import get_logger
|
||
from .model.block_name import RobotBlockName
|
||
from typing import Tuple
|
||
|
||
# 获取日志记录器
|
||
logger = get_logger("services.execution.handlers.robot_scheduling")
|
||
|
||
# 提取公共的API调用函数
|
||
async def call_robot_api(api_name: str, params: Dict[str, Any]) -> Dict[str, Any]:
|
||
"""
|
||
调用机器人调度服务API的通用函数
|
||
|
||
Args:
|
||
api_name: API名称，对应API_ENDPOINTS中的键
|
||
params: API参数
|
||
|
||
Returns:
|
||
API响应结果
|
||
"""
|
||
# 获取API端点和方法
|
||
endpoint = settings.ROBOT_API_ENDPOINTS.get(api_name)
|
||
method = settings.ROBOT_API_METHODS.get(api_name)
|
||
|
||
if not endpoint or not method:
|
||
logger.error(f"未找到API端点或方法：{api_name}")
|
||
return {
|
||
"success": False,
|
||
"message": f"未找到API配置: {api_name}"
|
||
}
|
||
|
||
# 检查是否启用测试模式
|
||
if settings.ROBOT_API_MOCK_MODE:
|
||
logger.info(f"[测试模式] 模拟调用API: {api_name}, 参数: {params}")
|
||
# 构造测试模式下的响应
|
||
test_response = generate_mock_response(api_name, params)
|
||
return test_response
|
||
|
||
# 构建完整的URL
|
||
url = f"{settings.ROBOT_API_BASE_URL}{endpoint}"
|
||
|
||
# 准备请求头
|
||
headers = {"Content-Type": "application/json"}
|
||
if settings.ROBOT_API_TOKEN:
|
||
headers["Authorization"] = f"Bearer {settings.ROBOT_API_TOKEN}"
|
||
|
||
logger.info(f"调用外部API {api_name} - {method} {url}, 参数: {params}")
|
||
|
||
try:
|
||
async with aiohttp.ClientSession() as session:
|
||
# 根据HTTP方法选择相应的请求方式
|
||
if method == "GET":
|
||
# 对于GET请求，将params转换为URL参数
|
||
async with session.get(
|
||
url,
|
||
params=params,
|
||
headers=headers,
|
||
timeout=settings.ROBOT_API_TIMEOUT
|
||
) as response:
|
||
result = await response.json()
|
||
elif method == "POST":
|
||
# 对于POST请求，将params作为JSON数据发送
|
||
async with session.post(
|
||
url,
|
||
json=params,
|
||
headers=headers,
|
||
timeout=settings.ROBOT_API_TIMEOUT
|
||
) as response:
|
||
result = await response.json()
|
||
elif method == "PUT":
|
||
# 对于PUT请求，将params作为JSON数据发送
|
||
async with session.put(
|
||
url,
|
||
json=params,
|
||
headers=headers,
|
||
timeout=settings.ROBOT_API_TIMEOUT
|
||
) as response:
|
||
result = await response.json()
|
||
else:
|
||
logger.error(f"不支持的HTTP方法: {method}")
|
||
return {
|
||
"success": False,
|
||
"message": f"不支持的HTTP方法: {method}"
|
||
}
|
||
|
||
# 检查响应状态码
|
||
if response.status != 200:
|
||
logger.error(f"API调用失败: {url}, 状态码: {response.status}, 响应: {result}")
|
||
return {
|
||
"success": False,
|
||
"message": f"API调用失败, 状态码: {response.status}",
|
||
"data": result
|
||
}
|
||
|
||
logger.info(f"API调用成功: {url}, 响应: {result}")
|
||
return result
|
||
|
||
except aiohttp.ClientError as e:
|
||
logger.error(f"API调用客户端错误: {url}, 错误: {str(e)}")
|
||
return {
|
||
"success": False,
|
||
"message": f"API调用客户端错误: {str(e)}"
|
||
}
|
||
except asyncio.TimeoutError:
|
||
logger.error(f"API调用超时: {url}")
|
||
return {
|
||
"success": False,
|
||
"message": "API调用超时"
|
||
}
|
||
except json.JSONDecodeError:
|
||
logger.error(f"API响应解析失败: {url}")
|
||
return {
|
||
"success": False,
|
||
"message": "API响应格式错误，无法解析JSON"
|
||
}
|
||
except Exception as e:
|
||
logger.error(f"API调用异常: {url}, 错误: {str(e)}")
|
||
return {
|
||
"success": False,
|
||
"message": f"API调用异常: {str(e)}"
|
||
}
|
||
|
||
def generate_mock_response(api_name: str, params: Dict[str, Any]) -> Dict[str, Any]:
|
||
"""
|
||
生成测试模式下的模拟响应
|
||
|
||
Args:
|
||
api_name: API名称
|
||
params: API参数
|
||
|
||
Returns:
|
||
模拟的API响应
|
||
"""
|
||
# 基本响应结构
|
||
response = {
|
||
"success": True,
|
||
"message": f"[测试模式] {api_name} 操作成功",
|
||
"data": {}
|
||
}
|
||
|
||
# 根据不同API返回不同的模拟数据
|
||
if api_name == "agv_operation":
|
||
# 机器人通用动作
|
||
response["data"] = {
|
||
"success": True,
|
||
"taskId": f"MOCK-OP-{str(uuid.uuid4())[:8]}"
|
||
}
|
||
elif api_name == "select_agv":
|
||
# 选择执行机器人
|
||
response["data"] = {
|
||
"agvId": f"MOCK-AGV-{str(uuid.uuid4())[:8]}"
|
||
}
|
||
elif api_name == "vehicle_station":
|
||
# 获取机器人位置
|
||
response["data"] = {
|
||
"station": f"MOCK-STATION-{str(uuid.uuid4())[:5]}",
|
||
"lastStation": f"MOCK-LAST-STATION-{str(uuid.uuid4())[:5]}"
|
||
}
|
||
elif api_name == "get_battery_level":
|
||
# 获取机器人电量
|
||
response["data"] = {
|
||
"batteryLevel": float(f"{(uuid.uuid4().int % 100) / 100:.2f}")
|
||
}
|
||
elif api_name == "get_pgv_code":
|
||
# 获取机器人PGV码
|
||
response["data"] = {
|
||
"codeInfo": True if uuid.uuid4().int % 2 == 0 else False
|
||
}
|
||
|
||
# 记录模拟调用结果
|
||
logger.info(f"[测试模式] 生成模拟响应: {api_name}, 响应: {response}")
|
||
return response
|
||
|
||
class RobotBlockHandler(BlockHandler):
|
||
"""机器人调度处理器基类，提供公共的API调用方法"""
|
||
|
||
async def _call_external_api(self, api_name: str, params: Dict[str, Any]) -> Dict[str, Any]:
|
||
"""调用外部API的通用方法"""
|
||
return await call_robot_api(api_name, params)
|
||
|
||
def _analyze_affected_blocks(self, block: Dict[str, Any], current_block_id: str, current_block_name: str) -> List[Dict[str, Any]]:
|
||
"""
|
||
分析当前块的结构，找出受当前选择机器人块影响的所有下级块
|
||
|
||
Args:
|
||
block: 当前块的定义
|
||
current_block_id: 当前块的ID
|
||
current_block_name: 当前块的名称
|
||
|
||
Returns:
|
||
List[Dict[str, Any]]: 受影响的块列表，每个元素包含块的ID、名称、类型和与当前块的关系
|
||
"""
|
||
affected_blocks = []
|
||
|
||
# 检查当前块是否有子块
|
||
if "children" in block and "default" in block["children"]:
|
||
children = block["children"]["default"]
|
||
logger.info(f"块 {current_block_name}(ID:{current_block_id}) 有 {len(children)} 个子块")
|
||
|
||
# 分析每个子块
|
||
for child in children:
|
||
child_id = child.get("id", "unknown")
|
||
child_name = child.get("name", f"b{child_id}")
|
||
child_type = child.get("blockType", "unknown")
|
||
|
||
# 记录子块信息
|
||
affected_blocks.append({
|
||
"id": child_id,
|
||
"name": child_name,
|
||
"type": child_type,
|
||
"relation": "direct_child",
|
||
"parent_id": current_block_id,
|
||
"parent_name": current_block_name
|
||
})
|
||
|
||
# 如果子块不是CSelectAgvBp类型，则继续分析其子块
|
||
# 如果子块是CSelectAgvBp类型，则停止分析该分支，因为该分支将由子块的CSelectAgvBp负责
|
||
if child_type != "CSelectAgvBp" and "children" in child and "default" in child["children"]:
|
||
# 递归分析子块的子块
|
||
nested_affected = self._analyze_affected_blocks(child, child_id, child_name)
|
||
|
||
# 将所有嵌套子块添加到结果中
|
||
for nested_block in nested_affected:
|
||
# 添加到结果列表中，标记为嵌套关系
|
||
nested_block["relation"] = "nested_child"
|
||
affected_blocks.append(nested_block)
|
||
|
||
return affected_blocks
|
||
|
||
def _get_robot_id_for_block(self, block_id: str, block_name: str, context: TaskContext) -> Tuple[Optional[str], Optional[str]]:
|
||
"""
|
||
获取适用于当前块的机器人ID
|
||
|
||
首先检查是否有专门为该块设置的机器人ID变量
|
||
如果没有则尝试获取全局机器人ID
|
||
|
||
Args:
|
||
block_id: 当前块ID
|
||
block_name: 当前块名称
|
||
context: 任务上下文
|
||
|
||
Returns:
|
||
Optional[str]: 机器人ID，如果没有找到则返回None
|
||
"""
|
||
# 首先检查是否有专门为该块设置的机器人ID
|
||
robot_id = context.get_variable(f"agv_for_block_{block_id}")
|
||
agv_task_id = context.get_variable(f"agv_task_id_{block_id}")
|
||
if robot_id:
|
||
logger.info(f"找到块 {block_name}(ID:{block_id}) 专用的机器人ID: {robot_id}")
|
||
return robot_id, agv_task_id
|
||
|
||
# 检查是否有按名称设置的机器人ID
|
||
robot_id = context.get_variable(f"agv_for_{block_name}")
|
||
if robot_id:
|
||
logger.info(f"找到块 {block_name} 专用的机器人ID: {robot_id}")
|
||
return robot_id, agv_task_id
|
||
|
||
# 如果没有专用设置，尝试获取全局机器人ID
|
||
robot_id = context.get_variable("selectedAgvId")
|
||
if robot_id:
|
||
logger.info(f"使用全局机器人ID: {robot_id} 用于块 {block_name}(ID:{block_id})")
|
||
return robot_id, agv_task_id
|
||
|
||
# 如果仍未找到，尝试从所有块输出中查找最近的selectedAgvId
|
||
# 这是兜底策略，保持向后兼容
|
||
for out_block_name, outputs in context.block_outputs.items():
|
||
if isinstance(outputs, dict) and "selectedAgvId" in outputs:
|
||
robot_id = outputs.get("selectedAgvId")
|
||
logger.info(f"从块 {out_block_name} 输出中获取机器人ID: {robot_id} 用于块 {block_name}(ID:{block_id})")
|
||
return robot_id, agv_task_id
|
||
|
||
# 未找到任何机器人ID
|
||
logger.warning(f"未找到块 {block_name}(ID:{block_id}) 可用的机器人ID")
|
||
return None, None
|
||
|
||
async def _update_task_record_agv_id(self, task_record_id: str, amr_id: str) -> None:
|
||
"""
|
||
更新任务记录中的agv_id字段
|
||
|
||
Args:
|
||
task_record_id: 任务记录ID
|
||
amr_id: 机器人ID
|
||
|
||
Returns:
|
||
None
|
||
"""
|
||
try:
|
||
from sqlalchemy.ext.asyncio import AsyncSession
|
||
from data.session import get_async_session
|
||
from data.models.taskrecord import VWEDTaskRecord
|
||
from sqlalchemy import select, update
|
||
|
||
if not amr_id:
|
||
logger.warning(f"未提供AMR ID，无法更新任务记录 {task_record_id}")
|
||
return
|
||
|
||
# 将多个AMR ID用逗号连接
|
||
logger.info(f"准备更新任务 {task_record_id} 的机器人ID: {amr_id}")
|
||
|
||
# 先查询当前任务记录中是否已有agv_id
|
||
async with get_async_session() as session:
|
||
session: AsyncSession = session
|
||
|
||
# 查询当前记录
|
||
stmt = select(VWEDTaskRecord.agv_id).where(VWEDTaskRecord.id == task_record_id)
|
||
result = await session.execute(stmt)
|
||
current_agv_id = result.scalar_one_or_none()
|
||
|
||
# 确定最终要存储的agv_id值
|
||
if current_agv_id:
|
||
# 如果已经有值，需要合并并去重
|
||
logger.info(f"任务 {task_record_id} 当前已存在的机器人IDs: {current_agv_id}")
|
||
current_ids = current_agv_id.split(",")
|
||
all_ids = current_ids + [amr_id]
|
||
# 去重并过滤空值
|
||
unique_ids = list(set([id for id in all_ids if id]))
|
||
final_agv_id = ",".join(unique_ids)
|
||
logger.info(f"合并后的机器人IDs: {final_agv_id}")
|
||
else:
|
||
final_agv_id = amr_id
|
||
|
||
# 更新记录
|
||
stmt = update(VWEDTaskRecord).where(VWEDTaskRecord.id == task_record_id).values(agv_id=final_agv_id)
|
||
await session.execute(stmt)
|
||
await session.commit()
|
||
|
||
logger.info(f"成功更新任务记录 {task_record_id} 的agv_id字段: {final_agv_id}")
|
||
except Exception as e:
|
||
logger.error(f"更新任务记录 {task_record_id} 的agv_id字段时发生错误: {str(e)}")
|
||
|
||
|
||
# 机器人通用动作处理器
|
||
@register_handler(RobotBlockName.AGV_OPERATION)
|
||
class AgvOperationBlockHandler(RobotBlockHandler):
|
||
"""机器人通用动作处理器"""
|
||
|
||
async def execute(
|
||
self,
|
||
block: Dict[str, Any],
|
||
input_params: Dict[str, Any],
|
||
context: TaskContext
|
||
) -> Dict[str, Any]:
|
||
"""执行机器人通用动作操作"""
|
||
from services.sync_service import wait_for_task_block_action_completion
|
||
try:
|
||
# 获取关键参数用于验证
|
||
target_site_label = input_params.get("targetSiteLabel")
|
||
script_name = input_params.get("scriptName")
|
||
# 参数检查
|
||
if not target_site_label:
|
||
result = {
|
||
"success": False,
|
||
"message": "目标站点名不能为空"
|
||
}
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
# 获取当前块信息
|
||
current_block_id = block.get("id", "unknown")
|
||
current_block_name = block.get("name", f"b{current_block_id}")
|
||
|
||
# 如果没有提供，尝试获取适用于当前块的机器人ID
|
||
vehicle, agv_task_id = self._get_robot_id_for_block(current_block_id, current_block_name, context)
|
||
if vehicle:
|
||
# 设置到输入参数中
|
||
input_params["vehicle"] = vehicle
|
||
|
||
# 记录使用的机器人ID
|
||
if vehicle:
|
||
logger.info(f"执行机器人通用动作，块 {current_block_name}(ID:{current_block_id}) 使用机器人: {vehicle}, 目标站点: {target_site_label}")
|
||
else:
|
||
error_msg = f"执行机器人通用动作失败：未指定机器人ID，目标站点: {target_site_label}"
|
||
logger.error(error_msg)
|
||
result = {
|
||
"success": False,
|
||
"message": error_msg
|
||
}
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
from services.sync_service import add_action
|
||
result = await add_action(
|
||
task_id=agv_task_id,
|
||
station_name=target_site_label,
|
||
action=script_name,
|
||
token=context.token
|
||
)
|
||
# 调用外部API执行机器人通用动作
|
||
if result.get("success", False):
|
||
# 获取任务ID
|
||
task_id = result.get("result", {}).get("id", "")
|
||
task_block_result = await wait_for_task_block_action_completion(task_id, context.token)
|
||
if task_block_result.get("success", False):
|
||
task_block_status = task_block_result.get("result", {}).get("status", "")
|
||
if task_block_status == 3:
|
||
result["message"] = f"机器人通用动作成功，目标站点: {target_site_label}"
|
||
elif task_block_status == 4:
|
||
result["message"] = f"机器人通用动作失败，目标站点: {target_site_label}:{task_block_result.get('message', '')}"
|
||
result["success"] = False
|
||
elif task_block_status == 5:
|
||
result["message"] = f"机器人通用动作终止，目标站点: {target_site_label}"
|
||
else:
|
||
result["message"] = f"机器人通用动作失败: {result.get('message', '未知错误')}"
|
||
|
||
# 记录执行结果
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
except Exception as e:
|
||
result = {
|
||
"success": False,
|
||
"message": f"机器人通用动作执行异常: {str(e)}"
|
||
}
|
||
# 记录异常
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
# 获取机器人位置处理器
|
||
@register_handler(RobotBlockName.VEHICLE_STATION)
|
||
class VehicleStationBlockHandler(RobotBlockHandler):
|
||
"""获取机器人位置处理器"""
|
||
|
||
async def execute(
|
||
self,
|
||
block: Dict[str, Any],
|
||
input_params: Dict[str, Any],
|
||
context: TaskContext
|
||
) -> Dict[str, Any]:
|
||
"""执行获取机器人位置操作"""
|
||
try:
|
||
# 获取关键参数用于验证
|
||
vehicle = input_params.get("vehicle")
|
||
|
||
# 参数检查
|
||
if not vehicle:
|
||
result = {
|
||
"success": False,
|
||
"message": "指定机器人不能为空"
|
||
}
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
# 调用外部API获取机器人位置
|
||
result = await self._call_external_api("vehicle_station", input_params)
|
||
|
||
if result.get("success", False):
|
||
# 获取站点信息
|
||
station = result.get("data", {}).get("station", "")
|
||
last_station = result.get("data", {}).get("lastStation", "")
|
||
|
||
# 设置上下文变量
|
||
context.set_variable("station", station)
|
||
context.set_variable("lastStation", last_station)
|
||
context.set_block_output(block.get("name"), {
|
||
"station": station,
|
||
"lastStation": last_station
|
||
})
|
||
|
||
result["message"] = f"获取机器人 {vehicle} 位置成功，当前位置: {station}, 上次位置: {last_station}"
|
||
else:
|
||
result["message"] = f"获取机器人位置失败: {result.get('message', '未知错误')}"
|
||
|
||
# 记录执行结果
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
except Exception as e:
|
||
result = {
|
||
"success": False,
|
||
"message": f"获取机器人位置执行异常: {str(e)}"
|
||
}
|
||
# 记录异常
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
# 获取机器人电量处理器
|
||
@register_handler(RobotBlockName.GET_BATTERY_LEVEL)
|
||
class GetBatteryLevelBlockHandler(RobotBlockHandler):
|
||
"""获取机器人电量处理器"""
|
||
|
||
async def execute(
|
||
self,
|
||
block: Dict[str, Any],
|
||
input_params: Dict[str, Any],
|
||
context: TaskContext
|
||
) -> Dict[str, Any]:
|
||
"""执行获取机器人电量操作"""
|
||
try:
|
||
# 获取关键参数用于验证
|
||
vehicle = input_params.get("vehicle")
|
||
|
||
# 参数检查
|
||
if not vehicle:
|
||
result = {
|
||
"success": False,
|
||
"message": "机器人ID不能为空"
|
||
}
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
# 调用外部API获取机器人电量
|
||
result = await self._call_external_api("get_battery_level", input_params)
|
||
|
||
if result.get("success", False):
|
||
# 获取电量信息
|
||
battery_level = result.get("data", {}).get("batteryLevel", 0.0)
|
||
|
||
# 设置上下文变量
|
||
context.set_variable("batteryLevel", battery_level)
|
||
context.set_block_output(block.get("name"), {"batteryLevel": battery_level})
|
||
|
||
# 格式化电量为百分比
|
||
battery_percent = f"{battery_level * 100:.1f}%"
|
||
result["message"] = f"获取机器人 {vehicle} 电量成功，当前电量: {battery_percent}"
|
||
else:
|
||
result["message"] = f"获取机器人电量失败: {result.get('message', '未知错误')}"
|
||
|
||
# 记录执行结果
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
except Exception as e:
|
||
result = {
|
||
"success": False,
|
||
"message": f"获取机器人电量执行异常: {str(e)}"
|
||
}
|
||
# 记录异常
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
# 获取机器人PGV码处理器
|
||
@register_handler(RobotBlockName.GET_PGV_CODE)
|
||
class GetPGVCodeBlockHandler(RobotBlockHandler):
|
||
"""获取机器人PGV码处理器"""
|
||
|
||
async def execute(
|
||
self,
|
||
block: Dict[str, Any],
|
||
input_params: Dict[str, Any],
|
||
context: TaskContext
|
||
) -> Dict[str, Any]:
|
||
"""执行获取机器人PGV码操作"""
|
||
try:
|
||
# 获取关键参数用于验证
|
||
vehicle = input_params.get("vehicle")
|
||
|
||
# 参数检查
|
||
if not vehicle:
|
||
result = {
|
||
"success": False,
|
||
"message": "机器人ID不能为空"
|
||
}
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
# 调用外部API获取机器人PGV码
|
||
result = await self._call_external_api("get_pgv_code", input_params)
|
||
|
||
if result.get("success", False):
|
||
# 获取PGV码信息
|
||
code_info = result.get("data", {}).get("codeInfo", False)
|
||
|
||
# 设置上下文变量
|
||
context.set_variable("codeInfo", code_info)
|
||
context.set_block_output(block.get("name"), {"codeInfo": code_info})
|
||
|
||
code_status = "有效" if code_info else "无效"
|
||
result["message"] = f"获取机器人 {vehicle} PGV码成功，二维码信息: {code_status}"
|
||
else:
|
||
result["message"] = f"获取机器人PGV码失败: {result.get('message', '未知错误')}"
|
||
|
||
# 记录执行结果
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
except Exception as e:
|
||
result = {
|
||
"success": False,
|
||
"message": f"获取机器人PGV码执行异常: {str(e)}"
|
||
}
|
||
# 记录异常
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
# 选择执行机器人处理器
|
||
@register_handler(RobotBlockName.SELECT_AGV)
|
||
class SelectAgvBlockHandler(RobotBlockHandler):
|
||
"""选择执行机器人处理器"""
|
||
|
||
async def execute(
|
||
self,
|
||
block: Dict[str, Any],
|
||
input_params: Dict[str, Any],
|
||
context: TaskContext
|
||
) -> Dict[str, Any]:
|
||
"""执行选择机器人操作"""
|
||
try:
|
||
# 获取关键参数用于验证
|
||
key_route = input_params.get("keyRoute")
|
||
priority = input_params.get("priority", 1)
|
||
if isinstance(priority, str):
|
||
priority = int(priority)
|
||
|
||
# 参数检查
|
||
if not key_route:
|
||
result = {
|
||
"success": False,
|
||
"message": "关键路径不能为空"
|
||
}
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
# 调用外部API选择执行机器人
|
||
# result = await self._call_external_api("select_agv", input_params)
|
||
from services.sync_service import create_choose_amr_task, wait_for_amr_selection
|
||
result = await create_choose_amr_task(
|
||
task_id=context.task_record_id,
|
||
key_station_name=key_route,
|
||
amr_name=input_params.get("vehicle", ""),
|
||
amr_group_name=input_params.get("group", ""),
|
||
token=context.token,
|
||
priority=priority
|
||
)
|
||
if result.get("success", False):
|
||
# 获取任务块ID
|
||
task_block_id = result.get("result", {}).get("id", "")
|
||
if not task_block_id:
|
||
result = {
|
||
"success": False,
|
||
"message": "创建选择AMR任务成功，但未返回任务块ID"
|
||
}
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
logger.info(f"开始等待任务块 {task_block_id} 的AMR选择结果")
|
||
|
||
# 等待AMR选择完成
|
||
task_block_result = await wait_for_amr_selection(
|
||
task_block_id=task_block_id,
|
||
token=context.token
|
||
)
|
||
|
||
if not task_block_result or not task_block_result.get("success", False):
|
||
result = {
|
||
"success": False,
|
||
"message": f"等待AMR选择结果失败或超时，任务块ID: {task_block_id}"
|
||
}
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
# 获取选出的机器人ID
|
||
agv_id = task_block_result.get("result", {}).get("amrId", "")
|
||
if not agv_id:
|
||
result = {
|
||
"success": False,
|
||
"message": f"未能获取到选择的AMR ID，任务块ID: {task_block_id}"
|
||
}
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
# 获取当前块ID和名称
|
||
current_block_id = block.get("id", "unknown")
|
||
current_block_name = block.get("name", f"b{current_block_id}")
|
||
# 更新任务记录中的agv_id字段
|
||
await self._update_task_record_agv_id(context.task_record_id, agv_id)
|
||
|
||
logger.info(f"选择机器人块 {current_block_name}(ID:{current_block_id}) 选择的机器人: {agv_id}")
|
||
|
||
# 分析块的层级结构并记录关联关系
|
||
affected_blocks = self._analyze_affected_blocks(block, current_block_id, current_block_name)
|
||
|
||
# 将分析结果记录到日志
|
||
logger.info(f"选择机器人块 {current_block_name} 影响的块ID: {[b['id'] for b in affected_blocks]}")
|
||
context.set_block_output(current_block_name, {"selectedAgvId": agv_id})
|
||
|
||
# 为每个受影响的块设置变量，记录它应该使用的机器人ID
|
||
for affected_block in affected_blocks:
|
||
affected_id = affected_block["id"]
|
||
affected_name = affected_block["name"]
|
||
context.set_variable(f"agv_for_block_{affected_id}", agv_id)
|
||
context.set_variable(f"agv_for_{affected_name}", agv_id)
|
||
context.set_variable(f"agv_task_id_{affected_id}", task_block_id)
|
||
context.set_block_output(affected_name, {"selectedAgvId": agv_id})
|
||
|
||
# 构造成功消息
|
||
vehicle = input_params.get("vehicle", "")
|
||
group = input_params.get("group", "")
|
||
tag = input_params.get("tag", "")
|
||
|
||
if vehicle:
|
||
result["message"] = f"指定机器人 {vehicle} 选择成功"
|
||
elif group:
|
||
result["message"] = f"从机器人组 {group} 选择机器人成功: {agv_id}"
|
||
elif tag:
|
||
result["message"] = f"根据标签 {tag} 选择机器人成功: {agv_id}"
|
||
else:
|
||
result["message"] = f"选择执行机器人成功: {agv_id}"
|
||
|
||
# 打印选择结果和影响的块
|
||
logger.info(f"选择机器人块 {current_block_name}(ID:{current_block_id}) 选择的机器人: {agv_id}")
|
||
logger.info(f"影响的块: {len(affected_blocks)} 个")
|
||
for i, b in enumerate(affected_blocks):
|
||
logger.info(f"{i+1}. {b['name']}(ID:{b['id']}, 类型:{b['type']}, 关系:{b['relation']})")
|
||
|
||
from services.execution.block_executor import BlockExecutor
|
||
executor = BlockExecutor(context)
|
||
|
||
# 检查是否有子块需要执行
|
||
has_children = "children" in block and "default" in block.get("children", {}) and len(block.get("children", {}).get("default", [])) > 0
|
||
|
||
if has_children:
|
||
# 执行子块
|
||
logger.info(f"开始执行选择机器人块 {current_block_name} 的子块")
|
||
loop_result = await executor.execute_children(block, "default")
|
||
|
||
# 处理子块执行结果
|
||
if loop_result.get("success", False):
|
||
# 子块执行成功，合并结果
|
||
logger.info(f"选择机器人块 {current_block_name} 的子块执行成功")
|
||
|
||
# 如果有需要合并的输出数据
|
||
child_results = loop_result.get("output", {}).get("results", [])
|
||
result["childBlockResults"] = child_results
|
||
|
||
# 保持成功状态
|
||
result["success"] = True
|
||
result["output"] = {
|
||
"selectedAgvId": agv_id,
|
||
"affectedBlocks": affected_blocks,
|
||
"childrenExecuted": True,
|
||
"childrenResult": loop_result
|
||
}
|
||
|
||
# 如果原始消息中没有包含子块执行信息，添加这部分信息
|
||
if "子块" not in result["message"]:
|
||
result["message"] = f"{result['message']}，子块执行成功"
|
||
else:
|
||
# 子块执行失败，根据失败的子块更新消息
|
||
logger.error(f"选择机器人块 {current_block_name} 的子块执行失败: {loop_result.get('message')}")
|
||
|
||
# 创建包含子块失败信息的结果
|
||
error_msg = loop_result.get("message", "未知错误")
|
||
failed_block_id = loop_result.get("block_id", "unknown")
|
||
|
||
result = {
|
||
"success": False,
|
||
"message": f"选择执行机器人成功，但子块执行失败: {error_msg}，失败块ID: {failed_block_id}",
|
||
"output": {
|
||
"selectedAgvId": agv_id,
|
||
"affectedBlocks": affected_blocks,
|
||
"childrenExecuted": False,
|
||
"childrenResult": loop_result
|
||
}
|
||
}
|
||
# 记录执行结果
|
||
from services.sync_service import closure_task
|
||
closure_result = await closure_task(
|
||
task_id=task_block_id,
|
||
token=context.token
|
||
)
|
||
else:
|
||
result["message"] = f"选择执行机器人失败: {result.get('message', '未知错误')}"
|
||
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
except Exception as e:
|
||
result = {
|
||
"success": False,
|
||
"message": f"选择执行机器人异常: {str(e)}"
|
||
}
|
||
# 记录异常
|
||
await self._record_task_log(block, result, context)
|
||
return result |