1005 lines
39 KiB
Python
1005 lines
39 KiB
Python
#!/usr/bin/env python
|
||
# -*- coding: utf-8 -*-
|
||
|
||
"""
|
||
库位处理器模块
|
||
提供与库位操作相关的各种处理器
|
||
"""
|
||
|
||
import logging
|
||
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 StorageBlockName
|
||
|
||
# 获取日志记录器
|
||
logger = get_logger("services.execution.handlers.storage_location")
|
||
# 提取公共的API调用函数
|
||
async def call_storage_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.STORAGE_API_ENDPOINTS.get(api_name)
|
||
method = settings.STORAGE_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.STORAGE_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.STORAGE_API_BASE_URL}{endpoint}"
|
||
|
||
# 准备请求头
|
||
headers = {"Content-Type": "application/json"}
|
||
if settings.STORAGE_API_TOKEN:
|
||
headers["Authorization"] = f"Bearer {settings.STORAGE_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.STORAGE_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.STORAGE_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.STORAGE_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.startswith("get_idle_site"):
|
||
# 获取库位类API
|
||
response["data"] = {
|
||
"siteId": f"MOCK-SITE-{str(uuid.uuid4())[:8]}"
|
||
}
|
||
elif api_name == "get_idle_crowded_site":
|
||
# 获取密集库位
|
||
response["data"] = {
|
||
"siteId": f"MOCK-CROWDED-{str(uuid.uuid4())[:8]}"
|
||
}
|
||
elif api_name == "get_locked_sites_by_task_record_id":
|
||
# 获取任务锁定的库位
|
||
response["data"] = {
|
||
"lockedSiteIdList": [f"MOCK-LOCKED-{str(uuid.uuid4())[:8]}" for _ in range(3)]
|
||
}
|
||
elif api_name == "get_site_attr":
|
||
# 获取库位属性
|
||
attr_name = params.get("attrName", "unknown")
|
||
response["data"] = {
|
||
"attrValue": f"MOCK-VALUE-FOR-{attr_name}"
|
||
}
|
||
elif api_name == "query_idle_site":
|
||
# 查询空闲库位
|
||
response["data"] = {
|
||
"site": {
|
||
"id": f"MOCK-QUERY-{str(uuid.uuid4())[:8]}",
|
||
"groupName": "MOCK-GROUP",
|
||
"type": 0,
|
||
"filled": params.get("filled", False),
|
||
"locked": params.get("locked", False),
|
||
"content": params.get("content", "")
|
||
}
|
||
}
|
||
elif api_name == "set_site_locked":
|
||
# 锁定库位
|
||
response["data"] = {"success": True}
|
||
|
||
# 记录模拟调用结果
|
||
logger.info(f"[测试模式] 生成模拟响应: {api_name}, 响应: {response}")
|
||
return response
|
||
|
||
# 创建一个基础库位处理器类，包含通用方法
|
||
class StorageBlockHandler(BlockHandler):
|
||
"""库位处理器基类，提供公共的API调用方法"""
|
||
|
||
async def _call_external_api(self, api_name: str, params: Dict[str, Any]) -> Dict[str, Any]:
|
||
"""调用外部API的通用方法"""
|
||
return await call_storage_api(api_name, params)
|
||
|
||
# 批量设置库位处理器
|
||
@register_handler(StorageBlockName.BATCH_SETTING_SITE)
|
||
class BatchSettingSiteBlockHandler(StorageBlockHandler):
|
||
"""批量设置库位处理器"""
|
||
|
||
async def execute(
|
||
self,
|
||
block: Dict[str, Any],
|
||
input_params: Dict[str, Any],
|
||
context: TaskContext
|
||
) -> Dict[str, Any]:
|
||
"""执行批量设置库位操作"""
|
||
try:
|
||
# 获取关键参数用于验证
|
||
site_ids = input_params.get("siteIds", [])
|
||
group_names = input_params.get("groupNames", [])
|
||
filled = input_params.get("filled")
|
||
|
||
# 参数检查
|
||
if not site_ids and not group_names:
|
||
result = {
|
||
"success": False,
|
||
"message": "库位ID和库区集不能同时为空"
|
||
}
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
if filled is None:
|
||
result = {
|
||
"success": False,
|
||
"message": "占用参数不能为空"
|
||
}
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
# 直接调用外部API执行批量设置，传递所有input_params
|
||
result = await self._call_external_api("batch_setting_site", input_params)
|
||
if result.get("success", False):
|
||
result["message"] = f"批量设置库位成功，共设置 {len(site_ids) or len(group_names)} 个库位"
|
||
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(StorageBlockName.GET_IDLE_CROWDED_SITE)
|
||
class GetIdleCrowdedSiteBlockHandler(StorageBlockHandler):
|
||
"""获取密集库位处理器"""
|
||
|
||
async def execute(
|
||
self,
|
||
block: Dict[str, Any],
|
||
input_params: Dict[str, Any],
|
||
context: TaskContext
|
||
) -> Dict[str, Any]:
|
||
"""执行获取密集库位操作"""
|
||
try:
|
||
# 获取关键参数用于验证
|
||
group_name = input_params.get("groupName", [])
|
||
filled = input_params.get("filled")
|
||
retry = input_params.get("retry", False)
|
||
retry_num = input_params.get("retryNum", 1)
|
||
|
||
# 参数检查
|
||
if not group_name:
|
||
result = {
|
||
"success": False,
|
||
"message": "库区集不能为空"
|
||
}
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
if filled is None:
|
||
result = {
|
||
"success": False,
|
||
"message": "取/放参数不能为空"
|
||
}
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
# 确保retry_num是整数类型
|
||
try:
|
||
retry_num = int(retry_num)
|
||
except (ValueError, TypeError):
|
||
logger.warning(f"retry_num参数类型错误或无法转换为整数: {retry_num}, 将使用默认值1")
|
||
retry_num = 1
|
||
input_params["retryNum"] = retry_num
|
||
|
||
# 确保retry_period是数字
|
||
retry_period = input_params.get("retryPeriod")
|
||
if retry_period is not None:
|
||
try:
|
||
retry_sleep = float(retry_period) / 1000
|
||
except (ValueError, TypeError):
|
||
logger.warning(f"retry_period参数类型错误或无法转换为数字: {retry_period}, 使用默认值1秒")
|
||
retry_sleep = 1
|
||
else:
|
||
retry_sleep = 1
|
||
|
||
# 调用外部API执行获取密集库位
|
||
attempts = 1
|
||
# 确保max_attempts是整数
|
||
max_attempts = retry_num if retry and retry_num is not None else 1
|
||
|
||
result = None
|
||
while attempts <= max_attempts:
|
||
result = await self._call_external_api("get_idle_crowded_site", input_params)
|
||
|
||
if result.get("success", False) and result.get("data", {}).get("siteId"):
|
||
# 获取成功
|
||
site_id = result.get("data", {}).get("siteId")
|
||
# 设置上下文变量
|
||
context.set_variable("siteId", site_id)
|
||
context.set_block_output(block.get("name"), {"siteId": site_id})
|
||
|
||
result["message"] = f"获取密集库位成功，库位ID: {site_id}"
|
||
break
|
||
else:
|
||
# 获取失败，判断是否需要重试
|
||
if retry and attempts < max_attempts:
|
||
logger.info(f"获取密集库位失败，第 {attempts} 次重试，等待 {retry_sleep} 秒后重试")
|
||
await asyncio.sleep(retry_sleep)
|
||
attempts += 1
|
||
else:
|
||
result["message"] = f"获取密集库位失败: {result.get('message', '未找到合适的库位')}"
|
||
break
|
||
|
||
# 记录执行结果
|
||
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(StorageBlockName.GET_IDLE_SITE)
|
||
class GetIdleSiteBlockHandler(StorageBlockHandler):
|
||
"""获取库位处理器"""
|
||
|
||
async def execute(
|
||
self,
|
||
block: Dict[str, Any],
|
||
input_params: Dict[str, Any],
|
||
context: TaskContext
|
||
) -> Dict[str, Any]:
|
||
"""执行获取库位操作"""
|
||
try:
|
||
# 获取关键参数用于验证
|
||
locked = input_params.get("locked")
|
||
retry_period = input_params.get("retryPeriod")
|
||
|
||
# 必填参数检查
|
||
if locked is None:
|
||
result = {
|
||
"success": False,
|
||
"message": "是否已锁定参数不能为空"
|
||
}
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
# 确保retry_period是数字类型
|
||
if retry_period is not None:
|
||
try:
|
||
retry_period = float(retry_period)
|
||
input_params["retryPeriod"] = retry_period
|
||
retry_sleep = retry_period / 1000
|
||
except (ValueError, TypeError):
|
||
logger.warning(f"retry_period参数类型错误或无法转换为数字: {retry_period}, 将使用默认值1000")
|
||
retry_sleep = 1
|
||
input_params["retryPeriod"] = 1000
|
||
else:
|
||
retry_sleep = 1
|
||
input_params["retryPeriod"] = 1000
|
||
|
||
# 设置重试计数器（用于日志记录）
|
||
retry_count = 0
|
||
|
||
while True: # 无限循环，直到找到库位
|
||
# 尝试获取库位
|
||
result = await self._call_external_api("get_idle_site", input_params)
|
||
|
||
if result.get("success", False) and result.get("data", {}).get("siteId"):
|
||
# 获取成功
|
||
site_id = result.get("data", {}).get("siteId")
|
||
# 设置上下文变量
|
||
context.set_variable("siteId", site_id)
|
||
context.set_block_output(block.get("name"), {"siteId": site_id})
|
||
|
||
# 根据重试次数设置不同的成功消息
|
||
if retry_count == 0:
|
||
result["message"] = f"获取库位成功，库位ID: {site_id}"
|
||
else:
|
||
result["message"] = f"第{retry_count}次重试获取库位成功，库位ID: {site_id}"
|
||
|
||
# 记录执行结果并退出循环
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
else:
|
||
# 获取失败，记录日志并继续重试
|
||
retry_count += 1
|
||
logger.info(f"获取库位失败，第{retry_count}次重试，等待 {retry_sleep} 秒后继续")
|
||
|
||
# 更新临时结果消息（仅用于日志记录）
|
||
temp_result = {
|
||
"success": False,
|
||
"message": f"第{retry_count}次尝试获取库位失败: {result.get('message', '未找到合适的库位')}，将继续重试"
|
||
}
|
||
await self._record_task_log(block, temp_result, context)
|
||
|
||
# 等待指定时间后继续重试
|
||
await asyncio.sleep(retry_sleep)
|
||
|
||
except Exception as e:
|
||
result = {
|
||
"success": False,
|
||
"message": f"获取库位执行异常: {str(e)}"
|
||
}
|
||
# 记录异常
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
# 获取任务实例加锁库位处理器
|
||
@register_handler(StorageBlockName.GET_LOCKED_SITES_BY_TASK_RECORD_ID)
|
||
class GetLockedSitesByTaskRecordIdBlockHandler(StorageBlockHandler):
|
||
"""根据任务实例ID获取所有加锁库位处理器"""
|
||
|
||
async def execute(
|
||
self,
|
||
block: Dict[str, Any],
|
||
input_params: Dict[str, Any],
|
||
context: TaskContext
|
||
) -> Dict[str, Any]:
|
||
"""获取任务实例关联的所有已锁库位"""
|
||
try:
|
||
# 获取参数进行验证
|
||
task_record_id = input_params.get("taskRecordId")
|
||
|
||
# 必填参数检查
|
||
if not task_record_id:
|
||
result = {
|
||
"success": False,
|
||
"message": "任务实例ID不能为空"
|
||
}
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
# 直接调用外部API获取库位列表
|
||
result = await self._call_external_api("get_locked_sites_by_task_record_id", input_params)
|
||
|
||
if result.get("success", False):
|
||
# 获取成功，设置上下文变量
|
||
locked_site_list = result.get("data", {}).get("lockedSiteIdList", [])
|
||
context.set_variable("lockedSiteIdList", locked_site_list)
|
||
context.set_block_output(block.get("name"), {"lockedSiteIdList": locked_site_list})
|
||
|
||
result["message"] = f"获取任务锁定库位成功，共 {len(locked_site_list)} 个库位"
|
||
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(StorageBlockName.GET_SITE_ATTR)
|
||
class GetSiteAttrBlockHandler(StorageBlockHandler):
|
||
"""获取库位扩展属性处理器"""
|
||
|
||
async def execute(
|
||
self,
|
||
block: Dict[str, Any],
|
||
input_params: Dict[str, Any],
|
||
context: TaskContext
|
||
) -> Dict[str, Any]:
|
||
"""获取库位扩展属性值"""
|
||
try:
|
||
# 获取参数进行验证
|
||
site_id = input_params.get("siteId")
|
||
attr_name = input_params.get("attrName")
|
||
|
||
# 必填参数检查
|
||
if not site_id:
|
||
result = {
|
||
"success": False,
|
||
"message": "库位ID不能为空"
|
||
}
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
if not attr_name:
|
||
result = {
|
||
"success": False,
|
||
"message": "属性名称不能为空"
|
||
}
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
# 直接调用外部API获取属性值
|
||
result = await self._call_external_api("get_site_attr", input_params)
|
||
|
||
if result.get("success", False):
|
||
# 获取成功，设置上下文变量
|
||
attr_value = result.get("data", {}).get("attrValue")
|
||
context.set_variable("attrValue", attr_value)
|
||
context.set_block_output(block.get("name"), {"attrValue": attr_value})
|
||
|
||
result["message"] = f"获取库位属性值成功，{attr_name}: {attr_value}"
|
||
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(StorageBlockName.QUERY_IDLE_SITE)
|
||
class QueryIdleSiteBlockHandler(StorageBlockHandler):
|
||
"""查询库位处理器"""
|
||
|
||
async def execute(
|
||
self,
|
||
block: Dict[str, Any],
|
||
input_params: Dict[str, Any],
|
||
context: TaskContext
|
||
) -> Dict[str, Any]:
|
||
"""查询库位"""
|
||
try:
|
||
# 直接调用外部API查询库位
|
||
result = await self._call_external_api("query_idle_site", input_params)
|
||
|
||
if result.get("success", False) and result.get("data", {}).get("site"):
|
||
# 查询成功，设置上下文变量
|
||
site = result.get("data", {}).get("site")
|
||
context.set_variable("site", site)
|
||
context.set_block_output(block.get("name"), {"site": site})
|
||
|
||
site_id = site.get("id", "未知")
|
||
result["message"] = f"查询库位成功，库位ID: {site_id}"
|
||
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(StorageBlockName.SET_SITE_ATTR)
|
||
class SetSiteAttrBlockHandler(StorageBlockHandler):
|
||
"""设置库位扩展属性处理器"""
|
||
|
||
async def execute(
|
||
self,
|
||
block: Dict[str, Any],
|
||
input_params: Dict[str, Any],
|
||
context: TaskContext
|
||
) -> Dict[str, Any]:
|
||
"""设置库位扩展属性值"""
|
||
try:
|
||
# 获取参数进行验证
|
||
site_id = input_params.get("siteId")
|
||
attr_name = input_params.get("attrName")
|
||
attr_value = input_params.get("attrValue")
|
||
|
||
# 必填参数检查
|
||
if not site_id:
|
||
result = {
|
||
"success": False,
|
||
"message": "库位ID不能为空"
|
||
}
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
if not attr_name:
|
||
result = {
|
||
"success": False,
|
||
"message": "属性名称不能为空"
|
||
}
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
# 直接调用外部API设置属性值
|
||
result = await self._call_external_api("set_site_attr", input_params)
|
||
|
||
if result.get("success", False):
|
||
value_display = attr_value if attr_value is not None else "null"
|
||
result["message"] = f"设置库位属性值成功，{site_id}.{attr_name} = {value_display}"
|
||
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(StorageBlockName.SET_SITE_CONTENT)
|
||
class SetSiteContentBlockHandler(StorageBlockHandler):
|
||
"""设置库位货物处理器"""
|
||
|
||
async def execute(
|
||
self,
|
||
block: Dict[str, Any],
|
||
input_params: Dict[str, Any],
|
||
context: TaskContext
|
||
) -> Dict[str, Any]:
|
||
"""设置库位货物"""
|
||
try:
|
||
# 获取参数进行验证
|
||
site_id = input_params.get("siteId")
|
||
content = input_params.get("content")
|
||
|
||
# 必填参数检查
|
||
if not site_id:
|
||
result = {
|
||
"success": False,
|
||
"message": "库位ID不能为空"
|
||
}
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
if content is None:
|
||
result = {
|
||
"success": False,
|
||
"message": "货物不能为空"
|
||
}
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
# 直接调用外部API设置库位货物
|
||
result = await self._call_external_api("set_site_content", input_params)
|
||
|
||
if result.get("success", False):
|
||
result["message"] = f"设置库位货物成功，{site_id} 货物: {content}"
|
||
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(StorageBlockName.SET_SITE_EMPTY)
|
||
class SetSiteEmptyBlockHandler(StorageBlockHandler):
|
||
"""设置库位为空处理器"""
|
||
|
||
async def execute(
|
||
self,
|
||
block: Dict[str, Any],
|
||
input_params: Dict[str, Any],
|
||
context: TaskContext
|
||
) -> Dict[str, Any]:
|
||
"""设置库位为空"""
|
||
try:
|
||
# 获取参数进行验证
|
||
site_id = input_params.get("siteId")
|
||
|
||
# 必填参数检查
|
||
if not site_id:
|
||
result = {
|
||
"success": False,
|
||
"message": "库位ID不能为空"
|
||
}
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
# 直接调用外部API设置库位为空
|
||
result = await self._call_external_api("set_site_empty", input_params)
|
||
|
||
if result.get("success", False):
|
||
result["message"] = f"设置库位为空成功，库位ID: {site_id}"
|
||
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(StorageBlockName.SET_SITE_FILLED)
|
||
class SetSiteFilledBlockHandler(StorageBlockHandler):
|
||
"""设置库位为占用处理器"""
|
||
|
||
async def execute(
|
||
self,
|
||
block: Dict[str, Any],
|
||
input_params: Dict[str, Any],
|
||
context: TaskContext
|
||
) -> Dict[str, Any]:
|
||
"""设置库位为占用"""
|
||
try:
|
||
# 获取参数进行验证
|
||
site_id = input_params.get("siteId")
|
||
|
||
# 必填参数检查
|
||
if not site_id:
|
||
result = {
|
||
"success": False,
|
||
"message": "库位ID不能为空"
|
||
}
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
# 直接调用外部API设置库位为占用
|
||
result = await self._call_external_api("set_site_filled", input_params)
|
||
|
||
if result.get("success", False):
|
||
result["message"] = f"设置库位为占用成功，库位ID: {site_id}"
|
||
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(StorageBlockName.SET_SITE_LOCKED)
|
||
class SetSiteLockedBlockHandler(StorageBlockHandler):
|
||
"""锁定库位处理器"""
|
||
|
||
async def execute(
|
||
self,
|
||
block: Dict[str, Any],
|
||
input_params: Dict[str, Any],
|
||
context: TaskContext
|
||
) -> Dict[str, Any]:
|
||
"""锁定库位"""
|
||
try:
|
||
# 获取参数进行验证
|
||
site_id = input_params.get("siteId")
|
||
locked_id = input_params.get("lockedId")
|
||
if_fair = input_params.get("ifFair", False) # 是否为公平锁
|
||
retryTimes = input_params.get("retryTimes", 0) # 重试次数，默认为0表示不重试
|
||
|
||
# 必填参数检查
|
||
if not site_id:
|
||
result = {
|
||
"success": False,
|
||
"message": "库位ID不能为空"
|
||
}
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
# 如果未指定锁定者ID，则使用当前任务ID
|
||
if not locked_id:
|
||
locked_id = context.get_task_record_id()
|
||
input_params["lockedId"] = locked_id
|
||
|
||
# 确保retry_num是整数类型
|
||
try:
|
||
retry_num = int(retryTimes)
|
||
except (ValueError, TypeError):
|
||
logger.warning(f"retry_num参数类型错误或无法转换为整数: {retryTimes}, 将使用默认值0")
|
||
retry_num = 0
|
||
input_params["retryNum"] = retry_num
|
||
|
||
# 处理公平锁参数
|
||
if if_fair is not None:
|
||
input_params["ifFair"] = if_fair
|
||
|
||
# 实现重试逻辑
|
||
attempts = 0
|
||
max_attempts = retry_num # 包括首次尝试
|
||
retry_sleep = 1 # 默认重试间隔为1秒
|
||
|
||
while attempts < max_attempts:
|
||
attempts += 1
|
||
|
||
# 调用外部API锁定库位
|
||
result = await self._call_external_api("set_site_locked", input_params)
|
||
|
||
if result.get("success", False):
|
||
# 获取锁定结果
|
||
success = result.get("data", {}).get("success", False)
|
||
|
||
# 设置上下文变量
|
||
context.set_variable("success", success)
|
||
context.set_block_output(block.get("name"), {"success": success})
|
||
|
||
if success:
|
||
# 锁定成功
|
||
if attempts == 1:
|
||
result["message"] = f"锁定库位成功，库位ID: {site_id}"
|
||
else:
|
||
result["message"] = f"第{attempts}次尝试锁定库位成功，库位ID: {site_id}"
|
||
break
|
||
else:
|
||
# 锁定失败但API调用成功，检查是否需要重试
|
||
if attempts < max_attempts:
|
||
logger.info(f"锁定库位失败，库位ID: {site_id}，第 {attempts} 次尝试，等待 {retry_sleep} 秒后重试")
|
||
# 记录临时结果（仅用于日志记录）
|
||
temp_result = {
|
||
"success": False,
|
||
"message": f"第{attempts}次尝试锁定库位失败: 库位 {site_id} 可能已被其他任务锁定，将继续重试"
|
||
}
|
||
await self._record_task_log(block, temp_result, context)
|
||
await asyncio.sleep(retry_sleep)
|
||
else:
|
||
# 达到最大重试次数，返回最终失败结果
|
||
result["message"] = f"锁定库位失败，库位ID: {site_id}，可能已被其他任务锁定，重试 {retry_num} 次后仍然失败"
|
||
else:
|
||
# API调用失败，检查是否需要重试
|
||
if attempts < max_attempts:
|
||
logger.info(f"API调用失败，第 {attempts} 次尝试，等待 {retry_sleep} 秒后重试")
|
||
# 记录临时结果（仅用于日志记录）
|
||
temp_result = {
|
||
"success": False,
|
||
"message": f"第{attempts}次API调用失败: {result.get('message', '未知错误')}，将继续重试"
|
||
}
|
||
await self._record_task_log(block, temp_result, context)
|
||
await asyncio.sleep(retry_sleep)
|
||
else:
|
||
# 达到最大重试次数，返回最终失败结果
|
||
result["message"] = f"锁定库位失败: {result.get('message', '未知错误')}，重试 {retry_num} 次后仍然失败"
|
||
|
||
# 记录最终执行结果
|
||
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(StorageBlockName.SET_SITE_TAGS)
|
||
class SetSiteTagsBlockHandler(StorageBlockHandler):
|
||
"""设置库位标签处理器"""
|
||
|
||
async def execute(
|
||
self,
|
||
block: Dict[str, Any],
|
||
input_params: Dict[str, Any],
|
||
context: TaskContext
|
||
) -> Dict[str, Any]:
|
||
"""设置库位标签"""
|
||
try:
|
||
# 获取参数进行验证
|
||
site_id = input_params.get("siteId")
|
||
tags = input_params.get("tags")
|
||
|
||
# 必填参数检查
|
||
if not site_id:
|
||
result = {
|
||
"success": False,
|
||
"message": "库位ID不能为空"
|
||
}
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
# 直接调用外部API设置库位标签
|
||
result = await self._call_external_api("set_site_tags", input_params)
|
||
|
||
if result.get("success", False):
|
||
tags_display = tags if tags else "空"
|
||
result["message"] = f"设置库位标签成功，库位ID: {site_id}，标签: {tags_display}"
|
||
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(StorageBlockName.SET_SITE_UNLOCKED)
|
||
class SetSiteUnlockedBlockHandler(StorageBlockHandler):
|
||
"""解锁库位处理器"""
|
||
|
||
async def execute(
|
||
self,
|
||
block: Dict[str, Any],
|
||
input_params: Dict[str, Any],
|
||
context: TaskContext
|
||
) -> Dict[str, Any]:
|
||
"""解锁库位"""
|
||
try:
|
||
# 获取参数进行验证
|
||
site_id = input_params.get("siteId")
|
||
un_locked_id = input_params.get("unLockedId")
|
||
|
||
# 必填参数检查
|
||
if not site_id:
|
||
result = {
|
||
"success": False,
|
||
"message": "库位ID不能为空"
|
||
}
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
# 如果未指定解锁者ID，则使用当前任务ID
|
||
if not un_locked_id:
|
||
un_locked_id = context.get_task_record_id()
|
||
input_params["unLockedId"] = un_locked_id
|
||
logger.info(f"未指定解锁者ID，使用当前任务ID: {un_locked_id}")
|
||
|
||
# 调用外部API解锁库位
|
||
result = await self._call_external_api("set_site_unlocked", input_params)
|
||
|
||
if result.get("success", False):
|
||
# 设置上下文变量
|
||
context.set_variable("unlockSuccess", True)
|
||
context.set_block_output(block.get("name"), {"unlockSuccess": True})
|
||
|
||
result["message"] = f"解锁库位成功，库位ID: {site_id}"
|
||
else:
|
||
# 设置上下文变量
|
||
context.set_variable("unlockSuccess", False)
|
||
context.set_block_output(block.get("name"), {"unlockSuccess": False})
|
||
|
||
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 |