#!/usr/bin/env python # -*- coding: utf-8 -*- """ 地图数据推送服务 处理地图数据推送时的动作点和库区数据存储 """ import uuid import datetime from typing import List, Dict, Any, Optional from sqlalchemy.orm import Session from sqlalchemy import and_ from data.models import StorageArea, OperatePoint, OperatePointLayer, StorageAreaType from routes.model.map_model import ( MapDataPushRequest, MapDataPushResponse, MapDataQueryRequest, MapDataQueryResponse, StorageAreaData, OperatePointData, OperatePointLayerData, StorageAreaTypeEnum ) from utils.logger import get_logger from config.settings import settings logger = get_logger("services.map_data_service") class MapDataService: """地图数据推送服务""" @staticmethod def push_map_data(db: Session, request: MapDataPushRequest) -> MapDataPushResponse: """ 推送地图数据 - 状态迁移模式 该方法会智能处理场景更新： 1. 检测场景是否已存在 2. 如果存在： - 将老场景与新场景进行比对 - 对于相同的库区/站点/库位，保留其业务状态（占用、货物、锁定等） - 删除新场景中不存在的老数据 - 新增的数据使用初始状态 3. 如果不存在：全新推送所有数据 Args: db: 数据库会话 request: 地图数据推送请求 Returns: MapDataPushResponse: 推送结果 """ try: # 初始化计数器 stats = { 'storage_areas_created': 0, 'storage_areas_updated': 0, 'storage_areas_deleted': 0, 'operate_points_created': 0, 'operate_points_updated': 0, 'operate_points_deleted': 0, 'layers_created': 0, 'layers_updated': 0, 'layers_deleted': 0, } logger.info(f"开始推送地图数据: 场景ID={request.scene_id}") # 检查场景是否已存在 existing_storage_areas = db.query(StorageArea).filter( and_( StorageArea.scene_id == request.scene_id, StorageArea.is_deleted == False ) ).all() scene_exists = len(existing_storage_areas) > 0 if scene_exists: logger.info(f"场景已存在，进入状态迁移模式") MapDataService._migrate_scene_data(db, request, stats) else: logger.info(f"场景不存在，进入全新推送模式") MapDataService._create_new_scene_data(db, request, stats) # 提交事务 db.commit() logger.info(f"地图数据推送成功: 场景ID={request.scene_id}, " f"库区(新增={stats['storage_areas_created']},更新={stats['storage_areas_updated']},删除={stats['storage_areas_deleted']}), " f"动作点(新增={stats['operate_points_created']},更新={stats['operate_points_updated']},删除={stats['operate_points_deleted']}), " f"分层(新增={stats['layers_created']},更新={stats['layers_updated']},删除={stats['layers_deleted']})") # 生成响应消息 mode = "状态迁移" if scene_exists else "全新推送" result_message = f"{mode}成功。" result_message += f"库区：新增{stats['storage_areas_created']}个，更新{stats['storage_areas_updated']}个，删除{stats['storage_areas_deleted']}个；" result_message += f"动作点：新增{stats['operate_points_created']}个，更新{stats['operate_points_updated']}个，删除{stats['operate_points_deleted']}个；" result_message += f"分层：新增{stats['layers_created']}个，更新{stats['layers_updated']}个，删除{stats['layers_deleted']}个" return MapDataPushResponse( scene_id=request.scene_id, storage_areas_count=stats['storage_areas_created'] + stats['storage_areas_updated'], operate_points_count=stats['operate_points_created'] + stats['operate_points_updated'], layers_count=stats['layers_created'] + stats['layers_updated'], message=result_message ) except Exception as e: db.rollback() logger.error(f"地图数据推送失败: {str(e)}") raise @staticmethod def _migrate_scene_data(db: Session, request: MapDataPushRequest, stats: Dict[str, int]): """ 状态迁移模式 - 智能处理场景更新 核心逻辑： 1. 构建新场景的数据映射（库区名、站点名、库位名） 2. 获取老场景的所有数据 3. 对于交集部分：保留业务状态，更新配置信息 4. 删除老场景中不在新场景的数据 5. 新增新场景中新增的数据 Args: db: 数据库会话 request: 地图推送请求 stats: 统计数据字典 """ scene_id = request.scene_id # ===== 第一步：构建新场景的数据映射 ===== new_area_names = {area.area_name for area in request.storage_areas} new_station_names = {point.station_name for point in request.operate_points} # 构建 站点名->库位名列表 的映射 new_station_layers_map = {} for point in request.operate_points: if point.layers: new_station_layers_map[point.station_name] = { layer.layer_name for layer in point.layers if layer.layer_name } logger.info(f"新场景包含: 库区{len(new_area_names)}个, 站点{len(new_station_names)}个") # ===== 第二步：获取老场景的所有数据 ===== old_storage_areas = db.query(StorageArea).filter( and_(StorageArea.scene_id == scene_id, StorageArea.is_deleted == False) ).all() old_operate_points = db.query(OperatePoint).filter( and_(OperatePoint.scene_id == scene_id, OperatePoint.is_deleted == False) ).all() # 构建老数据映射 old_area_map = {area.area_name: area for area in old_storage_areas} old_point_map = {point.station_name: point for point in old_operate_points} logger.info(f"老场景包含: 库区{len(old_area_map)}个, 站点{len(old_point_map)}个") # ===== 第三步：处理库区数据 ===== logger.info("开始处理库区迁移...") for area_data in request.storage_areas: old_area = old_area_map.get(area_data.area_name) if old_area: # 交集：更新库区配置，保留业务状态 MapDataService._migrate_storage_area( db, old_area, area_data, request.operate_points ) stats['storage_areas_updated'] += 1 else: # 新增：创建新库区 MapDataService._create_storage_area( db, area_data, scene_id, request.operate_points ) stats['storage_areas_created'] += 1 # 删除老场景中不在新场景的库区 for area_name, old_area in old_area_map.items(): if area_name not in new_area_names: db.delete(old_area) stats['storage_areas_deleted'] += 1 logger.info(f"删除库区: {area_name}") # 刷新库区操作到数据库，确保新库区可以被动作点查询到 db.flush() logger.info("库区处理完成，已刷新到数据库") # ===== 第四步：处理动作点和库位层数据 ===== logger.info("开始处理动作点和库位层迁移...") # 检查并过滤重复的站点名称 seen_station_names = set() valid_operate_points = [] for point_data in request.operate_points: if point_data.station_name in seen_station_names: logger.warning(f"发现重复的站点名称，跳过: {point_data.station_name}") continue seen_station_names.add(point_data.station_name) valid_operate_points.append(point_data) for point_data in valid_operate_points: old_point = old_point_map.get(point_data.station_name) if old_point: # 交集：更新动作点配置，保留业务状态，迁移库位层状态 MapDataService._migrate_operate_point( db, old_point, point_data, scene_id, stats ) stats['operate_points_updated'] += 1 else: # 新增：创建新动作点和库位层 new_point = MapDataService._create_operate_point( db, point_data, scene_id ) # 创建库位层 if point_data.layers: for index, layer_data in enumerate(point_data.layers, 1): MapDataService._create_layer( db, new_point, layer_data, index ) stats['layers_created'] += 1 stats['operate_points_created'] += 1 # 删除老场景中不在新场景的动作点（级联删除库位层） for station_name, old_point in old_point_map.items(): if station_name not in new_station_names: # 统计被删除的库位层数量 layer_count = db.query(OperatePointLayer).filter( and_( OperatePointLayer.operate_point_id == old_point.id, OperatePointLayer.is_deleted == False ) ).count() db.delete(old_point) # 级联删除相关的库位层 stats['operate_points_deleted'] += 1 stats['layers_deleted'] += layer_count logger.info(f"删除动作点及其{layer_count}个库位层: {station_name}") @staticmethod def _create_new_scene_data(db: Session, request: MapDataPushRequest, stats: Dict[str, int]): """ 全新推送模式 - 创建全新的场景数据 Args: db: 数据库会话 request: 地图推送请求 stats: 统计数据字典 """ scene_id = request.scene_id # 创建所有库区 for area_data in request.storage_areas: MapDataService._create_storage_area( db, area_data, scene_id, request.operate_points ) stats['storage_areas_created'] += 1 # 刷新库区操作到数据库，确保新库区可以被动作点查询到 db.flush() logger.info("库区创建完成，已刷新到数据库") # 检查并过滤重复的站点名称 seen_station_names = set() valid_operate_points = [] for point_data in request.operate_points: if point_data.station_name in seen_station_names: logger.warning(f"发现重复的站点名称，跳过: {point_data.station_name}") continue seen_station_names.add(point_data.station_name) valid_operate_points.append(point_data) # 创建所有动作点和库位层 for point_data in valid_operate_points: new_point = MapDataService._create_operate_point(db, point_data, scene_id) stats['operate_points_created'] += 1 # 创建库位层 if point_data.layers: for index, layer_data in enumerate(point_data.layers, 1): MapDataService._create_layer(db, new_point, layer_data, index) stats['layers_created'] += 1 @staticmethod def _upsert_storage_area(db: Session, area_data: StorageAreaData, scene_id: str, operate_points_data: List[OperatePointData]) -> bool: """ 增量更新库区数据 Args: db: 数据库会话 area_data: 库区数据 scene_id: 场景ID operate_points_data: 动作点数据列表 Returns: bool: True表示新增，False表示更新 """ try: # 查找现有库区（基于area_name和scene_id） existing_area = db.query(StorageArea).filter( and_( StorageArea.area_name == area_data.area_name, StorageArea.scene_id == scene_id, StorageArea.is_deleted == False ) ).first() # 筛选属于该库区的动作点 area_points = [point for point in operate_points_data if point.area_name == area_data.area_name] # 系统自动计算容量 max_capacity = MapDataService._calculate_storage_area_capacity( area_data.area_type.value, area_points ) if existing_area: # 更新现有库区 existing_area.area_type = StorageAreaType(area_data.area_type) existing_area.max_capacity = max_capacity existing_area.description = area_data.description existing_area.tags = area_data.tags existing_area.select_logic = area_data.select_logic existing_area.updated_at = datetime.datetime.now() logger.info(f"更新库区: {area_data.area_name}") return False else: # 创建新库区 new_area = StorageArea( id=str(uuid.uuid4()), area_name=area_data.area_name, area_type=StorageAreaType(area_data.area_type), scene_id=scene_id, max_capacity=max_capacity, description=area_data.description, tags=area_data.tags, select_logic=area_data.select_logic ) db.add(new_area) logger.info(f"创建新库区: {area_data.area_name}") return True except Exception as e: logger.error(f"更新库区失败 - {area_data.area_name}: {str(e)}") raise ValueError(f"库区数据处理失败: {str(e)}") @staticmethod def _upsert_operate_point(db: Session, point_data: OperatePointData, scene_id: str) -> tuple[bool, OperatePoint]: """ 增量更新动作点数据 支持以下功能： 1. 库位可以不绑定库区（area_name为空或None） 2. 基于station_name判断是否为已存在的库位 3. 如果station_name存在但库位名称不同，则更新库位名称 4. 如果库区名称不同，则更新库区关联 Args: db: 数据库会话 point_data: 动作点数据 scene_id: 场景ID Returns: tuple[bool, OperatePoint]: (是否新增, 动作点对象) """ try: # 查找现有动作点（基于station_name和scene_id） existing_point = db.query(OperatePoint).filter( and_( OperatePoint.station_name == point_data.station_name, OperatePoint.scene_id == scene_id, OperatePoint.is_deleted == False ) ).first() # 根据库区名称获取库区信息（支持库位不绑定库区的情况） storage_area = None if point_data.area_name: storage_area = db.query(StorageArea).filter( and_( StorageArea.area_name == point_data.area_name, StorageArea.scene_id == scene_id, StorageArea.is_deleted == False ) ).first() if existing_point: # 更新现有动作点 # 支持库区关联的修改 existing_point.storage_area_id = storage_area.id if storage_area else None existing_point.storage_area_type = storage_area.area_type if storage_area else None existing_point.area_name = point_data.area_name # 支持库区名称为空的情况 # 更新其他属性 existing_point.max_layers = point_data.max_layers existing_point.position_x = point_data.position_x existing_point.position_y = point_data.position_y existing_point.position_z = point_data.position_z existing_point.content = point_data.content or "" existing_point.tags = point_data.tags or "" existing_point.description = point_data.description existing_point.updated_at = datetime.datetime.now() # 记录更新信息 area_info = f"库区: {point_data.area_name}" if point_data.area_name else "未绑定库区" logger.info(f"更新动作点: {point_data.station_name}, {area_info}") return False, existing_point else: # 创建新动作点 new_point = OperatePoint( id=str(uuid.uuid4()), station_name=point_data.station_name, scene_id=scene_id, storage_area_id=storage_area.id if storage_area else None, storage_area_type=storage_area.area_type if storage_area else None, area_name=point_data.area_name, # 支持为None的情况 max_layers=point_data.max_layers, position_x=point_data.position_x, position_y=point_data.position_y, position_z=point_data.position_z, content=point_data.content or "", tags=point_data.tags or "", description=point_data.description ) db.add(new_point) # 记录创建信息 area_info = f"库区: {point_data.area_name}" if point_data.area_name else "未绑定库区" logger.info(f"创建新动作点: {point_data.station_name}, {area_info}") return True, new_point except Exception as e: logger.error(f"更新动作点失败 - {point_data.station_name}: {str(e)}") raise ValueError(f"动作点数据处理失败: {str(e)}") @staticmethod def _upsert_layers(db: Session, operate_point: OperatePoint, layers_data: List[OperatePointLayerData]) -> Dict[str, int]: """ 增量更新分层数据 支持以下功能： 1. 基于动作点ID和层索引确定唯一层 2. 支持库位名称更新（基于层位置） 3. 更新库区关联信息 4. 避免唯一约束冲突 5. 确保操作点库区变更时所有层的库区信息同步更新 Args: db: 数据库会话 operate_point: 动作点对象 layers_data: 分层数据列表 Returns: Dict[str, int]: 创建和更新的分层数量统计 """ try: created_count = 0 updated_count = 0 # 获取该动作点所有现有的层，按layer_index排序 existing_layers = db.query(OperatePointLayer).filter( and_( OperatePointLayer.operate_point_id == operate_point.id, OperatePointLayer.is_deleted == False ) ).order_by(OperatePointLayer.layer_index).all() # 重要修复：首先更新所有现有层的库区信息，确保库区变更时不会出现重复绑定 # 这解决了库位从一个库区转移到另一个库区时，旧层仍绑定原库区的问题 for existing_layer in existing_layers: if existing_layer.area_name != operate_point.area_name: existing_layer.area_name = operate_point.area_name # 同步更新库区名称 existing_layer.station_name = operate_point.station_name # 确保站点名称一致 existing_layer.updated_at = datetime.datetime.now() logger.debug(f"同步层库区信息: 站点={operate_point.station_name}, 层={existing_layer.layer_index}, 库区={operate_point.area_name}") # 如果没有提供层数据，但仍需要更新现有层的库区信息，直接返回 if not layers_data: return {'created': created_count, 'updated': updated_count} # 创建层索引到层对象的映射 existing_layers_map = {layer.layer_index: layer for layer in existing_layers} for index, layer_data in enumerate(layers_data, 1): # 层索引从1开始 layer_index = index if layer_index in existing_layers_map: # 更新现有层 existing_layer = existing_layers_map[layer_index] existing_layer.layer_name = layer_data.layer_name # 支持库位名称更新 existing_layer.area_name = operate_point.area_name # 更新库区名称（支持为None） existing_layer.station_name = operate_point.station_name # 确保站点名称一致 existing_layer.max_weight = layer_data.max_weight existing_layer.max_volume = layer_data.max_volume existing_layer.layer_height = layer_data.layer_height existing_layer.description = layer_data.description existing_layer.tags = layer_data.tags existing_layer.updated_at = datetime.datetime.now() # 记录更新信息 area_info = f", 库区: {operate_point.area_name}" if operate_point.area_name else ", 未绑定库区" logger.debug(f"更新分层: 站点={operate_point.station_name}, 库位={layer_data.layer_name}, 层={layer_index}{area_info}") updated_count += 1 else: # 创建新层 - 只有在该位置没有层时才创建 new_layer = OperatePointLayer( id=str(uuid.uuid4()), operate_point_id=operate_point.id, station_name=operate_point.station_name, area_name=operate_point.area_name, # 支持为None的情况 scene_id=operate_point.scene_id, layer_index=layer_index, layer_name=layer_data.layer_name, max_weight=layer_data.max_weight, max_volume=layer_data.max_volume, layer_height=layer_data.layer_height, description=layer_data.description, tags=layer_data.tags ) db.add(new_layer) # 为新创建的库位层同步扩展属性 try: MapDataService._sync_extended_properties_to_new_layer(db, new_layer) logger.debug(f"为新库位层 {new_layer.id} 同步扩展属性成功") except Exception as e: logger.error(f"为新库位层 {new_layer.id} 同步扩展属性失败: {str(e)}") raise ValueError(f"库位层扩展属性同步失败: {str(e)}") # 记录创建信息 area_info = f", 库区: {operate_point.area_name}" if operate_point.area_name else ", 未绑定库区" logger.debug(f"创建新分层: 站点={operate_point.station_name}, 库位={layer_data.layer_name}, 层={layer_index}{area_info}") created_count += 1 return {'created': created_count, 'updated': updated_count} except Exception as e: logger.error(f"更新分层数据失败 - 动作点{operate_point.station_name}: {str(e)}") raise ValueError(f"分层数据处理失败: {str(e)}") @staticmethod def query_map_data(db: Session, request: MapDataQueryRequest) -> MapDataQueryResponse: """ 查询地图数据 Args: db: 数据库会话 request: 地图数据查询请求 Returns: MapDataQueryResponse: 查询结果 """ try: # 查询库区数据 storage_areas_query = db.query(StorageArea).filter( and_( StorageArea.scene_id == request.scene_id, StorageArea.is_deleted == False ) ) if request.area_type: storage_areas_query = storage_areas_query.filter( StorageArea.area_type == request.area_type ) storage_areas = storage_areas_query.all() # 查询动作点数据 operate_points_query = db.query(OperatePoint).filter( and_( OperatePoint.scene_id == request.scene_id, OperatePoint.is_deleted == False ) ) operate_points = operate_points_query.all() # 统计数据 total_capacity = sum(area.max_capacity for area in storage_areas) used_capacity = sum(area.current_usage for area in storage_areas) dense_areas_count = sum(1 for area in storage_areas if area.area_type == StorageAreaType.DENSE) general_areas_count = len(storage_areas) - dense_areas_count # 查询分层数据 total_layers = 0 occupied_layers = 0 if request.include_layers: for point in operate_points: layers = db.query(OperatePointLayer).filter( and_( OperatePointLayer.operate_point_id == point.id, OperatePointLayer.is_deleted == False ) ).all() total_layers += len(layers) occupied_layers += sum(1 for layer in layers if layer.is_occupied) # 转换为响应格式 storage_areas_data = [] for area in storage_areas: area_dict = area.to_dict() area_dict['area_type'] = area.area_type.value storage_areas_data.append(area_dict) operate_points_data = [] for point in operate_points: point_dict = point.to_dict() # 添加库区类型信息 if point.storage_area_type: point_dict['storage_area_type'] = point.storage_area_type.value # 添加库区名称信息 if point.area_name: point_dict['area_name'] = point.area_name if request.include_layers: # 包含分层数据 layers = db.query(OperatePointLayer).filter( and_( OperatePointLayer.operate_point_id == point.id, OperatePointLayer.is_deleted == False ) ).order_by(OperatePointLayer.layer_index).all() point_dict['layers'] = [layer.to_dict() for layer in layers] operate_points_data.append(point_dict) return MapDataQueryResponse( scene_id=request.scene_id, storage_areas=storage_areas_data, operate_points=operate_points_data, total_capacity=total_capacity, used_capacity=used_capacity, dense_areas_count=dense_areas_count, general_areas_count=general_areas_count, total_layers=total_layers, occupied_layers=occupied_layers ) except Exception as e: logger.error(f"查询地图数据失败: {str(e)}") raise @staticmethod def _delete_existing_data(db: Session, scene_id: str): """删除现有数据""" # 先获取需要删除的动作点ID列表 operate_point_ids = db.query(OperatePoint.id).filter( and_( OperatePoint.scene_id == scene_id, OperatePoint.is_deleted == False ) ).all() operate_point_ids = [point_id[0] for point_id in operate_point_ids] # 物理删除动作点分层（为了避免主键冲突） if operate_point_ids: db.query(OperatePointLayer).filter( OperatePointLayer.operate_point_id.in_(operate_point_ids) ).delete(synchronize_session=False) # 物理删除动作点（为了避免主键冲突） db.query(OperatePoint).filter( and_( OperatePoint.scene_id == scene_id, OperatePoint.is_deleted == False ) ).delete(synchronize_session=False) # 物理删除库区（为了避免主键冲突） db.query(StorageArea).filter( and_( StorageArea.scene_id == scene_id, StorageArea.is_deleted == False ) ).delete(synchronize_session=False) @staticmethod def _calculate_storage_area_capacity(area_type: str, operate_points_data: List) -> int: """ 计算库区容量 Args: area_type: 库区类型 operate_points_data: 属于该库区的动作点数据列表 Returns: int: 计算出的容量 """ # 根据库区类型从配置中获取参数 if area_type == "dense": base_capacity = settings.MAP_DENSE_STORAGE_BASE_CAPACITY capacity_per_point = settings.MAP_DENSE_STORAGE_CAPACITY_PER_POINT layer_multiplier = settings.MAP_DENSE_STORAGE_LAYER_MULTIPLIER else: # general base_capacity = settings.MAP_GENERAL_STORAGE_BASE_CAPACITY capacity_per_point = settings.MAP_GENERAL_STORAGE_CAPACITY_PER_POINT layer_multiplier = settings.MAP_GENERAL_STORAGE_LAYER_MULTIPLIER # 基础容量 total_capacity = base_capacity # 根据动作点数量和层数计算额外容量 for point_data in operate_points_data: point_capacity = capacity_per_point # 如果有多层，应用层数倍数 if point_data.max_layers > 1: point_capacity = int(point_capacity * layer_multiplier * point_data.max_layers) total_capacity += point_capacity return total_capacity @staticmethod def _sync_extended_properties_to_new_layer(db: Session, layer: OperatePointLayer): """ 将所有已启用的扩展属性同步到新创建的库位层 Args: db: 数据库会话 layer: 新创建的库位层对象 """ try: # 导入扩展属性模型（在方法内导入避免循环导入） from data.models import ExtendedProperty import json import datetime # 获取所有已启用的扩展属性 extended_properties = db.query(ExtendedProperty).filter( ExtendedProperty.is_deleted == False, ExtendedProperty.is_enabled == True ).all() if not extended_properties: # 如果没有扩展属性，则不需要处理 return # 解析现有的config_json config = {} if layer.config_json: try: config = json.loads(layer.config_json) except Exception as e: logger.error(f"解析库位层 {layer.id} 的config_json失败: {str(e)}") raise ValueError(f"库位层配置数据格式错误: {str(e)}") # 确保extended_fields字段存在 if 'extended_fields' not in config: config['extended_fields'] = {} # 同步所有扩展属性 for prop in extended_properties: config['extended_fields'][prop.property_name] = { 'value': prop.default_value, 'type': prop.property_type.value, 'is_required': prop.is_required, 'updated_at': datetime.datetime.now().isoformat() } # 更新config_json layer.config_json = json.dumps(config, ensure_ascii=False, indent=2) logger.debug(f"为库位层 {layer.id} 同步了 {len(extended_properties)} 个扩展属性") except Exception as e: logger.error(f"同步扩展属性到库位层失败: {str(e)}") raise # ========== 状态迁移相关辅助方法 ========== @staticmethod def _migrate_storage_area(db: Session, old_area: StorageArea, area_data: StorageAreaData, operate_points_data: List[OperatePointData]): """ 迁移库区数据 - 更新配置，保留业务状态 保留的状态： - current_usage: 当前使用量 - is_active: 是否激活 - is_maintenance: 是否维护中 更新的配置： - area_type: 库区类型 - max_capacity: 最大容量（重新计算） - description: 描述 - tags: 标签 - select_logic: 选择逻辑 Args: db: 数据库会话 old_area: 老库区对象 area_data: 新库区数据 operate_points_data: 动作点数据列表 """ # 筛选属于该库区的动作点 area_points = [point for point in operate_points_data if point.area_name == area_data.area_name] # 重新计算容量 max_capacity = MapDataService._calculate_storage_area_capacity( area_data.area_type.value, area_points ) # 更新配置信息 old_area.area_type = StorageAreaType(area_data.area_type) old_area.max_capacity = max_capacity old_area.description = area_data.description old_area.tags = area_data.tags old_area.select_logic = area_data.select_logic old_area.updated_at = datetime.datetime.now() # 保留业务状态（current_usage, is_active, is_maintenance 不变） logger.info(f"迁移库区: {area_data.area_name}, 保留使用量={old_area.current_usage}") @staticmethod def _migrate_operate_point(db: Session, old_point: OperatePoint, point_data: OperatePointData, scene_id: str, stats: Dict[str, int]): """ 迁移动作点数据 - 更新配置，保留业务状态，迁移库位层 保留的状态： - is_disabled: 是否禁用 更新的配置： - storage_area_id: 库区ID（可能变更） - storage_area_type: 库区类型（可能变更） - area_name: 库区名称（可能变更） - max_layers: 最大层数 - position_x/y/z: 位置坐标 - content: 内容 - tags: 标签 - description: 描述 Args: db: 数据库会话 old_point: 老动作点对象 point_data: 新动作点数据 scene_id: 场景ID stats: 统计数据字典 """ # 根据库区名称获取库区信息（支持库位不绑定库区的情况） storage_area = None if point_data.area_name: storage_area = db.query(StorageArea).filter( and_( StorageArea.area_name == point_data.area_name, StorageArea.scene_id == scene_id, StorageArea.is_deleted == False ) ).first() # 更新动作点配置 old_point.storage_area_id = storage_area.id if storage_area else None old_point.storage_area_type = storage_area.area_type if storage_area else None old_point.area_name = point_data.area_name old_point.max_layers = point_data.max_layers old_point.position_x = point_data.position_x old_point.position_y = point_data.position_y old_point.position_z = point_data.position_z old_point.content = point_data.content or "" old_point.tags = point_data.tags or "" old_point.description = point_data.description old_point.updated_at = datetime.datetime.now() # 保留业务状态（is_disabled 不变） logger.info(f"迁移动作点: {point_data.station_name}") # 迁移库位层数据 MapDataService._migrate_layers(db, old_point, point_data.layers or [], stats) @staticmethod def _migrate_layers(db: Session, operate_point: OperatePoint, layers_data: List[OperatePointLayerData], stats: Dict[str, int]): """ 迁移库位层数据 - 基于库位名称匹配，保留货物状态 匹配规则：基于 layer_name 进行匹配 保留的状态（对于匹配的库位层）： - is_occupied: 是否占用 - goods_content: 货物内容 - goods_weight: 货物重量 - goods_volume: 货物体积 - is_locked: 是否锁定 - is_disabled: 是否禁用 - is_empty_tray: 是否空托盘 - locked_by: 锁定者 - goods_stored_at: 货物存放时间 - goods_retrieved_at: 货物取出时间 - last_access_at: 最后访问时间 - config_json: 配置JSON（包含扩展属性） 更新的配置： - layer_index: 层索引（可能变更） - max_weight: 最大承重 - max_volume: 最大体积 - layer_height: 层高 - description: 描述 - tags: 标签 Args: db: 数据库会话 operate_point: 动作点对象 layers_data: 新的库位层数据列表 stats: 统计数据字典 """ # 获取该动作点的所有老库位层 old_layers = db.query(OperatePointLayer).filter( and_( OperatePointLayer.operate_point_id == operate_point.id, OperatePointLayer.is_deleted == False ) ).all() # 构建老库位层映射：layer_name -> layer对象 old_layer_map = {layer.layer_name: layer for layer in old_layers if layer.layer_name} # 构建新库位名称集合 new_layer_names = {layer.layer_name for layer in layers_data if layer.layer_name} logger.debug(f"动作点 {operate_point.station_name} 老库位层: {len(old_layer_map)}个, 新库位层: {len(new_layer_names)}个") # ===== 第一步：先删除老库位层中不在新场景的，避免唯一约束冲突 ===== layers_to_delete = [] for layer_name, old_layer in old_layer_map.items(): if layer_name not in new_layer_names: layers_to_delete.append(old_layer) logger.debug(f"标记删除库位层: {layer_name}") # 执行删除并立即刷新到数据库 for old_layer in layers_to_delete: db.delete(old_layer) stats['layers_deleted'] += 1 # 刷新删除操作，确保唯一约束释放 if layers_to_delete: db.flush() logger.debug(f"已刷新删除操作，释放 {len(layers_to_delete)} 个库位层的唯一约束") # ===== 第二步：处理新库位层数据（更新或创建）===== for index, layer_data in enumerate(layers_data, 1): if not layer_data.layer_name: continue old_layer = old_layer_map.get(layer_data.layer_name) if old_layer: # 交集：更新配置，保留所有业务状态 old_layer.layer_index = index # 更新层索引 old_layer.area_name = operate_point.area_name # 更新库区名称（跟随动作点） old_layer.station_name = operate_point.station_name # 更新站点名称 old_layer.max_weight = layer_data.max_weight old_layer.max_volume = layer_data.max_volume old_layer.layer_height = layer_data.layer_height old_layer.description = layer_data.description old_layer.tags = layer_data.tags old_layer.updated_at = datetime.datetime.now() # 保留所有业务状态（is_occupied, goods_*, is_locked, locked_by, config_json 等都不变） stats['layers_updated'] += 1 logger.debug(f"迁移库位层: {layer_data.layer_name}, 占用状态={old_layer.is_occupied}, 货物={old_layer.goods_content}") else: # 新增：创建新库位层 MapDataService._create_layer(db, operate_point, layer_data, index) stats['layers_created'] += 1 @staticmethod def _create_storage_area(db: Session, area_data: StorageAreaData, scene_id: str, operate_points_data: List[OperatePointData]) -> StorageArea: """ 创建新库区 Args: db: 数据库会话 area_data: 库区数据 scene_id: 场景ID operate_points_data: 动作点数据列表 Returns: StorageArea: 创建的库区对象 """ # 筛选属于该库区的动作点 area_points = [point for point in operate_points_data if point.area_name == area_data.area_name] # 计算容量 max_capacity = MapDataService._calculate_storage_area_capacity( area_data.area_type.value, area_points ) new_area = StorageArea( id=str(uuid.uuid4()), area_name=area_data.area_name, area_type=StorageAreaType(area_data.area_type), scene_id=scene_id, max_capacity=max_capacity, description=area_data.description, tags=area_data.tags, select_logic=area_data.select_logic ) db.add(new_area) logger.info(f"创建新库区: {area_data.area_name}") return new_area @staticmethod def _create_operate_point(db: Session, point_data: OperatePointData, scene_id: str) -> OperatePoint: """ 创建新动作点 Args: db: 数据库会话 point_data: 动作点数据 scene_id: 场景ID Returns: OperatePoint: 创建的动作点对象 """ # 根据库区名称获取库区信息（支持库位不绑定库区的情况） storage_area = None if point_data.area_name: storage_area = db.query(StorageArea).filter( and_( StorageArea.area_name == point_data.area_name, StorageArea.scene_id == scene_id, StorageArea.is_deleted == False ) ).first() new_point = OperatePoint( id=str(uuid.uuid4()), station_name=point_data.station_name, scene_id=scene_id, storage_area_id=storage_area.id if storage_area else None, storage_area_type=storage_area.area_type if storage_area else None, area_name=point_data.area_name, max_layers=point_data.max_layers, position_x=point_data.position_x, position_y=point_data.position_y, position_z=point_data.position_z, content=point_data.content or "", tags=point_data.tags or "", description=point_data.description ) db.add(new_point) area_info = f"库区: {point_data.area_name}" if point_data.area_name else "未绑定库区" logger.info(f"创建新动作点: {point_data.station_name}, {area_info}") return new_point @staticmethod def _create_layer(db: Session, operate_point: OperatePoint, layer_data: OperatePointLayerData, layer_index: int) -> OperatePointLayer: """ 创建新库位层 Args: db: 数据库会话 operate_point: 动作点对象 layer_data: 库位层数据 layer_index: 层索引 Returns: OperatePointLayer: 创建的库位层对象 """ new_layer = OperatePointLayer( id=str(uuid.uuid4()), operate_point_id=operate_point.id, station_name=operate_point.station_name, area_name=operate_point.area_name, scene_id=operate_point.scene_id, layer_index=layer_index, layer_name=layer_data.layer_name, max_weight=layer_data.max_weight, max_volume=layer_data.max_volume, layer_height=layer_data.layer_height, description=layer_data.description, tags=layer_data.tags ) db.add(new_layer) # 为新创建的库位层同步扩展属性 try: MapDataService._sync_extended_properties_to_new_layer(db, new_layer) logger.debug(f"为新库位层 {new_layer.layer_name} 同步扩展属性成功") except Exception as e: logger.error(f"为新库位层 {new_layer.layer_name} 同步扩展属性失败: {str(e)}") raise ValueError(f"库位层扩展属性同步失败: {str(e)}") area_info = f", 库区: {operate_point.area_name}" if operate_point.area_name else ", 未绑定库区" logger.debug(f"创建新库位层: 站点={operate_point.station_name}, 库位={layer_data.layer_name}, 层={layer_index}{area_info}") return new_layer