SuZhouGuanHong/ShanMeiXinNengYuan.git

			@@ -1,4 +1,5 @@
			using AutoMapper;
			using Microsoft.Extensions.Configuration;
			using SqlSugar;
			using System.Text.Json;
			using WIDESEA_Common.LocationEnum;
			@@ -22,6 +23,8 @@
			private readonly IStockInfoService _stockInfoService;
			private readonly ILocationInfoService _locationInfoService;
			private readonly HttpClientHelper _httpClientHelper;
			private readonly IConfiguration _configuration;
			private readonly RoundRobinService _roundRobinService;

			public IRepository<Dt_Task> Repository => BaseDal;

			@@ -39,12 +42,16 @@
			IMapper mapper,
			IStockInfoService stockInfoService,
			ILocationInfoService locationInfoService,
			HttpClientHelper httpClientHelper) : base(BaseDal)
			HttpClientHelper httpClientHelper,
			IConfiguration configuration,
			RoundRobinService roundRobinService) : base(BaseDal)
			{
			_mapper = mapper;
			_stockInfoService = stockInfoService;
			_locationInfoService = locationInfoService;
			_httpClientHelper = httpClientHelper;
			_configuration = configuration;
			_roundRobinService = roundRobinService;
			}

			#region WCS逻辑处理
			@@ -165,7 +172,7 @@
			task.CurrentAddress = task.SourceAddress;
			task.NextAddress = locationInfo.LocationCode;
			task.TargetAddress = locationInfo.LocationCode;
			task.TaskStatus = TaskStatusEnum.Line_Finish.GetHashCode();
			task.TaskStatus = TaskInStatusEnum.Line_InFinish.GetHashCode();

			var updateResult = await BaseDal.UpdateDataAsync(task);
			var locationResult = await _locationInfoService.UpdateLocationInfoAsync(locationInfo);
			@@ -338,7 +345,7 @@
			{
			try
			{
			var tasks = await BaseDal.QueryFirstAsync(s => s.TaskId == taskId);
			var tasks = await BaseDal.QueryFirstAsync(s => s.TaskNum == taskId);
			if (tasks == null)
			return WebResponseContent.Instance.Error("未找到对应的任务");

			@@ -375,6 +382,164 @@
			}
			}

			/// <summary>
			/// 根据巷道确定目标地址
			/// </summary>
			private string DetermineTargetAddress(string roadway, Dictionary<string, string> addressMap)
			{
			if (string.IsNullOrWhiteSpace(roadway))
			return "10080"; // 默认地址

			foreach (var kvp in addressMap)
			{
			if (roadway.Contains(kvp.Key))
			return kvp.Value;
			}

			return "10080"; // 默认地址
			}

			/// <summary>
			/// 自动创建出库任务 - 查询到期库存并创建任务
			/// </summary>
			public async Task<WebResponseContent> CreateAutoOutboundTasksAsync()
			{
			try
			{
			// 1. 查询到期库存
			var expiredStocks = await _stockInfoService.Repository
			.QueryDataAsync(s => s.OutboundDate <= DateTime.Now
			&& s.StockStatus == StockStatusEmun.入库完成.GetHashCode());

			if (expiredStocks == null \|\| !expiredStocks.Any())
			{
			return WebResponseContent.Instance.OK("无到期库存需要处理");
			}

			// 批量加载位置详情（优化 N+1 查询问题）
			var locationIds = expiredStocks
			.Where(s => s.LocationId > 0)
			.Select(s => s.LocationId)
			.Distinct()
			.Cast<object>()
			.ToList();

			if (locationIds.Any())
			{
			var locations = await _locationInfoService.Repository
			.QureyDataByIdsAsync(locationIds);

			// 创建位置字典以便快速查找
			var locationDict = locations.ToDictionary(l => l.Id, l => l);

			// 为每个库存关联位置详情
			foreach (var stock in expiredStocks)
			{
			if (stock.LocationId > 0 && locationDict.ContainsKey(stock.LocationId))
			{
			stock.LocationDetails = locationDict[stock.LocationId];
			}
			}
			}

			// 过滤有位置且位置有库存的记录
			expiredStocks = expiredStocks
			.Where(s => s.LocationDetails != null
			&& s.LocationDetails.LocationStatus == LocationStatusEnum.InStock.GetHashCode())
			.ToList();

			if (!expiredStocks.Any())
			{
			return WebResponseContent.Instance.OK("无符合条件的到期库存");
			}

			// 2. 检查已存在的任务
			var palletCodes = expiredStocks.Select(s => s.PalletCode).ToList();
			var existingTasks = await Repository.QueryDataAsync(t =>
			palletCodes.Contains(t.PalletCode)
			&& (t.TaskStatus == TaskStatusEnum.New.GetHashCode()
			\|\| t.TaskStatus == TaskStatusEnum.SC_Executing.GetHashCode()
			\|\| t.TaskStatus == TaskInStatusEnum.InNew.GetHashCode()));

			var processedPallets = existingTasks.Select(t => t.PalletCode).ToHashSet();

			// 3. 筛选需要处理的库存
			var stocksToProcess = expiredStocks
			.Where(s => !processedPallets.Contains(s.PalletCode))
			.ToList();

			if (!stocksToProcess.Any())
			{
			return WebResponseContent.Instance.OK("所有到期库存已存在任务");
			}

			// 4. 获取配置的目标地址映射
			var targetAddressMap = _configuration.GetSection("AutoOutboundTask:TargetAddresses")
			.Get<Dictionary<string, string>>()
			?? new Dictionary<string, string>();

			// 5. 批量创建任务
			var taskList = new List<Dt_Task>();
			foreach (var stock in stocksToProcess)
			{
			// 根据巷道确定目标地址
			var targetAddress = DetermineTargetAddress(
			stock.LocationDetails?.RoadwayNo ?? "",
			targetAddressMap);

			var task = new Dt_Task
			{
			WarehouseId = stock.WarehouseId,
			PalletCode = stock.PalletCode,
			PalletType = stock.PalletType,
			SourceAddress = stock.LocationCode,
			CurrentAddress = stock.LocationCode,
			NextAddress = targetAddress,
			TargetAddress = targetAddress,
			Roadway = stock.LocationDetails?.RoadwayNo ?? "",
			TaskType = TaskTypeEnum.Outbound.GetHashCode(),
			TaskStatus = TaskStatusEnum.New.GetHashCode(),
			Grade = 1,
			TaskNum = 0, // 使用 0 让数据库自动生成任务号
			Creater = "system_auto"
			};
			taskList.Add(task);
			}

			var addResult = await BaseDal.AddDataAsync(taskList) > 0;
			if (!addResult)
			{
			return WebResponseContent.Instance.Error($"批量创建任务失败，共 {taskList.Count} 个任务");
			}

			// 6. 通知 WCS（异步，不影响主流程）
			_ = Task.Run(() =>
			{
			foreach (var task in taskList)
			{
			try
			{
			var wmstaskDto = _mapper.Map<WMSTaskDTO>(task);
			_httpClientHelper.Post<WebResponseContent>(
			"http://logistics-service/api/logistics/notifyoutbound",
			JsonSerializer.Serialize(wmstaskDto));
			}
			catch (Exception ex)
			{
			// WCS 通知失败不影响任务创建，记录日志即可
			Console.WriteLine($"WCS 通知失败，任务编号: {task.TaskNum}, 错误: {ex.Message}");
			}
			}
			});

			return WebResponseContent.Instance.OK($"成功创建 {taskList.Count} 个出库任务", taskList.Count);
			}
			catch (Exception ex)
			{
			return WebResponseContent.Instance.Error($"自动创建出库任务失败: {ex.Message}");
			}
			}

			#endregion WCS逻辑处理

			#region 分容柜接口