refactor: 整理TaskService任务流程结构

wanshenmean

2026-03-31 a200871400d465620d45189b8068fafd0d95e01a

refactor: 整理TaskService任务流程结构

 Code/WMS/WIDESEA_WMSServer/WIDESEA_TaskInfoService/TaskService.cs

@@ -74,5 +74,97 @@
            _unitOfWorkManage = unitOfWorkManage;
        }

        /// <summary>
        /// 查找托盘是否存在未完成任务。
        /// </summary>
        private async Task<WebResponseContent> GetTaskByPalletCodeAsync(string palletCode)
        {
            try
            {
                var task = await BaseDal.QueryFirstAsync(s => s.PalletCode == palletCode);
                if (task == null)
                    return WebResponseContent.Instance.Error("未找到对应的任务");

                var taskDto = _mapper.Map<WMSTaskDTO>(task);
                return WebResponseContent.Instance.OK("查询成功", taskDto);
            }
            catch (Exception ex)
            {
                return WebResponseContent.Instance.Error($"查询任务失败: {ex.Message}");
            }
        }

        /// <summary>
        /// 保存任务历史。
        /// </summary>
        private async Task<WebResponseContent> SaveTaskHistoryAsync(Dt_Task task, string operateType)
        {
            var historyTask = _mapper.Map<Dt_Task_Hty>(task);
            historyTask.InsertTime = DateTime.Now;
            historyTask.OperateType = operateType;

            var saved = await _task_HtyService.Repository.AddDataAsync(historyTask) > 0;
            return saved
                ? WebResponseContent.Instance.OK()
                : WebResponseContent.Instance.Error("任务历史保存失败");
        }

        /// <summary>
        /// 保存库存历史。
        /// </summary>
        private async Task<WebResponseContent> SaveStockHistoryAsync(Dt_StockInfo stockInfo, string operateType)
        {
            var historyStock = _mapper.Map<Dt_StockInfo_Hty>(stockInfo);
            historyStock.InsertTime = DateTime.Now;
            historyStock.OperateType = operateType;

            var saved = await _stockInfo_HtyService.Repository.AddDataAsync(historyStock) > 0;
            return saved
                ? WebResponseContent.Instance.OK()
                : WebResponseContent.Instance.Error("库存历史保存失败");
        }

        /// <summary>
        /// 完成任务后统一处理。
        /// </summary>
        private async Task<WebResponseContent> CompleteTaskAsync(Dt_Task task, string operateType = "")
        {
            var deleteTaskResult = await BaseDal.DeleteDataAsync(task);
            if (!deleteTaskResult)
                return WebResponseContent.Instance.Error("任务完成失败");

            return await SaveTaskHistoryAsync(task, operateType);
        }

        /// <summary>
        /// 根据巷道确定目标地址，支持多出库口轮询。
        /// </summary>
        private string DetermineTargetAddress(string roadway, Dictionary<string, List<string>> addressMap)
        {
            if (string.IsNullOrWhiteSpace(roadway))
                return "10080";

            string? matchedPrefix = null;
            foreach (var kvp in addressMap)
            {
                if (roadway.Contains(kvp.Key))
                {
                    matchedPrefix = kvp.Key;
                    break;
                }
            }

            if (matchedPrefix == null)
                return "10080";

            if (!addressMap.TryGetValue(matchedPrefix, out var addresses) || addresses == null || addresses.Count == 0)
                return "10080";

            if (addresses.Count == 1)
                return addresses[0];

            return _roundRobinService.GetNextAddress(matchedPrefix, addresses);
        }

    }
}

 Code/WMS/WIDESEA_WMSServer/WIDESEA_TaskInfoService/TaskService_AGV.cs

@@ -1,26 +1,13 @@
using Mapster;
using MapsterMapper;
using Microsoft.Extensions.Configuration;
using SqlSugar;
using System.DirectoryServices.Protocols;
using System.Text.Json;
using WIDESEA_Common.LocationEnum;
using WIDESEA_Common.StockEnum;
using WIDESEA_Common.TaskEnum;
using WIDESEA_Common.WareHouseEnum;
using WIDESEA_Core;
using WIDESEA_Core.BaseRepository;
using WIDESEA_Core.BaseServices;
using WIDESEA_Core.Core;
using WIDESEA_Core.Enums;
using WIDESEA_Core.Helper;
using WIDESEA_DTO.GradingMachine;
using WIDESEA_DTO.MES;
using WIDESEA_DTO.Stock;
using WIDESEA_DTO.Task;
using WIDESEA_IBasicService;
using WIDESEA_IStockService;
using WIDESEA_ITaskInfoService;
using WIDESEA_Model.Models;

namespace WIDESEA_TaskInfoService
@@ -29,323 +16,427 @@
    {
        #region 极卷库任务模块

        public string AGV_OutTaskComplete = WIDESEA_Core.Helper.AppSettings.Configuration["AGV_OutTaskComplete"]; // 上报AGV出库输送线完成
        public string WCS_ReceiveTask = WIDESEA_Core.Helper.AppSettings.Configuration["WCS_ReceiveTask"]; // WMS输送线任务下发
        public string AGV_OutTaskComplete = WIDESEA_Core.Helper.AppSettings.Configuration["AGV_OutTaskComplete"];
        public string WCS_ReceiveTask = WIDESEA_Core.Helper.AppSettings.Configuration["WCS_ReceiveTask"];

        /// <summary>
        /// 出入库申请
        /// 出入库申请。
        /// </summary>
        /// <param name="applyInOutDto">请求参数</param>
        /// <returns></returns>
        public async Task<AGVResponse> ApplyInOutAsync(ApplyInOutDto applyInOutDto)
        {
            AGVResponse aGVResponse = new AGVResponse();
            AGVResponse response = new AGVResponse();

            try
            {
                // 参数验证
                if (applyInOutDto == null) return aGVResponse.Error("请求参数不能为空");
                if (string.IsNullOrWhiteSpace(applyInOutDto.TrayNumber)) return aGVResponse.Error("托盘号不能为空");
                if (string.IsNullOrWhiteSpace(applyInOutDto.TaskId)) return aGVResponse.Error("任务号不能为空");
                if (string.IsNullOrWhiteSpace(applyInOutDto.MaterialType)) return aGVResponse.Error("物料类型不能为空");
                if (string.IsNullOrWhiteSpace(applyInOutDto.MaterialName)) return aGVResponse.Error("物料描述不能为空");
                if (string.IsNullOrWhiteSpace(applyInOutDto.ReqTime)) return aGVResponse.Error("请求时间不能为空");
                if (applyInOutDto.Floor != 1 && applyInOutDto.Floor != 2) return aGVResponse.Error($"楼层段错误，必须为1(模切段)或2(卷绕段)，当前值：{applyInOutDto.Floor}");
                if (applyInOutDto.YinYang != 1 && applyInOutDto.YinYang != 2) return aGVResponse.Error($"阴阳极错误，必须为1(阴极)或2(阳极)，当前值：{applyInOutDto.YinYang}");
                if (applyInOutDto.InOut != 1 && applyInOutDto.InOut != 2) return aGVResponse.Error($"出入库类型错误，必须为1(入库)或2(出库)，当前值：{applyInOutDto.InOut}");
                if (applyInOutDto.InOut == 1) // 入库
                {
                    if (applyInOutDto.Width == null || applyInOutDto.Width <= 0) return aGVResponse.Error("入库时宽度不能为空且必须大于0");
                    if (string.IsNullOrWhiteSpace(applyInOutDto.Group)) return aGVResponse.Error("入库时整托组别不能为空");
                }
                // 检查任务是否已存在
                var validationMessage = ValidateApplyInOutRequest(applyInOutDto);
                if (validationMessage != null)
                    return response.Error(validationMessage);

                var existingTask = await BaseDal.QueryFirstAsync(x => x.PalletCode == applyInOutDto.TrayNumber);
                if (existingTask != null) return aGVResponse.Error($"WMS已有当前任务，不可重复下发，任务号：{applyInOutDto.TaskId}");
                // 创建任务
                Dt_Task task = new Dt_Task
                {
                    OrderNo = applyInOutDto.TaskId, // 使用AGV的任务号
                    PalletCode = applyInOutDto.TrayNumber,
                    PalletType = applyInOutDto.Floor,
                    //WarehouseId = applyInOutDto.YinYang,
                    Grade = 1,
                    Creater = "AGV",
                    CreateDate = DateTime.Now,
                    Remark = $"物料类型：{applyInOutDto.MaterialType}，物料描述：{applyInOutDto.MaterialName}"
                };
                // 根据阴极/阳极设置巷道和站台
                if (applyInOutDto.YinYang == 1) // 阴极
                {
                    // 货物到达后分配货物位
                    task.Roadway = WarehouseEnum.FJ1.ToString();
                    task.WarehouseId = (int)WarehouseEnum.FJ1;
                    task.SourceAddress = applyInOutDto.InOut == 1 ? "D10010" : "D10020"; // 入库口/出库口
                    task.NextAddress = "D10080"; // 阴极公共出库口
                    task.TargetAddress = "阴极卷库";
                }
                else if (applyInOutDto.YinYang == 2) // 阳极
                {
                    task.Roadway = WarehouseEnum.ZJ1.ToString();
                    task.WarehouseId = (int)WarehouseEnum.ZJ1;
                    task.SourceAddress = applyInOutDto.InOut == 1 ? "D10100" : "D10090"; // 入库口/出库口
                    task.NextAddress = "D10160"; // 阳极公共出库口
                    task.TargetAddress = "正极卷库";
                }
                // 根据出入库类型设置目标地址
                if (applyInOutDto.InOut == 1) // 入库
                {
                    var stockInfo = await _stockInfoService.GetStockInfoAsync(applyInOutDto.TrayNumber);
                    if (stockInfo != null) return aGVResponse.Error($"当前托盘{applyInOutDto.TrayNumber}已经入库了");
                if (existingTask != null)
                    return response.Error($"WMS已有当前任务，不可重复下发，任务号：{applyInOutDto.TaskId}");

                    task.TaskType = (int)TaskInboundTypeEnum.Inbound;
                    task.TaskStatus = (int)TaskInStatusEnum.InNew;
                    task.CurrentAddress = task.SourceAddress; // 当前在入库口
                    // 保存任务
                    var result = await BaseDal.AddDataAsync(task);
                }
                else // 出库
                {
                    // 判断是否移库
                    task.TaskType = (int)TaskOutboundTypeEnum.Outbound;
                    task.TaskStatus = (int)TaskOutStatusEnum.OutNew;
                    task.CurrentAddress = task.SourceAddress; // 当前在入库口
                    // 查找库存
                    var stockInfo = await _stockInfoService.GetStockInfoAsync(applyInOutDto.TrayNumber);
                    if (stockInfo == null) return aGVResponse.Error($"未找到托盘{applyInOutDto.TrayNumber}的库存信息");
                    // 验证库存所属是否正确
                    if (stockInfo.WarehouseId != applyInOutDto.YinYang) return aGVResponse.Error($"托盘{applyInOutDto.TrayNumber}不属于当前{(applyInOutDto.YinYang == 1 ? "阴极" : "阳极")}");
                    if (stockInfo.StockStatus != (int)StockStatusEmun.入库完成) return aGVResponse.Error($"托盘{applyInOutDto.TrayNumber}正在移动中，请稍后！");
                    task.SourceAddress = stockInfo.LocationCode; // 源地址为货位
                    task.CurrentAddress = stockInfo.LocationCode; // 当前位置在货位
                    task.TargetAddress = applyInOutDto.YinYang == 1 ? "D10020" : "D10090"; // 目标地址为出库口
                var task = BuildAgvTask(applyInOutDto);

                    // 保存任务
                    var result = await BaseDal.AddDataAsync(task);
                    // 判断是否移库
                    //var transferTask = await _locationInfoService.TransferCheckAsync(result);
                }

                // 构建响应数据
                AGVDataDto aGVDataDto = new AGVDataDto
                if (applyInOutDto.InOut == 1)
                {
                    DevId = applyInOutDto.InOut == 1 ? task.SourceAddress : task.TargetAddress,
                    TrayNumber = task.PalletCode,
                    Group = applyInOutDto.Group,
                    Width = applyInOutDto.Width ?? 0,
                    LabelNumber = applyInOutDto.LabelNumber,
                    ProductNo = applyInOutDto.ProductNo,
                    ProductName = applyInOutDto.ProductName,
                    Quantity = applyInOutDto.Quantity,
                    UomCode = applyInOutDto.UomCode,
                    ProductType = applyInOutDto.ProductType,
                    Equipment = applyInOutDto.Equipment,
                    ProductionDate = applyInOutDto.ProductionDate,
                    LowerLimitTime = applyInOutDto.LowerLimitTime,
                    WarningTime = applyInOutDto.WarningTime,
                    OverdueTime = applyInOutDto.OverdueTime
                };

                return aGVResponse.OK(aGVDataDto);
            }
            catch (Exception ex)
            {
                return aGVResponse.Error($"WMS任务创建接口错误: {ex.Message}");
            }
        }

        /// <summary>
        /// 手动出库完成反馈给AGV
        /// </summary>
        /// <param name="outTaskCompleteDto">请求参数</param>
        /// <returns></returns>
        public async Task<WebResponseContent> OutTaskComplete(OutTaskCompleteDto outTaskCompleteDto)
        {
            WebResponseContent webResponse = new WebResponseContent();
            try
            {
                if (outTaskCompleteDto == null) return webResponse.Error("请求参数不能为空");
                if (string.IsNullOrWhiteSpace(outTaskCompleteDto.TaskId)) return webResponse.Error("任务号不能为空");
                if (string.IsNullOrWhiteSpace(outTaskCompleteDto.DevId)) return webResponse.Error("出库口编号不能为空");
                var task = await BaseDal.QueryFirstAsync(x => x.OrderNo == outTaskCompleteDto.TaskId);
                if (task == null) return webResponse.Error("未找到任务信息");
                outTaskCompleteDto.ReqTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
                var httpResponse = _httpClientHelper.Post<AGVResponse>(AGV_OutTaskComplete, outTaskCompleteDto.ToJson()).Data;
                // 判断远程接口返回是否成功
                if (httpResponse != null && httpResponse.Data != null)
                {
                    AGVResponse agvResponse = httpResponse;
                    // 根据code字段判断，code为true表示成功
                    if (agvResponse.Code == true)
                    {
                        var stockInfo = await _stockInfoService.GetStockInfoAsync(task.PalletCode);
                        if (stockInfo == null) return webResponse.Error($"未找到托盘{task.PalletCode}的库存信息");
                        var locationInfo = await _locationInfoService.GetLocationInfoAsync(stockInfo.LocationCode);
                        if (locationInfo == null) return webResponse.Error($"未找到托盘{stockInfo.LocationCode}的货位信息");
                        if (stockInfo.StockStatus != (int)StockStatusEmun.出库锁定 || locationInfo.LocationStatus != (int)LocationStatusEnum.InStockLock)
                        {
                            return webResponse.Error($"当前库存{stockInfo.StockStatus}或者货位{locationInfo.LocationStatus}状态信息错误");
                        }
                        locationInfo.LocationStatus = (int)LocationStatusEnum.Free;
                        _unitOfWorkManage.BeginTran();
                        BaseDal.DeleteData(task);
                        _locationInfoService.UpdateData(locationInfo);
                        _stockInfoService.DeleteData(stockInfo);
                        _unitOfWorkManage.CommitTran();
                        return webResponse.OK(agvResponse.Msg);
                    var inboundResult = await CreateAgvInboundTaskAsync(task, applyInOutDto);
                    if (inboundResult != null)
                        return inboundResult;
                    }
                    else
                    {
                        // 失败：返回AGV返回的错误信息
                        return webResponse.Error(string.IsNullOrWhiteSpace(agvResponse.Msg)
                            ? "AGV接口调用失败"
                            : agvResponse.Msg);
                    var outboundResult = await CreateAgvOutboundTaskAsync(task, applyInOutDto);
                    if (outboundResult != null)
                        return outboundResult;
                    }
                }
                else
                {
                    // HTTP请求本身失败
                    return webResponse.Error(httpResponse?.Msg ?? "AGV接口调用异常");
                }

                return response.OK(BuildAgvDataDto(task, applyInOutDto));
            }
            catch (Exception ex)
            {
                _unitOfWorkManage.RollbackTran();
                return webResponse.Error($"WMS任务完成接口错误：{ex.Message}");
                return response.Error($"WMS任务创建接口错误: {ex.Message}");
            }
        }

        ///// <summary>
        ///// 任务完成接口
        ///// </summary>
        ///// <param name="wCSTask"></param>
        ///// <returns></returns>
        //public async Task<WebResponseContent> TaskCompleted(WCSTaskDTO wCSTask)
        //{
        //    WebResponseContent webResponse = new WebResponseContent();
        //    try
        //    {
        //        Dt_Task task = await BaseDal.QueryFirstAsync(x => x.TaskId == wCSTask.TaskNum && x.PalletCode == wCSTask.PalletCode);
        //        if (task == null) return webResponse.Error("未找到任务信息");
        //        // 出库完成反馈
        //        OutTaskCompleteDto outTaskCompleteDto = new OutTaskCompleteDto()
        //        {
        //            TaskId = task.OrderNo,
        //            DevId = task.TargetAddress,
        //            ReqTime = DateTime.Now.ToString()
        //        };
        //        return await OutTaskComplete(outTaskCompleteDto);
        //    }
        //    catch (Exception ex)
        //    {
        //        return webResponse.Error($"WMS任务完成接口错误：{ex.Message}");
        //    }
        //}
        /// <summary>
        /// 输送线申请进入
        /// 手动出库完成反馈给AGV。
        /// </summary>
        /// <param name="applyEnterDto">请求参数</param>
        /// <returns></returns>
        public async Task<AGVResponse> ApplyEnterAsync(ApplyEnterDto applyEnterDto)
        public async Task<WebResponseContent> OutTaskComplete(OutTaskCompleteDto outTaskCompleteDto)
        {
            AGVResponse aGVResponse = new AGVResponse();
            WebResponseContent response = new WebResponseContent();

            try
            {
                // 参数验证
                if (applyEnterDto == null) return aGVResponse.Error("请求参数不能为空");
                if (string.IsNullOrWhiteSpace(applyEnterDto.DevId)) return aGVResponse.Error("设备编号不能为空");
                if (string.IsNullOrWhiteSpace(applyEnterDto.TaskId)) return aGVResponse.Error("任务号不能为空");
                if (applyEnterDto.InOut != 1 && applyEnterDto.InOut != 2) return aGVResponse.Error($"出入库类型错误，必须为1(入库)或2(出库)，当前值：{applyEnterDto.InOut}");
                var validationMessage = ValidateOutTaskCompleteRequest(outTaskCompleteDto);
                if (validationMessage != null)
                    return response.Error(validationMessage);

                // 查询任务是否存在
                var task = await BaseDal.QueryFirstAsync(x => x.OrderNo == applyEnterDto.TaskId);
                if (task == null) return aGVResponse.Error($"未找到任务信息，任务号：{applyEnterDto.TaskId}");
                if (applyEnterDto.InOut == 1 && task.TaskType == (int)TaskInboundTypeEnum.Inbound && task.TaskStatus == (int)TaskInStatusEnum.InNew)
                {
                    aGVResponse.OK();
                }
                else if (applyEnterDto.InOut == 2 && task.TaskType == (int)TaskOutboundTypeEnum.Outbound && task.TaskStatus == (int)TaskStatusEnum.Line_Finish)
                {
                    aGVResponse.OK();
                }
                return aGVResponse.Error($"输送线{applyEnterDto.DevId}当前繁忙，请稍后重试");
                var task = await BaseDal.QueryFirstAsync(x => x.OrderNo == outTaskCompleteDto.TaskId);
                if (task == null)
                    return response.Error("未找到任务信息");

                // Dt_Task.SourceAddress询问wcs站台1-阴极入口叫D10010和D10020；2-阳极D10090和D10100是否有货物
                //var httpResponse = _httpClientHelper.Post<WebResponseContent>("http://127.0.0.1:9999/api/Task/ApplyInOut", JsonSerializer.Serialize(task)).Data;
                //if (httpResponse != null && httpResponse.Status == true)
                //{
                //    _unitOfWorkManage.BeginTran();
                //    task.TaskStatus = (int)TaskStatusEnum.AGV_Executing;
                //    await BaseDal.UpdateDataAsync(task);
                //    _unitOfWorkManage.CommitTran();
                //    return aGVResponse.OK();
                //}
                //else
                //{
                //    return aGVResponse.Error($"站台{task.SourceAddress}已经载货");
                //}
                outTaskCompleteDto.ReqTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
                var httpResponse = _httpClientHelper.Post<AGVResponse>(AGV_OutTaskComplete, outTaskCompleteDto.ToJson()).Data;
                if (httpResponse == null || httpResponse.Data == null)
                    return response.Error(httpResponse?.Msg ?? "AGV接口调用异常");

                if (!httpResponse.Code)
                    return response.Error(string.IsNullOrWhiteSpace(httpResponse.Msg) ? "AGV接口调用失败" : httpResponse.Msg);

                var syncResult = await CompleteLocalOutboundAfterAgvAckAsync(task);
                return syncResult.Status ? response.OK(httpResponse.Msg) : syncResult;
            }
            catch (Exception ex)
            {
                //_unitOfWorkManage.RollbackTran();
                return aGVResponse.Error($"WMS输送线申请接口错误：{ex.Message}");
                _unitOfWorkManage.RollbackTran();
                return response.Error($"WMS任务完成接口错误：{ex.Message}");
            }
        }

        /// <summary>
        /// 取放货完成
        /// 输送线申请进入。
        /// </summary>
        /// <param name="taskCompleteDto">请求参数</param>
        /// <returns></returns>
        public async Task<AGVResponse> TaskCompleteAsync(TaskCompleteDto taskCompleteDto)
        public async Task<AGVResponse> ApplyEnterAsync(ApplyEnterDto applyEnterDto)
        {
            AGVResponse aGVResponse = new AGVResponse();
            AGVResponse response = new AGVResponse();

            try
            {
                if (taskCompleteDto == null) return aGVResponse.Error("请求参数不能为空");
                if (string.IsNullOrWhiteSpace(taskCompleteDto.TaskId)) return aGVResponse.Error("任务号不能为空");
                if (string.IsNullOrWhiteSpace(taskCompleteDto.DevId)) return aGVResponse.Error("设备编号不能为空");
                if (taskCompleteDto.InOut != 1 && taskCompleteDto.InOut != 2) return aGVResponse.Error($"出入库类型错误，必须为1(入库)或2(出库)，当前值：{taskCompleteDto.InOut}");
                var task = await BaseDal.QueryFirstAsync(x => x.OrderNo == taskCompleteDto.TaskId);
                if (task == null) return aGVResponse.Error($"未找到任务信息，任务号：{taskCompleteDto.TaskId}");
                if (taskCompleteDto.InOut == 2)
                {
                    var stockInfo = await _stockInfoService.GetStockInfoAsync(task.PalletCode);
                    if (stockInfo == null) return aGVResponse.Error($"未找到托盘{task.PalletCode}的库存信息");
                    var locationInfo = await _locationInfoService.GetLocationInfoAsync(stockInfo.LocationCode);
                    if (locationInfo == null) return aGVResponse.Error($"未找到托盘{stockInfo.LocationCode}的货位信息");
                    if (stockInfo.StockStatus != (int)StockStatusEmun.出库锁定 || locationInfo.LocationStatus != (int)LocationStatusEnum.InStockLock)
                    {
                        return aGVResponse.Error($"当前库存{stockInfo.StockStatus}或者货位{locationInfo.LocationStatus}状态信息错误");
                var validationMessage = ValidateApplyEnterRequest(applyEnterDto);
                if (validationMessage != null)
                    return response.Error(validationMessage);

                var task = await BaseDal.QueryFirstAsync(x => x.OrderNo == applyEnterDto.TaskId);
                if (task == null)
                    return response.Error($"未找到任务信息，任务号：{applyEnterDto.TaskId}");

                if (CanApplyEnter(task, applyEnterDto))
                    return response.OK();

                return response.Error($"输送线{applyEnterDto.DevId}当前繁忙，请稍后重试");
                    }
                    locationInfo.LocationStatus = (int)LocationStatusEnum.Free;
                    task.TaskStatus = (int)TaskOutStatusEnum.OutFinish;
                    _unitOfWorkManage.BeginTran();
                    _stockInfoService.DeleteData(stockInfo);
                    await _locationInfoService.UpdateLocationInfoAsync(locationInfo);
                    BaseDal.DeleteAndMoveIntoHty(task, App.User.UserId == 0 ? OperateTypeEnum.自动完成 : OperateTypeEnum.人工完成);
                    _unitOfWorkManage.CommitTran();
            catch (Exception ex)
            {
                return response.Error($"WMS输送线申请接口错误：{ex.Message}");
            }
        }

        /// <summary>
        /// 取放货完成。
        /// </summary>
        public async Task<AGVResponse> TaskCompleteAsync(TaskCompleteDto taskCompleteDto)
        {
            AGVResponse response = new AGVResponse();

            try
            {
                var validationMessage = ValidateTaskCompleteRequest(taskCompleteDto);
                if (validationMessage != null)
                    return response.Error(validationMessage);

                var task = await BaseDal.QueryFirstAsync(x => x.OrderNo == taskCompleteDto.TaskId);
                if (task == null)
                    return response.Error($"未找到任务信息，任务号：{taskCompleteDto.TaskId}");

                return taskCompleteDto.InOut == 2
                    ? await CompleteAgvOutboundTaskAsync(task)
                    : await CompleteAgvInboundTaskAsync(task);
            }
            catch (Exception ex)
            {
                _unitOfWorkManage.RollbackTran();
                return response.Error($"WMS取放货完成接口错误：{ex.Message}");
            }
        }

        /// <summary>
        /// 任务取消。
        /// </summary>
        public async Task<AGVResponse> TaskCancelAsync(TaskCancelDto taskCancelDto)
        {
            AGVResponse response = new AGVResponse();

            try
            {
                var validationMessage = ValidateTaskCancelRequest(taskCancelDto);
                if (validationMessage != null)
                    return response.Error(validationMessage);

                var task = await BaseDal.QueryFirstAsync(x => x.OrderNo == taskCancelDto.TaskId);
                if (task == null)
                    return response.OK();

                if (task.TaskStatus == (int)TaskInStatusEnum.InNew)
                    return CancelAgvInboundTask(task);

                if (task.TaskStatus == (int)TaskOutStatusEnum.OutNew)
                    return await CancelAgvOutboundTaskAsync(task);

                return response.Error("任务已经在执行中，不可取消");
            }
            catch (Exception ex)
            {
                _unitOfWorkManage.RollbackTran();
                return response.Error($"WMS任务取消接口错误：{ex.Message}");
            }
        }

        private static string? ValidateApplyInOutRequest(ApplyInOutDto dto)
        {
            if (dto == null) return "请求参数不能为空";
            if (string.IsNullOrWhiteSpace(dto.TrayNumber)) return "托盘号不能为空";
            if (string.IsNullOrWhiteSpace(dto.TaskId)) return "任务号不能为空";
            if (string.IsNullOrWhiteSpace(dto.MaterialType)) return "物料类型不能为空";
            if (string.IsNullOrWhiteSpace(dto.MaterialName)) return "物料描述不能为空";
            if (string.IsNullOrWhiteSpace(dto.ReqTime)) return "请求时间不能为空";
            if (dto.Floor != 1 && dto.Floor != 2) return $"楼层段错误，必须为1(模切段)或2(卷绕段)，当前值：{dto.Floor}";
            if (dto.YinYang != 1 && dto.YinYang != 2) return $"阴阳极错误，必须为1(阴极)或2(阳极)，当前值：{dto.YinYang}";
            if (dto.InOut != 1 && dto.InOut != 2) return $"出入库类型错误，必须为1(入库)或2(出库)，当前值：{dto.InOut}";
            if (dto.InOut == 1 && (dto.Width == null || dto.Width <= 0)) return "入库时宽度不能为空且必须大于0";
            if (dto.InOut == 1 && string.IsNullOrWhiteSpace(dto.Group)) return "入库时整托组别不能为空";
            return null;
        }

        private static string? ValidateOutTaskCompleteRequest(OutTaskCompleteDto dto)
        {
            if (dto == null) return "请求参数不能为空";
            if (string.IsNullOrWhiteSpace(dto.TaskId)) return "任务号不能为空";
            if (string.IsNullOrWhiteSpace(dto.DevId)) return "出库口编号不能为空";
            return null;
        }

        private static string? ValidateApplyEnterRequest(ApplyEnterDto dto)
        {
            if (dto == null) return "请求参数不能为空";
            if (string.IsNullOrWhiteSpace(dto.DevId)) return "设备编号不能为空";
            if (string.IsNullOrWhiteSpace(dto.TaskId)) return "任务号不能为空";
            if (dto.InOut != 1 && dto.InOut != 2) return $"出入库类型错误，必须为1(入库)或2(出库)，当前值：{dto.InOut}";
            return null;
        }

        private static string? ValidateTaskCompleteRequest(TaskCompleteDto dto)
        {
            if (dto == null) return "请求参数不能为空";
            if (string.IsNullOrWhiteSpace(dto.TaskId)) return "任务号不能为空";
            if (string.IsNullOrWhiteSpace(dto.DevId)) return "设备编号不能为空";
            if (dto.InOut != 1 && dto.InOut != 2) return $"出入库类型错误，必须为1(入库)或2(出库)，当前值：{dto.InOut}";
            return null;
        }

        private static string? ValidateTaskCancelRequest(TaskCancelDto dto)
        {
            if (dto == null) return "请求参数不能为空";
            if (string.IsNullOrWhiteSpace(dto.TaskId)) return "任务号不能为空";
            return null;
        }

        private Dt_Task BuildAgvTask(ApplyInOutDto dto)
        {
            var task = new Dt_Task
            {
                OrderNo = dto.TaskId,
                PalletCode = dto.TrayNumber,
                PalletType = dto.Floor,
                Grade = 1,
                Creater = "AGV",
                CreateDate = DateTime.Now,
                Remark = $"物料类型：{dto.MaterialType}，物料描述：{dto.MaterialName}"
            };

            if (dto.YinYang == 1)
            {
                task.Roadway = WarehouseEnum.FJ1.ToString();
                task.WarehouseId = (int)WarehouseEnum.FJ1;
                task.SourceAddress = dto.InOut == 1 ? "D10010" : "D10020";
                task.NextAddress = "D10080";
                task.TargetAddress = "阴极卷库";
                }
                else
                {
                    //查找可用货位
                    var availableLocation = await _locationInfoService.GetLocationInfo(task.Roadway);
                task.Roadway = WarehouseEnum.ZJ1.ToString();
                task.WarehouseId = (int)WarehouseEnum.ZJ1;
                task.SourceAddress = dto.InOut == 1 ? "D10100" : "D10090";
                task.NextAddress = "D10160";
                task.TargetAddress = "正极卷库";
            }

                    if (availableLocation == null) return aGVResponse.Error("无可用的入库货位");
            return task;
        }

        private AGVDataDto BuildAgvDataDto(Dt_Task task, ApplyInOutDto dto)
        {
            return new AGVDataDto
            {
                DevId = dto.InOut == 1 ? task.SourceAddress : task.TargetAddress,
                TrayNumber = task.PalletCode,
                Group = dto.Group,
                Width = dto.Width ?? 0,
                LabelNumber = dto.LabelNumber,
                ProductNo = dto.ProductNo,
                ProductName = dto.ProductName,
                Quantity = dto.Quantity,
                UomCode = dto.UomCode,
                ProductType = dto.ProductType,
                Equipment = dto.Equipment,
                ProductionDate = dto.ProductionDate,
                LowerLimitTime = dto.LowerLimitTime,
                WarningTime = dto.WarningTime,
                OverdueTime = dto.OverdueTime
            };
        }

        private async Task<AGVResponse?> CreateAgvInboundTaskAsync(Dt_Task task, ApplyInOutDto dto)
        {
            AGVResponse response = new AGVResponse();
            var stockInfo = await _stockInfoService.GetStockInfoAsync(dto.TrayNumber);
            if (stockInfo != null)
                return response.Error($"当前托盘{dto.TrayNumber}已经入库了");

            task.TaskType = (int)TaskInboundTypeEnum.Inbound;
            task.TaskStatus = (int)TaskInStatusEnum.InNew;
            task.CurrentAddress = task.SourceAddress;

            var addResult = await BaseDal.AddDataAsync(task) > 0;
            return addResult ? null : response.Error("入库任务创建失败");
        }

        private async Task<AGVResponse?> CreateAgvOutboundTaskAsync(Dt_Task task, ApplyInOutDto dto)
        {
            AGVResponse response = new AGVResponse();
            var stockInfo = await _stockInfoService.GetStockInfoAsync(dto.TrayNumber);
            if (stockInfo == null)
                return response.Error($"未找到托盘{dto.TrayNumber}的库存信息");

            if (stockInfo.WarehouseId != dto.YinYang)
                return response.Error($"托盘{dto.TrayNumber}不属于当前{(dto.YinYang == 1 ? "阴极" : "阳极")}");

            if (stockInfo.StockStatus != (int)StockStatusEmun.入库完成)
                return response.Error($"托盘{dto.TrayNumber}正在移动中，请稍后！");

            var locationInfo = await _locationInfoService.GetLocationInfoAsync(stockInfo.LocationCode);
            if (locationInfo == null)
                return response.Error($"未找到托盘{stockInfo.LocationCode}的货位信息");

            if (locationInfo.LocationStatus != (int)LocationStatusEnum.InStock)
                return response.Error($"当前货位{locationInfo.LocationStatus}状态信息错误");

            task.TaskType = (int)TaskOutboundTypeEnum.Outbound;
            task.TaskStatus = (int)TaskOutStatusEnum.OutNew;
            task.SourceAddress = stockInfo.LocationCode;
            task.CurrentAddress = stockInfo.LocationCode;
            task.TargetAddress = dto.YinYang == 1 ? "D10020" : "D10090";

            stockInfo.StockStatus = (int)StockStatusEmun.出库锁定;
            locationInfo.LocationStatus = (int)LocationStatusEnum.InStockLock;

            _unitOfWorkManage.BeginTran();
            var addTaskResult = await BaseDal.AddDataAsync(task) > 0;
            var updateLocationResult = await _locationInfoService.UpdateLocationInfoAsync(locationInfo);
            var updateStockResult = await _stockInfoService.UpdateStockAsync(stockInfo);
            if (!addTaskResult || !updateLocationResult || !updateStockResult)
            {
                _unitOfWorkManage.RollbackTran();
                return response.Error("出库任务创建失败");
            }

            _unitOfWorkManage.CommitTran();
            return null;
        }

        private async Task<WebResponseContent> CompleteLocalOutboundAfterAgvAckAsync(Dt_Task task)
        {
            var stockInfo = await _stockInfoService.GetStockInfoAsync(task.PalletCode);
            if (stockInfo == null)
                return WebResponseContent.Instance.Error($"未找到托盘{task.PalletCode}的库存信息");

            var locationInfo = await _locationInfoService.GetLocationInfoAsync(stockInfo.LocationCode);
            if (locationInfo == null)
                return WebResponseContent.Instance.Error($"未找到托盘{stockInfo.LocationCode}的货位信息");

            if (stockInfo.StockStatus != (int)StockStatusEmun.出库锁定 || locationInfo.LocationStatus != (int)LocationStatusEnum.InStockLock)
                return WebResponseContent.Instance.Error($"当前库存{stockInfo.StockStatus}或者货位{locationInfo.LocationStatus}状态信息错误");

            locationInfo.LocationStatus = (int)LocationStatusEnum.Free;

            _unitOfWorkManage.BeginTran();
            var deleteTaskResult = BaseDal.DeleteData(task);
            var updateLocationResult = _locationInfoService.UpdateData(locationInfo);
            var deleteStockResult = _stockInfoService.DeleteData(stockInfo);
            if (!deleteTaskResult || !updateLocationResult.Status || !deleteStockResult.Status)
            {
                _unitOfWorkManage.RollbackTran();
                return WebResponseContent.Instance.Error("AGV完成回传后，本地任务/库存/货位更新失败");
            }

            _unitOfWorkManage.CommitTran();
            return WebResponseContent.Instance.OK();
        }

        private bool CanApplyEnter(Dt_Task task, ApplyEnterDto dto)
        {
            return dto.InOut == 1
                ? task.TaskType == (int)TaskInboundTypeEnum.Inbound && task.TaskStatus == (int)TaskInStatusEnum.InNew
                : task.TaskType == (int)TaskOutboundTypeEnum.Outbound && task.TaskStatus == (int)TaskStatusEnum.Line_Finish;
        }

        private async Task<AGVResponse> CompleteAgvOutboundTaskAsync(Dt_Task task)
        {
            AGVResponse response = new AGVResponse();
            var stockInfo = await _stockInfoService.GetStockInfoAsync(task.PalletCode);
            if (stockInfo == null)
                return response.Error($"未找到托盘{task.PalletCode}的库存信息");

            var locationInfo = await _locationInfoService.GetLocationInfoAsync(stockInfo.LocationCode);
            if (locationInfo == null)
                return response.Error($"未找到托盘{stockInfo.LocationCode}的货位信息");

            if (stockInfo.StockStatus != (int)StockStatusEmun.出库锁定 || locationInfo.LocationStatus != (int)LocationStatusEnum.InStockLock)
                return response.Error($"当前库存{stockInfo.StockStatus}或者货位{locationInfo.LocationStatus}状态信息错误");

            locationInfo.LocationStatus = (int)LocationStatusEnum.Free;
            task.TaskStatus = (int)TaskOutStatusEnum.OutFinish;

            _unitOfWorkManage.BeginTran();
            var deleteStockResult = _stockInfoService.DeleteData(stockInfo);
            var updateLocationResult = await _locationInfoService.UpdateLocationInfoAsync(locationInfo);
            BaseDal.DeleteAndMoveIntoHty(task, App.User.UserId == 0 ? OperateTypeEnum.自动完成 : OperateTypeEnum.人工完成);
            if (!deleteStockResult.Status || !updateLocationResult)
            {
                _unitOfWorkManage.RollbackTran();
                return response.Error("出库完成后，本地库存或货位更新失败");
            }

            _unitOfWorkManage.CommitTran();
            return response.OK();
        }

        private async Task<AGVResponse> CompleteAgvInboundTaskAsync(Dt_Task task)
        {
            AGVResponse response = new AGVResponse();
            var availableLocation = await _locationInfoService.GetLocationInfo(task.Roadway);
            if (availableLocation == null)
                return response.Error("无可用的入库货位");

                    task.TargetAddress = availableLocation.LocationCode;
                    // 通知WCS入库

                    var wcsTaskDto = _mapper.Map<WCSTaskDTO>(task);
                    var httpResponse = _httpClientHelper.Post<WebResponseContent>(WCS_ReceiveTask, JsonSerializer.Serialize(wcsTaskDto));
                    if (httpResponse == null) return aGVResponse.Error("下发WCS失败");
            if (httpResponse == null || httpResponse.Data == null || !httpResponse.Data.Status)
                return response.Error(httpResponse?.Data?.Message ?? "下发WCS失败");

                    task.TaskStatus = (int)TaskStatusEnum.Line_Executing;
                    task.Dispatchertime = DateTime.Now;

                    var locationInfo = await _locationInfoService.GetLocationInfoAsync(task.TargetAddress);
                    if (locationInfo == null) return aGVResponse.Error($"未找到托盘{task.TargetAddress}的货位信息");
                    if (locationInfo.LocationStatus != (int)LocationStatusEnum.InStock)
                    {
                        return aGVResponse.Error($"当前货位{locationInfo.LocationStatus}状态信息错误");
                    }
                    Dt_StockInfo dt_Stock = new Dt_StockInfo()
            if (locationInfo == null)
                return response.Error($"未找到托盘{task.TargetAddress}的货位信息");

            if (locationInfo.LocationStatus != (int)LocationStatusEnum.Free)
                return response.Error($"当前货位{locationInfo.LocationStatus}状态信息错误");

            Dt_StockInfo stockInfo = new Dt_StockInfo
                    {
                        PalletCode = task.PalletCode,
                        StockStatus = (int)StockStatusEmun.入库确认,
@@ -354,76 +445,64 @@
                        Creater = "AGV",
                        CreateDate = DateTime.Now
                    };

                    locationInfo.LocationStatus = (int)LocationStatusEnum.FreeLock;

                    _unitOfWorkManage.BeginTran();
                    BaseDal.UpdateData(task);
                    _locationInfoService.UpdateData(locationInfo);
                    _stockInfoService.AddData(dt_Stock);
                    _unitOfWorkManage.CommitTran();
                }
                return aGVResponse.OK();
            }
            catch (Exception ex)
            var updateTaskResult = BaseDal.UpdateData(task);
            var updateLocationResult = _locationInfoService.UpdateData(locationInfo);
            var addStockResult = _stockInfoService.AddData(stockInfo);
            if (!updateTaskResult || !updateLocationResult.Status || !addStockResult.Status)
            {
                _unitOfWorkManage.RollbackTran();
                return aGVResponse.Error($"WMS取放货完成接口错误：{ex.Message}");
            }
                return response.Error("入库完成后，本地任务、库存或货位更新失败");
        }

        /// <summary>
        /// 任务取消
        /// </summary>
        /// <param name="taskCancelDto">请求参数</param>
        /// <returns></returns>
        public async Task<AGVResponse> TaskCancelAsync(TaskCancelDto taskCancelDto)
        {
            AGVResponse aGVResponse = new AGVResponse();
            try
            {
                if (taskCancelDto == null) return aGVResponse.Error("请求参数不能为空");
                if (string.IsNullOrWhiteSpace(taskCancelDto.TaskId)) return aGVResponse.Error("任务号不能为空");
            _unitOfWorkManage.CommitTran();
            return response.OK();
        }

                var task = await BaseDal.QueryFirstAsync(x => x.OrderNo == taskCancelDto.TaskId);
                // 没有任务强制取消
                if (task == null) return aGVResponse.OK();

                if (task.TaskStatus == (int)TaskInStatusEnum.InNew)
        private AGVResponse CancelAgvInboundTask(Dt_Task task)
                {
            AGVResponse response = new AGVResponse();
                    task.TaskStatus = (int)TaskInStatusEnum.InCancel;
                    // 入库任务直接删除

                    _unitOfWorkManage.BeginTran();
                    BaseDal.DeleteAndMoveIntoHty(task, App.User.UserId == 0 ? OperateTypeEnum.自动完成 : OperateTypeEnum.人工完成);
                    _unitOfWorkManage.CommitTran();
                    return aGVResponse.OK();
            return response.OK();
                }
                else if (task.TaskStatus == (int)TaskOutStatusEnum.OutNew)

        private async Task<AGVResponse> CancelAgvOutboundTaskAsync(Dt_Task task)
                {
                    // 出库任务恢复库存
            AGVResponse response = new AGVResponse();
                    var stockInfo = await _stockInfoService.GetStockInfoAsync(task.PalletCode);
                    if (stockInfo == null) return aGVResponse.Error($"未找到托盘{task.PalletCode}的库存信息");
            if (stockInfo == null)
                return response.Error($"未找到托盘{task.PalletCode}的库存信息");

                    var locationInfo = await _locationInfoService.GetLocationInfoAsync(stockInfo.LocationCode);
                    if (locationInfo == null) return aGVResponse.Error($"未找到托盘{stockInfo.LocationCode}的货位信息");
            if (locationInfo == null)
                return response.Error($"未找到托盘{stockInfo.LocationCode}的货位信息");

                    if (stockInfo.StockStatus != (int)StockStatusEmun.出库锁定 || locationInfo.LocationStatus != (int)LocationStatusEnum.InStockLock)
                    {
                        return aGVResponse.Error($"当前库存{stockInfo.StockStatus}或者货位{locationInfo.LocationStatus}状态信息错误");
                    }
                return response.Error($"当前库存{stockInfo.StockStatus}或者货位{locationInfo.LocationStatus}状态信息错误");

                    stockInfo.StockStatus = (int)StockStatusEmun.入库完成;
                    locationInfo.LocationStatus = (int)LocationStatusEnum.InStock;
                    task.TaskStatus = (int)TaskOutStatusEnum.OutCancel;

                    _unitOfWorkManage.BeginTran();
                    _locationInfoService.UpdateData(locationInfo);
                    _stockInfoService.UpdateData(stockInfo);
            var updateLocationResult = _locationInfoService.UpdateData(locationInfo);
            var updateStockResult = _stockInfoService.UpdateData(stockInfo);
                    BaseDal.DeleteAndMoveIntoHty(task, App.User.UserId == 0 ? OperateTypeEnum.自动完成 : OperateTypeEnum.人工完成);
                    _unitOfWorkManage.CommitTran();
                    return aGVResponse.OK();
                }
                return aGVResponse.Error("任务已经在执行中，不可取消");
            }
            catch (Exception ex)
            if (!updateLocationResult.Status || !updateStockResult.Status)
            {
                _unitOfWorkManage.RollbackTran();
                return aGVResponse.Error($"WMS任务取消接口错误：{ex.Message}");
                return response.Error("出库任务取消失败");
            }

            _unitOfWorkManage.CommitTran();
            return response.OK();
        }

        #endregion 极卷库任务模块

 Code/WMS/WIDESEA_WMSServer/WIDESEA_TaskInfoService/TaskService_WCS.cs

@@ -249,8 +249,8 @@
                {
                    OutTaskCompleteDto outTaskCompleteDto = new OutTaskCompleteDto()
                    {
                        TaskId = task.OrderNo,
                        DevId = task.TargetAddress,
                        TaskId = task.OrderNo ?? string.Empty,
                        DevId = task.TargetAddress ?? string.Empty,
                        ReqTime = DateTime.Now.ToString()
                    };
                    return await OutTaskComplete(outTaskCompleteDto);
@@ -260,7 +260,7 @@
                return await ExecuteWithinTransactionAsync(async () =>
                {
                    stockInfo.LocationId = 0;
                    stockInfo.LocationCode = null;
                    stockInfo.LocationCode = string.Empty;
                    stockInfo.OutboundDate = DateTime.Now;

                    location.LocationStatus = LocationStatusEnum.Free.GetHashCode();
@@ -396,19 +396,13 @@
                    if (!updateLocationResult || !updateStockResult)
                        return WebResponseContent.Instance.Error("任务完成失败");

                    // 保存任务历史
                    var historyTask = _mapper.Map<Dt_Task_Hty>(task);
                    historyTask.InsertTime = DateTime.Now;
                    historyTask.OperateType = "空托盘入库完成";
                    if (await _task_HtyService.Repository.AddDataAsync(historyTask) <= 0)
                        return WebResponseContent.Instance.Error("任务历史保存失败");
                    var saveTaskHistoryResult = await SaveTaskHistoryAsync(task, "空托盘入库完成");
                    if (!saveTaskHistoryResult.Status)
                        return saveTaskHistoryResult;

                    // 保存库存历史
                    var historyStock = _mapper.Map<Dt_StockInfo_Hty>(stockInfo);
                    historyStock.InsertTime = DateTime.Now;
                    historyStock.OperateType = "空托盘入库完成";
                    if (await _stockInfo_HtyService.Repository.AddDataAsync(historyStock) <= 0)
                        return WebResponseContent.Instance.Error("库存历史保存失败");
                    var saveStockHistoryResult = await SaveStockHistoryAsync(stockInfo, "空托盘入库完成");
                    if (!saveStockHistoryResult.Status)
                        return saveStockHistoryResult;

                    var deleteResult = await BaseDal.DeleteDataAsync(task);
                    if (!deleteResult) return WebResponseContent.Instance.Error("任务完成失败");
@@ -483,7 +477,7 @@
                return await ExecuteWithinTransactionAsync(async () =>
                {
                    stockInfo.LocationId = 0;
                    stockInfo.LocationCode = null;
                    stockInfo.LocationCode = string.Empty;
                    stockInfo.StockStatus = StockStatusEmun.出库完成.GetHashCode();

                    location.LocationStatus = LocationStatusEnum.Free.GetHashCode();
@@ -493,19 +487,13 @@
                    if (!updateLocationResult || !updateStockResult)
                        return WebResponseContent.Instance.Error("任务完成失败");

                    // 保存任务历史
                    var historyTask = _mapper.Map<Dt_Task_Hty>(task);
                    historyTask.InsertTime = DateTime.Now;
                    historyTask.OperateType = "空托盘出库完成";
                    if (await _task_HtyService.Repository.AddDataAsync(historyTask) <= 0)
                        return WebResponseContent.Instance.Error("任务历史保存失败");
                    var saveTaskHistoryResult = await SaveTaskHistoryAsync(task, "空托盘出库完成");
                    if (!saveTaskHistoryResult.Status)
                        return saveTaskHistoryResult;

                    // 保存库存历史
                    var historyStock = _mapper.Map<Dt_StockInfo_Hty>(stockInfo);
                    historyStock.InsertTime = DateTime.Now;
                    historyStock.OperateType = "空托盘出库完成";
                    if (await _stockInfo_HtyService.Repository.AddDataAsync(historyStock) <= 0)
                        return WebResponseContent.Instance.Error("库存历史保存失败");
                    var saveStockHistoryResult = await SaveStockHistoryAsync(stockInfo, "空托盘出库完成");
                    if (!saveStockHistoryResult.Status)
                        return saveStockHistoryResult;

                    var deleteResult = await BaseDal.DeleteDataAsync(task);
                    if (!deleteResult) return WebResponseContent.Instance.Error("任务完成失败");
@@ -542,78 +530,6 @@
            {
                return WebResponseContent.Instance.Error($"修改失败: {ex.Message}");
            }
        }

        /// <summary>
        /// 查找托盘是否有任务
        /// </summary>
        /// <param name="palletCode"></param>
        /// <returns></returns>
        private async Task<WebResponseContent> GetTaskByPalletCodeAsync(string palletCode)
        {
            try
            {
                var task = await BaseDal.QueryFirstAsync(s => s.PalletCode == palletCode);
                if (task == null)
                    return WebResponseContent.Instance.Error("未找到对应的任务");
                var taskDto = _mapper.Map<WMSTaskDTO>(task);
                return WebResponseContent.Instance.OK("查询成功", taskDto);
            }
            catch (Exception ex)
            {
                return WebResponseContent.Instance.Error($"查询任务失败: {ex.Message}");
            }
        }

        /// <summary>
        /// 完成任务后统一处理（删除任务数据）
        /// </summary>
        private async Task<WebResponseContent> CompleteTaskAsync(Dt_Task task, string operateType = "")
        {
            var deleteTaskResult = await BaseDal.DeleteDataAsync(task);
            if (!deleteTaskResult) return WebResponseContent.Instance.Error("任务完成失败");

            var historyTask = _mapper.Map<Dt_Task_Hty>(task);
            historyTask.InsertTime = DateTime.Now;
            historyTask.OperateType = operateType;
            var saveResult = await _task_HtyService.Repository.AddDataAsync(historyTask) > 0;
            if (!saveResult) return WebResponseContent.Instance.Error("任务历史保存失败");

            return WebResponseContent.Instance.OK("任务完成");
        }

        /// <summary>
        /// 根据巷道确定目标地址（支持多出库口轮询）
        /// </summary>
        private string DetermineTargetAddress(string roadway, Dictionary<string, List<string>> addressMap)
        {
            if (string.IsNullOrWhiteSpace(roadway))
                return "10080";

            // 查找匹配的巷道前缀
            string matchedPrefix = null;
            foreach (var kvp in addressMap)
            {
                if (roadway.Contains(kvp.Key))
                {
                    matchedPrefix = kvp.Key;
                    break;
                }
            }

            if (matchedPrefix == null)
                return "10080";

            var addresses = addressMap[matchedPrefix];
            if (addresses == null || addresses.Count == 0)
                return "10080";

            // 单个地址，直接返回
            if (addresses.Count == 1)
                return addresses[0];

            // 多个地址，使用轮询服务
            return _roundRobinService.GetNextAddress(matchedPrefix, addresses);
        }

        /// <summary>
@@ -865,7 +781,7 @@
                    TaskNum = await BaseDal.GetTaskNo(),
                    PalletCode = palletCode,
                    PalletType = stockInfo?.PalletType ?? 0,
                    Roadway = stock.Roadway,
                    Roadway = stock.Roadway ?? string.Empty,
                    TaskType = taskType.GetHashCode(),
                    TaskStatus = TaskRobotStatusEnum.RobotNew.GetHashCode(),
                    SourceAddress = sourceLineNo,
@@ -882,7 +798,7 @@
                if (!result)
                    return WebResponseContent.Instance.Error($"机械手{taskName}任务创建失败");

                var wmstaskDto = _mapper.Map<WMSTaskDTO>(task);
                var wmstaskDto = _mapper.Map<WMSTaskDTO>(task) ?? new WMSTaskDTO();
                return WebResponseContent.Instance.OK($"机械手{taskName}任务创建成功", wmstaskDto);
            }
            catch (Exception ex)