#!/usr/bin/env python # -*- coding: utf-8 -*- """ 地图数据推送服务 处理地图数据推送时的动作点和库区数据存储 """ import uuid 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: """ 推送地图数据 Args: db: 数据库会话 request: 地图数据推送请求 Returns: MapDataPushResponse: 推送结果 """ try: # 初始化计数器 storage_areas_count = 0 operate_points_count = 0 layers_count = 0 # 先查询数据库是否有相关场景数据 existing_storage_areas = db.query(StorageArea).filter( and_( StorageArea.scene_id == request.scene_id, StorageArea.is_deleted == False ) ).first() existing_operate_points = db.query(OperatePoint).filter( and_( OperatePoint.scene_id == request.scene_id, OperatePoint.is_deleted == False ) ).first() # 记录是否进行了覆盖操作 has_existing_data = existing_storage_areas or existing_operate_points # 如果数据库有相关场景数据，则删除现有数据 if has_existing_data: logger.info(f"发现现有场景数据，开始删除: 场景ID={request.scene_id}") MapDataService._delete_existing_data(db, request.scene_id) else: logger.info(f"未发现现有场景数据，直接创建: 场景ID={request.scene_id}") # 处理库区数据 - 创建新数据 logger.info(f"开始创建库区数据: 数量={len(request.storage_areas)}") for area_data in request.storage_areas: new_area = MapDataService._create_storage_area(area_data, request.scene_id, request.operate_points) db.add(new_area) storage_areas_count += 1 # 创建库区ID到类型和名称的映射 storage_area_type_mapping = {area.id: area.area_type for area in request.storage_areas} storage_area_name_mapping = {area.id: area.area_name for area in request.storage_areas} # 检查动作点站点名称重复 duplicate_stations = [] valid_operate_points = [] # 查询数据库中该场景下现有的站点名称和库位名称（未删除的） existing_station_names = set() existing_location_names = set() if not has_existing_data: # 如果没有现有数据需要覆盖，则需要检查数据库中的站点名称和库位名称 existing_points = db.query(OperatePoint.station_name, OperatePoint.storage_location_name).filter( and_( OperatePoint.scene_id == request.scene_id, OperatePoint.is_deleted == False ) ).all() existing_station_names = {point.station_name for point in existing_points} existing_location_names = {point.storage_location_name for point in existing_points} # 检查请求中的动作点是否有重复的站点名称和库位名称（包括与数据库中现有数据的重复） seen_station_names = set() seen_location_names = set() for point_data in request.operate_points: # 检查是否与数据库中现有数据重复 if point_data.station_name in existing_station_names: duplicate_stations.append(point_data.station_name) logger.warning(f"发现与数据库中现有数据重复的站点名称: {point_data.station_name}") continue if point_data.storage_location_name in existing_location_names: duplicate_stations.append(f"{point_data.station_name}(库位名重复)") logger.warning(f"发现与数据库中现有数据重复的库位名称: {point_data.storage_location_name}") continue # 检查是否在请求中重复 if point_data.station_name in seen_station_names: duplicate_stations.append(point_data.station_name) logger.warning(f"发现在请求中重复的站点名称: {point_data.station_name}") continue if point_data.storage_location_name in seen_location_names: duplicate_stations.append(f"{point_data.station_name}(库位名重复)") logger.warning(f"发现在请求中重复的库位名称: {point_data.storage_location_name}") continue seen_station_names.add(point_data.station_name) seen_location_names.add(point_data.storage_location_name) valid_operate_points.append(point_data) # 处理动作点数据 - 创建新数据 logger.info(f"开始创建动作点数据: 数量={len(valid_operate_points)}") for point_data in valid_operate_points: new_point = MapDataService._create_operate_point(point_data, request.scene_id, storage_area_type_mapping, storage_area_name_mapping) db.add(new_point) operate_points_count += 1 # 处理分层数据 if point_data.layers: layer_counts = MapDataService._handle_layers( db, new_point, point_data.layers, is_update=False ) layers_count += layer_counts['created'] # 提交事务 db.commit() logger.info(f"地图数据推送成功: 场景ID={request.scene_id}, " f"库区={storage_areas_count}个, 动作点={operate_points_count}个, " f"分层={layers_count}个") # 根据是否进行了覆盖操作和是否有重复站点生成不同的消息 result_message = "" if has_existing_data: result_message = f"推送成功，已覆盖现有数据。创建了{storage_areas_count}个库区，{operate_points_count}个动作点，{layers_count}个分层" else: result_message = f"推送成功，创建了{storage_areas_count}个库区，{operate_points_count}个动作点，{layers_count}个分层" # 如果有重复的站点，添加提示信息 if duplicate_stations: duplicate_count = len(duplicate_stations) duplicate_names = ", ".join(set(duplicate_stations)) # 去重后的站点名称 result_message += f"。检测到{duplicate_count}个重复的站点名称已被过滤：{duplicate_names}" return MapDataPushResponse( scene_id=request.scene_id, storage_areas_count=storage_areas_count, operate_points_count=operate_points_count, layers_count=layers_count, message=result_message ) except Exception as e: db.rollback() logger.error(f"地图数据推送失败: {str(e)}") raise @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): """删除现有数据""" # 软删除动作点分层 db.query(OperatePointLayer).filter( OperatePointLayer.operate_point_id.in_( db.query(OperatePoint.id).filter( and_( OperatePoint.scene_id == scene_id, OperatePoint.is_deleted == False ) ) ) ).update({OperatePointLayer.is_deleted: True}) # 软删除动作点 db.query(OperatePoint).filter( and_( OperatePoint.scene_id == scene_id, OperatePoint.is_deleted == False ) ).update({OperatePoint.is_deleted: True}) # 软删除库区 db.query(StorageArea).filter( and_( StorageArea.scene_id == scene_id, StorageArea.is_deleted == False ) ).update({StorageArea.is_deleted: True}) @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 _create_storage_area(area_data: StorageAreaData, scene_id: str, operate_points_data: List[OperatePointData]) -> StorageArea: """创建库区""" # 筛选属于该库区的动作点 area_points = [point for point in operate_points_data if point.storage_area_id == area_data.id] # 系统自动计算容量 max_capacity = MapDataService._calculate_storage_area_capacity( area_data.area_type.value, area_points ) return StorageArea( id=area_data.id, area_name=area_data.area_name, area_code=area_data.area_code, area_type=StorageAreaType(area_data.area_type), scene_id=scene_id, max_capacity=max_capacity, description=area_data.description, tags=area_data.tags ) @staticmethod def _create_operate_point(point_data: OperatePointData, scene_id: str, storage_area_type_mapping: Dict[str, StorageAreaTypeEnum], storage_area_name_mapping: Dict[str, str]) -> OperatePoint: """创建动作点""" # 根据库区ID获取库区类型和名称 storage_area_type = None area_name = None if point_data.storage_area_id and point_data.storage_area_id in storage_area_type_mapping: storage_area_type = StorageAreaType(storage_area_type_mapping[point_data.storage_area_id]) area_name = storage_area_name_mapping.get(point_data.storage_area_id) # 自动生成UUID作为动作点ID operate_point_id = str(uuid.uuid4()) return OperatePoint( id=operate_point_id, station_name=point_data.station_name, storage_location_name=point_data.storage_location_name, scene_id=scene_id, storage_area_id=point_data.storage_area_id, storage_area_type=storage_area_type, area_name=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 ) @staticmethod def _handle_layers(db: Session, operate_point: OperatePoint, layers_data: Optional[List[OperatePointLayerData]], is_update: bool = False) -> Dict[str, int]: """ 处理分层数据 Args: db: 数据库会话 operate_point: 动作点对象 layers_data: 分层数据列表 is_update: 是否为更新操作（现在始终为False） Returns: Dict[str, int]: 创建的分层数量统计 """ created_count = 0 if not layers_data: return {'created': created_count, 'updated': 0} # 创建新分层 for layer_data in layers_data: layer_id = str(uuid.uuid4()) new_layer = OperatePointLayer( id=layer_id, operate_point_id=operate_point.id, station_name=operate_point.station_name, storage_location_name=operate_point.storage_location_name, area_id=operate_point.storage_area_id, # 添加库区ID（冗余字段） area_name=operate_point.area_name, # 添加库区名称 scene_id=operate_point.scene_id, # 添加场景ID（冗余字段） layer_index=layer_data.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)}") # 不抛出异常，避免影响地图推送的主流程 created_count += 1 return {'created': created_count, 'updated': 0} @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)}") config = {} # 确保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