#!/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 sqlalchemy import and_, or_, desc, asc, select, update from sqlalchemy.orm import Session 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 from data.session import get_async_session from data.models.operate_point_layer import OperatePointLayer from data.models.extended_property import ExtendedProperty, ExtendedPropertyTypeEnum # 获取日志记录器 logger = get_logger("services.execution.handlers.storage_location") # 创建一个基础库位处理器类，包含通用方法 class StorageBlockHandler(BlockHandler): pass # 批量设置库位处理器 @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") # 获取地图ID map_id = context.map_id # 参数检查 if not site_ids and not group_names: result = { "success": False, "message": "库位ID和库区集不能同时为空" } await self._record_task_log(block, result, context) return result if not map_id: result = { "success": False, "message": "地图ID不能为空" } 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") # 获取地图ID map_id = context.map_id logger.info(f"获取库位处理器参数: {input_params}") # 必填参数检查 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) retry_sleep = retry_period / 1000 except (ValueError, TypeError): logger.warning(f"retry_period参数类型错误或无法转换为数字: {retry_period}, 将使用默认值1000") retry_sleep = 1 else: retry_sleep = 1 # 设置重试计数器（用于日志记录） retry_count = 0 while True: # 无限循环，直到找到库位 # 尝试获取库位 result = await self._query_idle_site_from_db(input_params, context.task_record_id, map_id) 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 async def _query_idle_site_from_db(self, input_params: Dict[str, Any], task_record_id: str, map_id:str) -> Dict[str, Any]: """从数据库查询空闲库位""" try: # 解析输入参数 site_id = input_params.get("siteId") # 库位ID content = input_params.get("content") # 货物 filled = input_params.get("filled") # 是否有货物 locked = input_params.get("locked") # 是否已锁定（必填） group_name = input_params.get("groupName") # 库区名 order_desc = input_params.get("orderDesc", True) # 是否为降序 lock_after_get = input_params.get("lock") # 获取库位后是否锁定 # 转换字符串类型的布尔值 if isinstance(filled, str): filled = filled.lower() in ('true', '1', 'yes') if isinstance(locked, str): locked = locked.lower() in ('true', '1', 'yes') if isinstance(order_desc, str): order_desc = order_desc.lower() in ('true', '1', 'yes') if isinstance(lock_after_get, str): lock_after_get = lock_after_get.lower() in ('true', '1', 'yes') logger.info(f"查询库位参数: site_id={site_id}, content={content}, filled={filled}, locked={locked}, group_name={group_name}, order_desc={order_desc}, lock_after_get={lock_after_get}") async with get_async_session() as session: # 构建查询条件 query = select(OperatePointLayer) conditions = [] conditions.append(OperatePointLayer.is_empty_tray == False) # 必填条件：是否已锁定 conditions.append(OperatePointLayer.is_locked == locked) conditions.append(OperatePointLayer.is_disabled == False) # 可选条件：库位ID if site_id: conditions.append(OperatePointLayer.id == site_id) # 可选条件：货物内容 if content: conditions.append(OperatePointLayer.goods_content == content) # 可选条件：是否有货物 if filled: conditions.append(OperatePointLayer.is_occupied == filled) # 可选条件：库区名 if group_name: conditions.append(OperatePointLayer.area_name == group_name) # 应用所有条件 if conditions: query = query.where(and_(*conditions)) # 排序：按station_name排序 if order_desc: query = query.order_by(desc(OperatePointLayer.station_name)) else: query = query.order_by(asc(OperatePointLayer.station_name)) # 只获取第一个匹配的库位 query = query.limit(1) # 执行查询 result = await session.execute(query) layer = result.scalar_one_or_none() if layer: found_site_id = layer.id # 如果需要在获取后锁定库位 if lock_after_get: try: # 更新库位锁定状态 from sqlalchemy import update update_stmt = update(OperatePointLayer).where( OperatePointLayer.id == found_site_id ).values( is_locked=True, locked_by=f"task_{task_record_id}" # 生成一个锁定者ID ) await session.execute(update_stmt) await session.commit() logger.info(f"库位 {found_site_id} 已成功锁定") return { "success": True, "message": f"查询库位成功并已锁定，库位ID: {found_site_id}", "data": { "siteId": found_site_id } } except Exception as lock_error: logger.error(f"锁定库位失败: {str(lock_error)}") # 即使锁定失败，也返回查询成功的结果 return { "success": True, "message": f"查询库位成功，但锁定失败: {str(lock_error)}，库位ID: {found_site_id}", "data": { "siteId": found_site_id } } else: # 不需要锁定，直接返回查询结果 return { "success": True, "message": f"查询库位成功，库位ID: {found_site_id}", "data": { "siteId": found_site_id } } else: # 未找到匹配的库位 return { "success": False, "message": "未找到符合条件的库位" } except Exception as e: logger.error(f"查询库位异常: {str(e)}") return { "success": False, "message": f"查询库位异常: {str(e)}" } # 获取任务实例加锁库位处理器 @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") map_id = context.map_id # 必填参数检查 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 # 直接从数据库获取扩展属性值 result = await self._get_site_attr_from_db(site_id, attr_name, map_id) 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}) # 记录执行结果 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 async def _get_site_attr_from_db(self, site_id: str, attr_name: str, map_id: str) -> Dict[str, Any]: """从数据库获取库位扩展属性值""" try: async with get_async_session() as session: # 先检查库位是否存在 site_check_query = select(OperatePointLayer).where( OperatePointLayer.id == site_id, OperatePointLayer.is_deleted == False, OperatePointLayer.scene_id == map_id, OperatePointLayer.is_disabled == False ) site_check_result = await session.execute(site_check_query) existing_layer = site_check_result.scalar_one_or_none() if not existing_layer: return { "success": False, "message": f"库位不存在: {site_id}" } # 检查扩展属性是否已定义 extended_property_query = select(ExtendedProperty).where( ExtendedProperty.property_name == attr_name, ExtendedProperty.is_deleted == False ) extended_property_result = await session.execute(extended_property_query) extended_property = extended_property_result.scalar_one_or_none() if not extended_property: return { "success": False, "message": f"扩展属性 '{attr_name}' 不存在" } # 解析config_json获取扩展属性值 import json attr_value = None attr_type = extended_property.property_type.value is_required = extended_property.is_required if existing_layer.config_json: try: config = json.loads(existing_layer.config_json) if 'extended_fields' in config and attr_name in config['extended_fields']: attr_info = config['extended_fields'][attr_name] attr_value = attr_info.get('value') # 如果config中有类型信息，使用config中的类型 if 'type' in attr_info: attr_type = attr_info['type'] # 如果config中有required信息，使用config中的required if 'is_required' in attr_info: is_required = attr_info['is_required'] except Exception as e: logger.error(f"解析库位层 {site_id} 的config_json失败: {str(e)}") # 如果没有找到属性值，使用默认值 if attr_value is None: attr_value = extended_property.default_value logger.info(f"获取库位 {site_id} 扩展属性 {attr_name} 成功: {attr_value}") return { "success": True, "message": f"获取库位扩展属性成功，{attr_name}: {attr_value}", "data": { "attrValue": attr_value, "attrType": attr_type, "isRequired": is_required, "propertyName": attr_name } } except Exception as e: logger.error(f"获取库位扩展属性异常: {str(e)}") return { "success": False, "message": f"获取库位扩展属性异常: {str(e)}" } # 查询库位处理器 @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") map_id = context.map_id # 必填参数检查 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 # 直接操作数据库设置扩展属性值 result = await self._set_site_attr_in_db(site_id, attr_name, attr_value, map_id) # 记录执行结果 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 async def _set_site_attr_in_db(self, site_id: str, attr_name: str, attr_value: Any, map_id:str) -> Dict[str, Any]: """在数据库中设置库位扩展属性值""" try: async with get_async_session() as session: # 先检查库位是否存在 site_check_query = select(OperatePointLayer).where( OperatePointLayer.id == site_id, OperatePointLayer.is_deleted == False, OperatePointLayer.scene_id == map_id ) site_check_result = await session.execute(site_check_query) existing_layer = site_check_result.scalar_one_or_none() if not existing_layer: return { "success": False, "message": f"库位不存在: {site_id}" } # 检查扩展属性是否已定义 extended_property_query = select(ExtendedProperty).where( ExtendedProperty.property_name == attr_name, ExtendedProperty.is_deleted == False ) extended_property_result = await session.execute(extended_property_query) extended_property = extended_property_result.scalar_one_or_none() # 如果扩展属性不存在，则创建新的扩展属性 if not extended_property: try: # 推断属性类型 # property_type = self._infer_property_type(attr_value) # 创建新的扩展属性 extended_property = ExtendedProperty( property_key=attr_name, property_name=attr_name, property_type=ExtendedPropertyTypeEnum.STRING, ) session.add(extended_property) await session.commit() await session.refresh(extended_property) logger.info(f"自动创建扩展属性: {attr_name}") except Exception as e: logger.error(f"创建扩展属性失败: {str(e)}") return { "success": False, "message": f"创建扩展属性失败: {str(e)}" } # 如果扩展属性存在但被禁用，启用它 elif not extended_property.is_enabled: try: # 启用扩展属性 enable_stmt = update(ExtendedProperty).where( ExtendedProperty.id == extended_property.id ).values( is_enabled=True, updated_at=datetime.datetime.now() ) await session.execute(enable_stmt) await session.commit() # 刷新对象状态 await session.refresh(extended_property) logger.info(f"启用扩展属性: {attr_name}") except Exception as e: logger.error(f"启用扩展属性失败: {str(e)}") return { "success": False, "message": f"启用扩展属性失败: {str(e)}" } # 解析现有的config_json import json import datetime config = {} if existing_layer.config_json: try: config = json.loads(existing_layer.config_json) except Exception as e: logger.error(f"解析库位层 {site_id} 的config_json失败: {str(e)}") config = {} # 确保extended_fields字段存在 if 'extended_fields' not in config: config['extended_fields'] = {} # 更新扩展属性值 config['extended_fields'][attr_name] = { 'value': attr_value, 'type': extended_property.property_type.value, 'is_required': extended_property.is_required, 'updated_at': datetime.datetime.now().isoformat() } # 更新config_json try: updated_config_json = json.dumps(config, ensure_ascii=False, indent=2) # 更新数据库 update_stmt = update(OperatePointLayer).where( OperatePointLayer.id == site_id ).values( config_json=updated_config_json, updated_at=datetime.datetime.now() ) await session.execute(update_stmt) await session.commit() value_display = attr_value if attr_value is not None else "null" logger.info(f"库位 {site_id} 扩展属性 {attr_name} 已成功设置为: {value_display}") return { "success": True, "message": f"设置库位扩展属性成功，{site_id}.{attr_name} = {value_display}" } except Exception as e: logger.error(f"序列化库位层 {site_id} 的config_json失败: {str(e)}") return { "success": False, "message": f"更新扩展属性失败: {str(e)}" } except Exception as e: logger.error(f"设置库位扩展属性异常: {str(e)}") return { "success": False, "message": f"设置库位扩展属性异常: {str(e)}" } # def _infer_property_type(self, value: Any): # """推断属性类型""" # if isinstance(value, bool): # return ExtendedPropertyTypeEnum.BOOLEAN # elif isinstance(value, int): # return ExtendedPropertyTypeEnum.INTEGER # elif isinstance(value, float): # return ExtendedPropertyTypeEnum.NUMBER # elif isinstance(value, str): # # 尝试判断是否为日期 # try: # from datetime import datetime # datetime.fromisoformat(value.replace('Z', '+00:00')) # return ExtendedPropertyTypeEnum.DATE # except: # return ExtendedPropertyTypeEnum.STRING # elif isinstance(value, list): # return ExtendedPropertyTypeEnum.ARRAY # elif isinstance(value, dict): # return ExtendedPropertyTypeEnum.OBJECT # else: # return ExtendedPropertyTypeEnum.STRING # 设置库位货物处理器 @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") map_id = context.map_id # 必填参数检查 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 # 直接操作数据库设置库位货物 result = await self._set_site_content_in_db(site_id, content, map_id) # 记录执行结果 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 async def _set_site_content_in_db(self, site_id: str, content: str, map_id:str) -> Dict[str, Any]: """在数据库中设置库位货物内容""" try: async with get_async_session() as session: # 先检查库位是否存在 site_check_query = select(OperatePointLayer).where( OperatePointLayer.id == site_id, OperatePointLayer.scene_id == map_id ) site_check_result = await session.execute(site_check_query) existing_layer = site_check_result.scalar_one_or_none() if not existing_layer: return { "success": False, "message": f"库位不存在: {site_id}" } # 库位存在，设置货物内容 from sqlalchemy import update import datetime update_stmt = update(OperatePointLayer).where( OperatePointLayer.id == site_id, OperatePointLayer.scene_id == map_id ).values( goods_content=content, # goods_stored_at=datetime.datetime.now(), # 记录货物存放时间 last_access_at=datetime.datetime.now() # 更新最后访问时间 ) await session.execute(update_stmt) await session.commit() logger.info(f"库位 {site_id} 货物内容已成功设置为: {content}") return { "success": True, "message": f"设置库位货物成功，库位ID: {site_id}，货物内容: {content}" } except Exception as e: logger.error(f"设置库位货物异常: {str(e)}") return { "success": False, "message": f"设置库位货物异常: {str(e)}" } # 设置库位为空处理器 @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") map_id = context.map_id # 必填参数检查 if not site_id: result = { "success": False, "message": "库位ID不能为空" } await self._record_task_log(block, result, context) return result result = await self._set_site_empty_in_db(site_id, map_id) 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 async def _set_site_empty_in_db(self, site_id: str, map_id:str) -> Dict[str, Any]: """在数据库中设置库位为非占用状态""" try: async with get_async_session() as session: # 先检查库位是否存在 site_check_query = select(OperatePointLayer).where( OperatePointLayer.id == site_id, OperatePointLayer.scene_id == map_id ) site_check_result = await session.execute(site_check_query) existing_layer = site_check_result.scalar_one_or_none() if not existing_layer: return { "success": False, "message": f"库位不存在: {site_id}" } # 检查库位是否已经被占用 if not existing_layer.is_occupied: return { "success": False, "message": f"库位 {site_id} 已处于非占用状态，无法重复设置" } # 库位存在且未被占用，设置为占用状态 from sqlalchemy import update import datetime update_stmt = update(OperatePointLayer).where( OperatePointLayer.id == site_id, OperatePointLayer.scene_id == map_id ).values( is_occupied=False, goods_content='', # 清空货物内容 goods_retrieved_at=datetime.datetime.now(), # 记录货物取出时间 last_access_at=datetime.datetime.now() ) await session.execute(update_stmt) await session.commit() logger.info(f"库位 {site_id} 已成功设置为空闲状态") return { "success": True, "message": f"设置库位为空成功，库位ID: {site_id}" } except Exception as e: logger.error(f"设置库位为非占用异常: {str(e)}") return { "success": False, "message": f"设置库位为非占用异常: {str(e)}" } # 设置库位为占用处理器 @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") map_id = context.map_id # 必填参数检查 if not site_id: result = { "success": False, "message": "库位ID不能为空" } await self._record_task_log(block, result, context) return result # 直接操作数据库设置库位为占用 result = await self._set_site_filled_in_db(site_id, map_id) # 记录执行结果 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 async def _set_site_filled_in_db(self, site_id: str, map_id:str) -> Dict[str, Any]: """在数据库中设置库位为占用状态""" try: async with get_async_session() as session: # 先检查库位是否存在 site_check_query = select(OperatePointLayer).where( OperatePointLayer.id == site_id, OperatePointLayer.scene_id == map_id ) site_check_result = await session.execute(site_check_query) existing_layer = site_check_result.scalar_one_or_none() if not existing_layer: return { "success": False, "message": f"库位不存在: {site_id}" } # 检查库位是否已经被占用 if existing_layer.is_occupied: return { "success": False, "message": f"库位 {site_id} 已处于占用状态，无法重复设置" } # 库位存在且未被占用，设置为占用状态 from sqlalchemy import update import datetime update_stmt = update(OperatePointLayer).where( OperatePointLayer.id == site_id, OperatePointLayer.scene_id == map_id ).values( is_occupied=True, last_access_at=datetime.datetime.now() ) await session.execute(update_stmt) await session.commit() logger.info(f"库位 {site_id} 已成功设置为占用状态") return { "success": True, "message": f"设置库位为占用成功，库位ID: {site_id}" } except Exception as e: logger.error(f"设置库位为占用异常: {str(e)}") return { "success": False, "message": f"设置库位为占用异常: {str(e)}" } # 锁定库位处理器 @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) # 是否为公平锁 retry_times = input_params.get("retryTimes", 0) # 重试次数，默认为0表示不重试 map_id = context.map_id # 必填参数检查 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.block_record_id input_params["lockedId"] = locked_id # 确保retry_times是整数类型 try: retry_times = int(retry_times) except (ValueError, TypeError): logger.warning(f"retryTimes参数类型错误或无法转换为整数: {retry_times}, 将使用默认值0") retry_times = 0 logger.info(f"锁定库位参数: site_id={site_id}, locked_id={locked_id}, if_fair={if_fair}, retry_times={retry_times}") # 直接从数据库锁定库位 result = await self._set_site_locked_in_db(site_id, locked_id, if_fair, retry_times, map_id) if result.get("success", False): # 设置上下文变量 context.set_variable("success", True) context.set_block_output(block.get("name"), {"success": True}) else: # 设置上下文变量 context.set_variable("success", False) context.set_block_output(block.get("name"), {"success": False}) # 记录最终执行结果 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 async def _set_site_locked_in_db(self, site_id: str, locked_id: str, if_fair: bool, retry_times: int, map_id:str) -> Dict[str, Any]: """在数据库中锁定库位""" try: async with get_async_session() as session: # 先检查库位是否存在 site_check_query = select(OperatePointLayer).where( OperatePointLayer.id == site_id, OperatePointLayer.scene_id == map_id ) site_check_result = await session.execute(site_check_query) existing_layer = site_check_result.scalar_one_or_none() if not existing_layer: return { "success": False, "message": f"库位不存在: {site_id}" } # 实现重试逻辑 attempts = 0 max_attempts = retry_times + 1 # 包括首次尝试 retry_sleep = 1 # 默认重试间隔为1秒 while attempts < max_attempts: attempts += 1 # 重新查询库位当前状态 current_site_query = select(OperatePointLayer).where( OperatePointLayer.id == site_id, OperatePointLayer.scene_id == map_id, OperatePointLayer.is_disabled == False, # OperatePointLayer.is_empty_tray == False ) current_site_result = await session.execute(current_site_query) current_layer = current_site_result.scalar_one_or_none() if not current_layer: return { "success": False, "message": f"库位不存在: {site_id}" } # 检查库位是否已被锁定 if current_layer.is_locked: # 如果是同一个锁定者，视为已锁定成功 if current_layer.locked_by == locked_id: logger.info(f"库位 {site_id} 已被同一锁定者 {locked_id} 锁定") return { "success": True, "message": f"库位已被同一锁定者锁定，库位ID: {site_id}" } # 被其他锁定者锁定，需要重试 if attempts < max_attempts: logger.info(f"库位 {site_id} 已被其他锁定者 {current_layer.locked_by} 锁定，第 {attempts} 次尝试，等待 {retry_sleep} 秒后重试") await asyncio.sleep(retry_sleep) continue else: # 达到最大重试次数，返回失败 return { "success": False, "message": f"库位 {site_id} 已被其他锁定者 {current_layer.locked_by} 锁定，重试 {retry_times} 次后仍然失败" } # 库位未被锁定，尝试锁定 try: import datetime update_stmt = update(OperatePointLayer).where( OperatePointLayer.id == site_id, OperatePointLayer.scene_id == map_id, OperatePointLayer.is_locked == False # 乐观锁：只有未锁定时才能锁定 ).values( is_locked=True, locked_by=locked_id, last_access_at=datetime.datetime.now() ) result = await session.execute(update_stmt) # 检查是否成功更新 if result.rowcount > 0: await session.commit() if attempts == 1: success_msg = f"锁定库位成功，库位ID: {site_id}" else: success_msg = f"第{attempts}次尝试锁定库位成功，库位ID: {site_id}" logger.info(success_msg) return { "success": True, "message": success_msg } else: # 更新失败，可能在更新期间被其他进程锁定 if attempts < max_attempts: logger.info(f"库位 {site_id} 锁定失败（可能被其他进程抢占），第 {attempts} 次尝试，等待 {retry_sleep} 秒后重试") await asyncio.sleep(retry_sleep) continue else: return { "success": False, "message": f"库位 {site_id} 锁定失败，可能被其他进程抢占，重试 {retry_times} 次后仍然失败" } except Exception as e: logger.error(f"锁定库位时发生异常: {str(e)}") if attempts < max_attempts: logger.info(f"第 {attempts} 次尝试发生异常，等待 {retry_sleep} 秒后重试") await asyncio.sleep(retry_sleep) continue else: return { "success": False, "message": f"锁定库位时发生异常: {str(e)}" } # 不应该到达这里 return { "success": False, "message": f"锁定库位失败，未知错误" } except Exception as e: logger.error(f"锁定库位异常: {str(e)}") return { "success": False, "message": f"锁定库位异常: {str(e)}" } # 设置库位标签处理器 @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") replace_mode = input_params.get("replaceMode", False) # 是否替换模式，默认为追加模式 map_id = context.map_id # 必填参数检查 if not site_id: result = { "success": False, "message": "库位ID不能为空" } await self._record_task_log(block, result, context) return result # 转换字符串类型的布尔值 if isinstance(replace_mode, str): replace_mode = replace_mode.lower() in ('true', '1', 'yes') logger.info(f"设置库位标签参数: site_id={site_id}, tags={tags}, replace_mode={replace_mode}") # 直接从数据库设置库位标签 result = await self._set_site_tags_in_db(site_id, tags, replace_mode, map_id) # 记录执行结果 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 async def _set_site_tags_in_db(self, site_id: str, tags: str, replace_mode: bool = False, map_id:str=None) -> Dict[str, Any]: """在数据库中设置库位标签""" try: async with get_async_session() as session: # 先检查库位是否存在 site_check_query = select(OperatePointLayer).where( OperatePointLayer.id == site_id, OperatePointLayer.scene_id == map_id, OperatePointLayer.is_disabled == False ) site_check_result = await session.execute(site_check_query) existing_layer = site_check_result.scalar_one_or_none() if not existing_layer: return { "success": False, "message": f"库位不存在: {site_id}" } # 处理标签数据 new_tags_set = set() # 解析新输入的标签 if tags: # 支持多种分隔符：逗号、分号、空格等 import re tag_list = re.split(r'[,，;；\s]+', str(tags).strip()) new_tags_set.update(tag.strip() for tag in tag_list if tag.strip()) # 处理现有标签 final_tags_set = set() if not replace_mode and existing_layer.tags: # 追加模式：合并现有标签 existing_tag_list = re.split(r'[,，;；\s]+', existing_layer.tags.strip()) final_tags_set.update(tag.strip() for tag in existing_tag_list if tag.strip()) # 合并新标签 final_tags_set.update(new_tags_set) # 去重并用逗号连接 final_tags = ','.join(sorted(final_tags_set)) if final_tags_set else '' # 执行更新操作 try: import datetime update_stmt = update(OperatePointLayer).where( OperatePointLayer.id == site_id, OperatePointLayer.scene_id == map_id ).values( tags=final_tags, last_access_at=datetime.datetime.now() ) result = await session.execute(update_stmt) # 检查是否成功更新 if result.rowcount > 0: await session.commit() tags_display = final_tags if final_tags else "空" operation_mode = "替换" if replace_mode else "追加" success_msg = f"设置库位标签成功（{operation_mode}模式），库位ID: {site_id}，标签: {tags_display}" logger.info(success_msg) return { "success": True, "message": success_msg } else: # 更新失败 return { "success": False, "message": f"设置库位标签失败，库位 {site_id} 可能不存在或已被删除" } except Exception as e: logger.error(f"设置库位标签时发生异常: {str(e)}") return { "success": False, "message": f"设置库位标签时发生异常: {str(e)}" } except Exception as e: logger.error(f"设置库位标签异常: {str(e)}") return { "success": False, "message": f"设置库位标签异常: {str(e)}" } # 解锁库位处理器 @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") map_id = context.map_id # 必填参数检查 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}") logger.info(f"解锁库位参数: site_id={site_id}, un_locked_id={un_locked_id}") # 直接从数据库解锁库位 result = await self._set_site_unlocked_in_db(site_id, un_locked_id, map_id) if result.get("success", False): # 设置上下文变量 context.set_variable("unlockSuccess", True) context.set_block_output(block.get("name"), {"unlockSuccess": True}) else: # 设置上下文变量 context.set_variable("unlockSuccess", False) context.set_block_output(block.get("name"), {"unlockSuccess": False}) # 记录执行结果 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 async def _set_site_unlocked_in_db(self, site_id: str, un_locked_id: str, map_id:str) -> Dict[str, Any]: """在数据库中解锁库位""" try: async with get_async_session() as session: # 先检查库位是否存在 site_check_query = select(OperatePointLayer).where( OperatePointLayer.id == site_id, OperatePointLayer.scene_id == map_id, OperatePointLayer.is_disabled == False ) site_check_result = await session.execute(site_check_query) existing_layer = site_check_result.scalar_one_or_none() if not existing_layer: return { "success": False, "message": f"库位不存在: {site_id}" } # 检查库位是否已被锁定 if not existing_layer.is_locked: # 库位未被锁定，直接返回成功 logger.info(f"库位 {site_id} 未被锁定，解锁操作视为成功") return { "success": True, "message": f"库位未被锁定，解锁操作成功，库位ID: {site_id}" } # 检查解锁者权限 if existing_layer.locked_by != un_locked_id: # 解锁者不是当前锁定者，执行失败 logger.error(f"解锁者 {un_locked_id} 不是库位 {site_id} 的锁定者 {existing_layer.locked_by}，解锁失败") return { "success": False, "message": f"解锁失败，解锁者 {un_locked_id} 不是库位 {site_id} 的锁定者 {existing_layer.locked_by}" } # 执行解锁操作 try: import datetime update_stmt = update(OperatePointLayer).where( OperatePointLayer.id == site_id, OperatePointLayer.scene_id == map_id, OperatePointLayer.is_locked == True # 只有锁定的库位才能解锁 ).values( is_locked=False, locked_by=None, # 清空锁定者 last_access_at=datetime.datetime.now() ) result = await session.execute(update_stmt) # 检查是否成功更新 if result.rowcount > 0: await session.commit() success_msg = f"解锁库位成功，库位ID: {site_id}" logger.info(success_msg) return { "success": True, "message": success_msg } else: # 更新失败，可能在更新期间库位状态发生变化 return { "success": False, "message": f"解锁库位失败，库位 {site_id} 可能已被其他进程解锁" } except Exception as e: logger.error(f"解锁库位时发生异常: {str(e)}") return { "success": False, "message": f"解锁库位时发生异常: {str(e)}" } except Exception as e: logger.error(f"解锁库位异常: {str(e)}") return { "success": False, "message": f"解锁库位异常: {str(e)}" }