Merge branch 'master' of http://115.159.85.185:8098/r/HuaYiZhongHeng/BaiBuLiKu

刘磊

2024-12-10 ca426532f1d63f12aaee002a014a4355341ffa9c

 Code Management/WMS/WIDESEA_WMSServer/WIDESEA_StorageTaskServices/Task/Dt_TaskService.cs

@@ -1,14 +1,22 @@

using AngleSharp.Io;
using log4net.Core;
using Mapster;
using Masuit.Tools;
using OfficeOpenXml.FormulaParsing.Excel.Functions.Math;
using SixLabors.Fonts.Tables.AdvancedTypographic;
using WIDESEA_Core.Const;
using WIDESEA_DTO.MOM;
using WIDESEA_DTO.WMS;
using WIDESEA_IServices;
using WIDESEA_IStoragIntegrationServices;
using WIDESEA_Model.Models;
using WIDESEA_Services;
using WIDESEA_StorageBasicRepository;
using WIDESEAWCS_BasicInfoRepository;
using WIDESEAWCS_Model.Models;

namespace WIDESEA_StorageOutTaskServices;
namespace WIDESEA_StorageTaskServices;

public partial class Dt_TaskService : ServiceBase<Dt_Task, IDt_TaskRepository>, IDt_TaskService
{
@@ -85,7 +93,7 @@
                    content = await _agingInOrOutInputService.GetOCVOutputAsync(agingOutputDto);
                    //ValidateResponse(content);
                    var result = JsonConvert.DeserializeObject<BasicResult>(content.Data.ToString());
                    if (!result.Success)
                    if (!result.Success || !agingOutputDto.SerialNos[0].SerialNoResult)
                    {
                        task.Remark = "NG";
                    }
@@ -94,15 +102,20 @@

            // 更新库存状态和任务状态
            (var loc, var tas) = UpdateStockAndTaskStatus(stock, task);
            var taskHty = task.Adapt<Dt_Task_Hty>();

            // 事务处理
            await _unitOfWorkManage.UseTranAsync(async () =>
            {
                if (task.TaskType != (int)TaskOutboundTypeEnum.OutQuality)
                {
                    await DeleteStockInfoAsync(stock.Id);
                    await DeleteStockInfoDetailsAsync(stock.StockInfoDetails);
                }
                await UpdateLocationAsync(loc);
                await DeleteStockInfoAsync(stock.Id);
                await DeleteStockInfoDetailsAsync(stock.StockInfoDetails);
                if (task.Roadway.Contains("FR") || task.Roadway.Contains("GW"))   //如果是分容或高温出库 将任务删除
                    await DeleteTaskAsync(task.TaskId);
                //if (task.Roadway.Contains("FR") || task.Roadway.Contains("GW") || task.TaskType == (int)TaskOutboundTypeEnum.OutTray)   //如果是分容或高温出库 将任务删除
                await DeleteTaskAsync(task.TaskId);
                await AddTaskHtyAsync(taskHty);
            });

            return content.OK("任务完成成功", task.Remark);
@@ -151,7 +164,7 @@
            {
                SlotNo = x.OrderNo.ToInt32(),
                SerialNo = x.SerialNumber,
                SerialNoResult = true,
                SerialNoResult = isNG,
                ParameterInfo = new List<ParameterInfoOutput> {
                    new ParameterInfoOutput() {
                        Value = outHours.ToString(),
@@ -161,7 +174,8 @@
                        TargetValue = parameterInfo.TargetValue,
                        LowerLomit = parameterInfo.LowerSpecificationsLimit,
                        UpperLimit = parameterInfo.UpperSpecificationsLimit,
                        DefectCode = defectCode
                        DefectCode = defectCode,
                        UOMCode = parameterInfo.UOMCode,
                    }
                }
            }).ToList()
@@ -224,6 +238,15 @@
        }
    }

    private async Task AddTaskHtyAsync(Dt_Task_Hty taskHty)
    {
        var isTaskAdd = await _task_HtyRepository.AddDataAsync(taskHty) > 0;
        if (!isTaskAdd)
        {
            throw new Exception("历史任务信息添加失败");
        }
    }

    #endregion 出库任务完成

    #region 移库任务完成
@@ -239,12 +262,12 @@
        try
        {
            // 更新货位和库存信息
            (DtStockInfo updateStock, DtLocationInfo locationInf) = UpdateStockLocation(stock, task.NextAddress);
            (DtStockInfo updateStock, DtLocationInfo locationInForm, DtLocationInfo locationInfoTo) = UpdateStockLocation(stock, task);
            var taskHty = CreateHistoricalTask(task);
            LogFactory.GetLog("任务完成").InfoFormat(true, "移库任务完成", $"货位地址：{task.TargetAddress},修改后库存数据：{JsonConvert.SerializeObject(updateStock)}，原先货位数据：{locationInf}");
            LogFactory.GetLog("任务完成").InfoFormat(true, "移库任务完成", $"货位地址：{task.TargetAddress},修改后库存数据：{JsonConvert.SerializeObject(updateStock)}，原先货位数据：{locationInForm}");

            // 执行数据库事务
            bool isResult = await ExecuteTransaction(updateStock, taskHty, locationInf, task.TaskId);
            bool isResult = await ExecuteTransaction(updateStock, taskHty, locationInForm, locationInfoTo, task.TaskId);
            if (isResult)
                content.OK("移库任务完成成功");
            else
@@ -392,9 +415,24 @@
        var loation = _locationRepository.QueryFirst(x => x.RoadwayNo == task.Roadway && x.LocationCode == task.TargetAddress);
        if (loation == null)
            throw new Exception("未找到对应位置信息");
        var area = _areaInfoRepository.QueryFirst(x => x.AreaID == loation.AreaId);
        if (area == null)
            throw new Exception("未找到对应区域信息");

        var area = new Dt_AreaInfo();
        if (task.Roadway.Contains("FR"))
        {
            area = _areaInfoRepository.QueryFirst(x => x.AreaID == loation.AreaId);
        }
        else
        {
            var station = _stationManagerRepository.QueryFirst(x => x.stationChildCode == task.SourceAddress);
            if (station.stationPLC == "1017")
                area = _areaInfoRepository.QueryFirst(x => x.AreaID == Convert.ToInt32(station.stationNGLocation));
            else
                area = _areaInfoRepository.QueryFirst(x => x.AreaID == loation.AreaId);
            if (area == null)
                throw new Exception("未找到对应区域信息");
        }


        var boxDetail = boxing.BoxingInfoDetails.Adapt<List<DtStockInfoDetail>>();
        boxDetail.ForEach(x => { x.Status = (int)StockStateEmun.已入库; });
        var stock = new DtStockInfo()
@@ -420,6 +458,7 @@
            EquipmentCode = area.Spare2,
            Software = area.Spare3
        };

        var result = _agingInOrOutInputService.GetOCVInputAsync(agingInputDto).Result;
        var respone = JsonConvert.DeserializeObject<ResponeAgingInputDto>(result.Data.ToString());
        stock.LinedProcessFeedbackTime = respone.LinedProcessFeedbackTime;
@@ -465,7 +504,6 @@
        {
            return await CompleteInToOutTaskAsync(task);
        }

        // 验证库存是否存在
        var stock = await _stockInfoRepository.QueryFirstNavAsync(x => x.PalletCode == task.PalletCode);

@@ -474,14 +512,18 @@
        {
            case (int)TaskInboundTypeEnum.Inbound:
            case (int)TaskInboundTypeEnum.InTray:
            case (int)TaskInboundTypeEnum.InNG:
                LogFactory.GetLog("任务完成").InfoFormat(true, "入库任务", "");
                return await CompleteInboundTaskAsync(task);

            case (int)TaskOutboundTypeEnum.OutTray:
            case (int)TaskOutboundTypeEnum.Outbound:
            case (int)TaskOutboundTypeEnum.OutNG:
                LogFactory.GetLog("任务完成").InfoFormat(true, "出库任务", "");
                return await CompleteStackTaskAsync(task, stock);

            case (int)TaskRelocationTypeEnum.Relocation:
                return await CompleteTransferTaskAsync(task, stock);
            default:
                return content.Error("任务类型不存在");
        }
@@ -491,12 +533,13 @@

    #region 请求任务入库

    #region
    /// <summary>
    /// 请求任务巷道
    /// </summary>
    /// <param name="input">请求模型</param>
    /// <returns>包含任务信息的响应内容</returns>
    public async Task<WebResponseContent> RequestTaskAsync(RequestTaskDto input)
    public async Task<WebResponseContent> RequestTaskAsync2(RequestTaskDto input)
    {
        // 创建一个WebResponseContent对象
        WebResponseContent content = new WebResponseContent();
@@ -542,8 +585,8 @@
            {
                Software = area.Spare3,
                TrayBarcode = input.PalletCode,
                //EquipmentCode = "EQ_CWJZ01"
                EquipmentCode = area.Spare2
                EquipmentCode = area.Spare2,
                SceneType = area.Spare4,
            };

            // 调用GetTrayCellStatusAsync方法，获取整盘电芯
@@ -558,7 +601,7 @@
                return content.Error(result.MOMMessage);

            // 获取异常电芯
            var serialNosError = result.SerialNos.Where(x => x.SerialNoStatus != 1).ToList();
            List<SerialNoDto>? serialNosError = result.SerialNos.Where(x => x.SerialNoStatus != 1).ToList();
            if (serialNosError.Count > 0)
            {
                // TODO 创建任务送至NG排出口
@@ -583,59 +626,131 @@
                content = await RequestTrayInTaskAsync(input);
                return content;
            }
            //Console.WriteLine("qqqqq");

            // TODO 获取本地料框属性与整盘电芯属性获取的值进行对比，如果一致则继续，否则返回错误信息
            //var productions = await _productionRepository.QueryDataAsync(x => result.TrayBarcodePropertys.Select(x => x.TrayBarcodeProperty).ToList().Contains(x.TrayBarcodeProperty));
            //if (productions.Count <= 0)
            //    return content.Error("料框属性不存在");

            // 调用CreateBoxingInfo方法，创建组盘信息

            var boxing = CreateBoxingInfo(result, input.PalletCode);
            //Console.WriteLine(boxing.ToJsonString());
            if (boxing == null) return content.Error("组盘失败");

            // 调用GetProcessApplyAsync方法，获取工艺路线
            ProcessApplyDto process = await GetProcessApplyAsync(result);

            // 如果process为null，则返回content
            if (process == null) return content;

            // 并赋值上位软件名称和设备编码
            process.Software = area.Spare3;
            process.EquipmentCode = area.Spare2;

            // 调用GetProcessApplyAsync方法，获取工艺申请

            // 调用_processApplyService.GetProcessApplyAsync方法，获取工艺申请
            content = await _processApplyService.GetProcessApplyAsync(process);

            // 如果状态为false，则返回null
            if (!content.Status) return content.Error("工艺申请失败");
            var resultProcessApply = JsonConvert.DeserializeObject<ResultProcessApply>(content.Data.ToString());
            if ((resultProcessApply.Success)) return content.Error("工艺申请失败");

            var par = resultProcessApply.ProcessInfo.Where(x => x.ProcessCode == boxing.ProcessCode).FirstOrDefault().Number.ToInt32();


            // 调用GetProcessResponseAsync方法，获取工艺响应
            //var processResponse = await GetProcessResponseAsync(process, input.Position);

            ////List<string> strings = input.Position == "1088" ? new List<string>() { "CHSC01" } : new List<string>() { "JZSC01" };
            Console.WriteLine(area.AreaCode+"-----------------------");
            Console.WriteLine(input.Position + "-----------------------");
            var stationManagers = _stationManagerRepository.QueryData(x => x.stationType == 1 && x.stationChildCode == input.Position && x.stationArea == area.AreaCode).ToList();
            if (stationManagers.Count <= 0)
            if (result.ProcessCode == "OCVB")
            {
                throw new Exception("未找到NG入库站台配置");
                //TODO 判断需不需要去包装，不需要就去常温三
                var stationManagers = _stationManagerRepository.QueryData(x => x.stationPLC == "1018" && x.stationArea == "Cache");
                var station = stationManagers.Select(x => x.stationChildCode).ToList();

                // 获取WCSip地址
                var configz = _configService.GetConfigsByCategory(CateGoryConst.CONFIG_SYS_IPAddress);
                var wcsBasez = configz.Where(x => x.ConfigKey == SysConfigConst.WCSIPAddress).FirstOrDefault()?.ConfigValue;
                var address = configz.Where(x => x.ConfigKey == SysConfigConst.GetStation).FirstOrDefault()?.ConfigValue;
                if (wcsBasez == null || address == null)
                {
                    throw new InvalidOperationException("WCS IP 未配置");
                }
                var wcsIpAddrss = wcsBasez + address;

                var abc = HttpHelper.PostAsync(wcsIpAddrss, station.ToJsonString()).Result;
                content = JsonConvert.DeserializeObject<WebResponseContent>(abc);
                if (content.Data.ObjToInt() > 0)
                {
                    // TODO 送至包装
                    List<string> strings = stationManagers.Where(x => x.stationType == 0).Select(x => x.Roadway).ToList();
                    content = await CreateNewTask(input, strings, 3);
                    return content;
                }
                else
                {
                    var config = _configService.GetByConfigKey("SYS_InStacker", "CW3InStacker");
                    var strings = config.ConfigValue.Split(',').ToList();
                    // TODO 入库
                    content = await CreateNewTask(input, strings);
                    if (content.Status)
                        await _boxingInfoRepository.AddDataNavAsync(boxing);
                }
            }
            List<string> strings = stationManagers.Select(x => x.Roadway).ToList();
            //// 调用CreateNewTask方法，创建新任务
            content = await CreateNewTask(input, strings);
            if (content.Status)
            else
            {
                var isBox = await _boxingInfoRepository.AddDataNavAsync(boxing);
                // TODO 获取本地料框属性与整盘电芯属性获取的值进行对比，如果一致则继续，否则返回错误信息
                //var productions = await _productionRepository.QueryDataAsync(x => result.TrayBarcodePropertys.Select(x => x.TrayBarcodeProperty).ToList().Contains(x.TrayBarcodeProperty));
                //if (productions.Count <= 0)
                //    return content.Error("料框属性不存在");

                // 调用CreateBoxingInfo方法，创建组盘信息

                //var boxing = CreateBoxingInfo(result, input.PalletCode);
                ////Console.WriteLine(boxing.ToJsonString());
                //if (boxing == null) return content.Error("组盘失败");

                // 调用GetProcessApplyAsync方法，获取工艺路线
                ProcessApplyDto process = await GetProcessApplyAsync(result);

                // 如果process为null，则返回content
                if (process == null) return content;

                // 并赋值上位软件名称和设备编码
                process.Software = area.Spare3;
                process.EquipmentCode = area.Spare2;

                // 调用GetProcessApplyAsync方法，获取工艺申请

                // 调用_processApplyService.GetProcessApplyAsync方法，获取工艺申请
                content = await _processApplyService.GetProcessApplyAsync(process);

                // 如果状态为false，则返回null
                if (!content.Status) return content.Error("工艺申请失败");

                var resultProcessApply = JsonConvert.DeserializeObject<ResultProcessApply>(content.Data.ToString());
                if (!resultProcessApply.Success) return content.Error("工艺申请失败");

                var number = resultProcessApply.ProcessInfo.Where(x => x.ProcessCode == boxing.ProcessCode).FirstOrDefault().Number.ToInt32();
                foreach (var item in resultProcessApply.ProcessInfo)
                {
                    if (item.Number.ToInt32() == number + 1)
                    {
                        boxing.NextProcessCode = item.ProcessCode;
                    }
                }
                Console.WriteLine();
                Console.WriteLine($"当前工序：{boxing.ProcessCode}");
                Console.WriteLine($"下一工序：{boxing.NextProcessCode}");

                Console.WriteLine(area.AreaCode + "-----------------------");
                Console.WriteLine(input.Position + "-----------------------");

                var areaIn = string.Empty;
                switch (boxing.NextProcessCode)
                {
                    case "CH01":
                        areaIn = "CH001";
                        break;
                    case "JZ01":
                        areaIn = "JZ001";
                        break;
                    case "GW01":
                        areaIn = "GWSC1";
                        break;
                    case "CW01":
                        areaIn = "CWSC1";
                        break;
                    case "CW02":
                        areaIn = "CWSC2";
                        break;
                    default:
                        break;
                }

                var stationManagers = _stationManagerRepository.QueryData(x => x.stationType == 1 && x.stationChildCode == input.Position && x.stationArea.Contains(areaIn)).FirstOrDefault();
                if (stationManagers == null)
                {
                    throw new Exception("未找到入库站台配置");
                }
                List<string> strings = stationManagers.Roadway.Split(',').ToList();
                Console.WriteLine(strings.ToJsonString() + "b-----------------------");
                //// 调用CreateNewTask方法，创建新任务
                content = await CreateNewTask(input, strings);
                if (content.Status)
                {
                    var isBox = await _boxingInfoRepository.AddDataNavAsync(boxing);
                }
                //}
            }
        }
        catch (Exception err)
@@ -649,6 +764,95 @@
        return content;
    }

    #endregion

    public async Task<WebResponseContent> RequestTaskAsync(RequestTaskDto input)
    {
        WebResponseContent content = new WebResponseContent();

        try
        {
            // 查询任务
            var task = await QueryTaskByPalletCode(input.PalletCode);
            if (task != null)
            {
                return CreateAndReturnWMSTaskDTO(task);
            }

            // 查询库存信息（这里后续要完善质检回库逻辑）
            var stock = await QueryStockInfo(input.PalletCode);
            if (stock != null)
            {
                Dt_Task taskNew = new Dt_Task
                {
                    Grade = 1,
                    Roadway = stock.LocationInfo.RoadwayNo,
                    TargetAddress = stock.LocationInfo.RoadwayNo,
                    Dispatchertime = DateTime.Now,
                    MaterialNo = "",
                    NextAddress = stock.LocationInfo.RoadwayNo,
                    OrderNo = null,
                    PalletCode = stock.PalletCode,
                    SourceAddress = input.Position,
                    CurrentAddress = input.Position,
                    TaskState = (int)TaskInStatusEnum.InNew,
                    TaskType = (int)TaskInboundTypeEnum.InQuality,
                    TaskNum = BaseDal.GetTaskNo().Result,
                    Creater = "System", // 修正拼写错误
                    CreateDate = DateTime.Now,
                    TaskId = 0,
                };

                var taskDTO = CreateTaskDTO(task);
                // TODO质检回库
            }

            // 根据位置查询区域信息
            var area = await QueryAreaInfoByPosition(input.Position.Replace("-1", ""));
            if (area == null)
            {
                return content.Error("该点位不在区域列表中存在");
            }

            // 创建并获取整盘电芯状态
            TrayCellsStatusDto trayCells = CreateTrayCellsStatusDto(area, input.PalletCode);
            content = await GetTrayCellStatusAsync(trayCells);
            if (!content.Status) return content;

            var result = JsonConvert.DeserializeObject<ResultTrayCellsStatus>(content.Data.ToString());
            if (!result.Success)
            {
                if (result.SerialNos.Count <= 0)
                {
                    // 空托盘入库逻辑
                    return await RequestTrayInTaskAsync(input);
                }
                else
                    return content.Error(result.MOMMessage);
            }

            // 处理异常电芯情况
            var serialNosError = result.SerialNos.Where(x => x.SerialNoStatus != 1).ToList();
            if (serialNosError.Count > 0)
            {
                return await HandleErrorCells(input, area, serialNosError);
            }


            var boxing = CreateBoxingInfo(result, input.PalletCode);
            if (boxing == null) return content.Error("组盘失败");

            return await ProcessBasedOnProcessCode(boxing, area, input, result);
        }
        catch (Exception err)
        {
            // 更详细的异常处理，可以根据异常类型记录不同的错误日志等
            content.Error(err.Message);
            Console.WriteLine(err.Message);
        }

        return content;
    }
    /// <summary>
    /// 更新任务货位
    /// </summary>
@@ -704,15 +908,16 @@
                return content.OK(data: task);
            }

            var stationManagers = _stationManagerRepository.QueryData(x => x.stationType == 1 && x.stationChildCode == input.Position).ToList();
            if (stationManagers.Count <= 0)

            var stationManagers = _stationManagerRepository.QueryData(x => x.stationType == 6 && x.stationChildCode == input.Position).FirstOrDefault();
            if (stationManagers == null)
            {
                throw new Exception("未找到空托盘入库站台配置");
                stationManagers = _stationManagerRepository.QueryData(x => x.stationType == 1 && x.stationChildCode == input.Position).FirstOrDefault();
                if (stationManagers == null)
                    throw new Exception("未找到空托盘入库站台和入库站台配置");
            }


            // 获取目标地址
            List<string> strings = stationManagers.Select(x => x.Roadway).ToList();
            List<string> strings = stationManagers.Roadway.Split(',').ToList();
            Console.WriteLine(strings.ToJsonString() + "b-----------------------");

            return await CreateNewTask(input, strings, 1);
        }
@@ -775,15 +980,15 @@
    /// <param name="areaCode">区域编码</param>
    /// <param name="roadways">巷道编码集合</param>
    /// <returns>返回结果集</returns>
    public async Task<WebResponseContent> RequestTrayOutTaskAsync(string position, int tag, string areaCode, List<string> roadways)
    public async Task<WebResponseContent> RequestTrayOutTaskAsync(string position, int tag, string areaCode, string productionLine)
    {
        WebResponseContent content = new WebResponseContent();
        try
        {
            // 根据托盘类型查询库存信息
            DtStockInfo stockInfo = tag == (int)TaskOutboundTypeEnum.Outbound
                ? QueryStockInfoForRealTrayAsync(areaCode, roadways).Result
                : QueryStockInfoForEmptyTrayAsync(areaCode, roadways).Result;
                ? QueryStockInfoForRealTrayAsync(areaCode, productionLine).Result
                : QueryStockInfoForEmptyTrayAsync(areaCode).Result;

            if (stockInfo == null)
            {
@@ -830,7 +1035,7 @@
    /// <summary>
    /// 查询实盘库存信息
    /// </summary>
    private async Task<DtStockInfo> QueryStockInfoForRealTrayAsync(string areaCode, List<string> roadways)
    private async Task<DtStockInfo> QueryStockInfoForRealTrayAsync(string areaCode, string productionLine)
    {
        var area = await _areaInfoRepository.QueryFirstAsync(x => x.AreaCode == areaCode);

@@ -838,6 +1043,7 @@
            .Includes(x => x.LocationInfo) // 预加载LocationInfo
            .Includes(x => x.StockInfoDetails) // 预加载StockInfoDetails
            .Where(x => x.AreaCode == areaCode && x.OutboundTime < DateTime.Now && x.IsFull == true) // 过滤条件
            .WhereIF(!productionLine.IsNullOrEmpty(), x => x.ProductionLine == productionLine)
            .Where(x => x.LocationInfo.LocationStatus == (int)LocationEnum.InStock && x.LocationInfo.AreaId == area.AreaID) // 过滤条件
            .OrderBy(x => x.OutboundTime) // 排序
            .FirstAsync(); // 获取第一个元素
@@ -851,7 +1057,7 @@
    /// <summary>
    /// 查询空盘库存信息
    /// </summary>
    private async Task<DtStockInfo> QueryStockInfoForEmptyTrayAsync(string areaCode, List<string> roadways)
    private async Task<DtStockInfo> QueryStockInfoForEmptyTrayAsync(string areaCode)
    {
        var area = await _areaInfoRepository.QueryFirstAsync(x => x.AreaCode == areaCode);

@@ -887,7 +1093,7 @@
            SourceAddress = stockInfo.LocationCode,
            CurrentAddress = stockInfo.LocationCode,
            TaskState = (int)TaskOutStatusEnum.OutNew,
            TaskType = tag == (int)TaskOutboundTypeEnum.Outbound ? (int)TaskOutboundTypeEnum.Outbound : (int)TaskOutboundTypeEnum.OutTray,
            TaskType = tag,
            TaskNum = BaseDal.GetTaskNo().Result,
            Creater = "System", // 修正拼写错误
            CreateDate = DateTime.Now,
@@ -989,6 +1195,84 @@
            content.Error(ex.Message);
        }
        return content;
    }

    #endregion

    #region 指定任务出库

    public async Task<WebResponseContent> CreateAndSendOutboundTask(string locationCode, string palletCode)
    {
        WebResponseContent content = new WebResponseContent();
        try
        {
            // 查询库存信息
            var stockInfo = await _stockInfoRepository.QueryFirstNavAsync(x => x.LocationCode == locationCode && x.PalletCode == palletCode);
            if (stockInfo == null)
            {
                return content.Error("未查询到对应的库存信息");
            }

            var task = await BaseDal.QueryFirstAsync(x => x.PalletCode == palletCode);
            if (task != null)
            {
                return content.Error($"【{palletCode}】已存在任务");
            }

            int taskType = 0;
            if (stockInfo.IsFull)
                taskType = (int)TaskOutboundTypeEnum.OutQuality;
            else
                taskType = (int)TaskOutboundTypeEnum.OutTray;
            // 创建并添加任务到数据库
            task = CreateTask(stockInfo, "1020-1", taskType);
            //var taskId = await BaseDal.AddDataAsync(task);
            //if (taskId <= 0)
            //{
            //    return content.Error("任务创建失败");
            //}

            // 创建任务传输用的DTO对象
            var taskDTO = CreateTaskDTO(task);

            // 获取WMS IP地址用于发送任务请求
            var wmsIpAddress = GetWCSIpReceiveTask();
            if (wmsIpAddress == null)
            {
                throw new InvalidOperationException("WMS IP 未配置");
            }

            var tasks = new List<WMSTaskDTO>() { taskDTO };
            // 发送任务请求到WMS
            var result = await HttpHelper.PostAsync(wmsIpAddress, tasks.ToJsonString());
            content = JsonConvert.DeserializeObject<WebResponseContent>(result);
            if (content.Status)
            {
                // 添加任务到数据库
                await BaseDal.AddDataAsync(task);
                // 更新库存位置状态为不可用
                stockInfo.LocationInfo.LocationStatus = (int)LocationEnum.InStockDisable;
                await _locationRepository.UpdateDataAsync(stockInfo.LocationInfo);
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"发生异常: {ex.Message}");
            content.Error(ex.Message);
        }

        return content;
    }
    private string GetWCSIpReceiveTask()
    {
        var configs = _configService.GetConfigsByCategory(CateGoryConst.CONFIG_SYS_IPAddress);
        var wmsBase = configs.FirstOrDefault(x => x.ConfigKey == SysConfigConst.WCSIPAddress)?.ConfigValue;
        var ipAddress = configs.FirstOrDefault(x => x.ConfigKey == SysConfigConst.ReceiveTask)?.ConfigValue;
        if (wmsBase == null || ipAddress == null)
        {
            return null;
        }
        return wmsBase + ipAddress;
    }

    #endregion
@@ -1168,20 +1452,19 @@
    /// <param name="stock">库存对象</param>
    /// <param name="toLocation">目标位置</param>
    // 更新库存和位置信息
    private (DtStockInfo, DtLocationInfo) UpdateStockLocation(DtStockInfo stock, string toLocation)
    private (DtStockInfo, DtLocationInfo, DtLocationInfo) UpdateStockLocation(DtStockInfo stock, Dt_Task task)
    {
        // 获取库存信息
        var locationInfo = _locationRepository.QueryFirst(x => x.LocationCode == stock.LocationCode);
        // 将库存状态设置为在库
        locationInfo.LocationStatus = LocationEnum.InStock.ObjToInt();
        //修改来源库位和 目标库位状态
        var fromLocation = _locationRepository.QueryFirst(x => x.LocationCode == task.SourceAddress && x.RoadwayNo == task.Roadway);
        fromLocation.LocationStatus = LocationEnum.Free.ObjToInt();
        var toLocation = _locationRepository.QueryFirst(x => x.LocationCode == task.SourceAddress && x.RoadwayNo == task.Roadway);
        toLocation.LocationStatus = LocationEnum.InStock.ObjToInt();

        // 将库存位置设置为目标位置
        stock.LocationCode = toLocation;
        // 将库存状态设置为在库
        stock.LocationInfo.LocationStatus = LocationEnum.InStock.ObjToInt();
        stock.LocationCode = task.TargetAddress;

        // 返回更新后的库存和位置信息
        return (stock, locationInfo);
        return (stock, fromLocation, toLocation);
    }

    /// <summary>
@@ -1214,6 +1497,18 @@
                                            .ExecuteCommandAsync();
                }

            }

            var stocks = _stockInfoRepository.QueryData(x => x.AreaCode == stock.AreaCode && x.ProductionLine == stock.ProductionLine && x.SpecialParameterDuration != stock.SpecialParameterDuration);
            if (stocks != null && stocks.Count > 0)
            {
                foreach (var item in stocks)
                {
                    item.SpecialParameterDuration = stock.SpecialParameterDuration;
                    item.ParameterInfos = stock.ParameterInfos;
                    item.OutboundTime = Convert.ToDateTime(item.LinedProcessFeedbackTime == null ? item.CreateDate : item.LinedProcessFeedbackTime).AddHours(Convert.ToDouble(stock.SpecialParameterDuration));
                }
                var isUpdates = await _stockInfoRepository.UpdateDataAsync(stocks);
            }

            // 添加历史任务
@@ -1270,6 +1565,16 @@
                task.CurrentAddress = input.Position;
                task.TargetAddress = "002-021-000";
                task.NextAddress = "002-021-000";
                task.TaskState = (int)TaskInStatusEnum.Line_InFinish;
                bool isResult = await BaseDal.UpdateDataAsync(task);
                return content.OK(data: task);
            }
            else if (task.TaskType == (int)TaskInboundTypeEnum.InQuality)
            {
                var stockInfo = _stockInfoRepository.QueryFirst(x => x.PalletCode == input.PalletCode);
                task.CurrentAddress = input.Position;
                task.TargetAddress = stockInfo.LocationInfo.LocationCode;
                task.NextAddress = stockInfo.LocationInfo.LocationCode;
                task.TaskState = (int)TaskInStatusEnum.Line_InFinish;
                bool isResult = await BaseDal.UpdateDataAsync(task);
                return content.OK(data: task);
@@ -1348,8 +1653,8 @@
    /// 创建新任务
    /// </summary>
    /// <param name="input">请求模型</param>
    /// <param name="areaId">区域ID</param>
    /// <param name="content">响应内容</param>
    /// <param name="process">巷道</param>
    /// <param name="flag">标识（0-入库，1-空托盘入库，2-NG入库，3-出库）</param>
    /// <returns></returns>
    private async Task<WebResponseContent> CreateNewTask(RequestTaskDto input, List<string> process = null, int flag = 0)
    {
@@ -1358,8 +1663,8 @@
        // 获取目标地址
        //string ToAddress = await GetRoadWayAsync(process);
        string ToAddress = string.Empty;
        if (flag != 2)
            ToAddress = await GetRoadWayAsync(input, process);
        if (flag < 2)
            ToAddress = await GetRoadWayAsync(process);
        else
            ToAddress = process[0];

@@ -1376,8 +1681,8 @@
            OrderNo = null,
            PalletCode = input.PalletCode,
            SourceAddress = input.Position,
            TaskState = (int)TaskInStatusEnum.InNew,
            TaskType = flag == 0 ? (int)TaskInboundTypeEnum.Inbound : flag == 1 ? (int)TaskInboundTypeEnum.InTray : (int)TaskInboundTypeEnum.InNG,
            TaskState = flag == 3 ? (int)TaskOutStatusEnum.OutNew : (int)TaskInStatusEnum.InNew,
            TaskType = flag == 0 ? (int)TaskInboundTypeEnum.Inbound : flag == 1 ? (int)TaskInboundTypeEnum.InTray : flag == 2 ? (int)TaskInboundTypeEnum.InNG : (int)TaskOutboundTypeEnum.Outbound,
            TaskNum = await BaseDal.GetTaskNo(),
            Creater = "Systeam"
        };
@@ -1389,6 +1694,11 @@
        {
            task.TaskId = taskId;
            isResult = await _taskExecuteDetailRepository.AddDetailAsync(task, false, TaskDescription.GetTaskUpdateDescription(input.PalletCode, input.Position, ToAddress, TaskInStatusEnum.InNew.GetIntegralRuleTypeEnumDesc()));

            //var location = _locationRepository.QueryFirst(x => x.RoadwayNo == task.Roadway && x.LocationCode == task.TargetAddress);
            //location.LocationStatus = (int)LocationEnum.Lock;
            //var isLocation = _locationRepository.UpdateData(location);

            if (isResult)
            {
                // 创建WMS任务
@@ -1453,27 +1763,30 @@
    }

    /// <summary>
    /// 获取巷道或站台
    /// 根据巷道获取巷道或站台
    /// </summary>
    /// <param name="areaId">货位区域ID</param>
    /// <param name="position">站台</param>
    /// <param name="Direction">方向</param>
    /// <param name="area">关系区域</param>
    /// <returns></returns>
    public async Task<string> GetRoadWayAsync(RequestTaskDto input, List<string> process)
    public async Task<string> GetRoadWayAsync(List<string> process)
    {
        var minGroup = _locationRepository.QueryData(x => process.Contains(x.RoadwayNo) && x.LocationStatus == (int)LocationEnum.Free)
             .GroupBy(x => x.RoadwayNo)
             .OrderByDescending(g => g.Count()) // 根据每个组的元素数量排序
             .First(); // 取出数量最多的组
             .ToList(); // 取出数量最多的组

        string minRoadwayNo = minGroup.Key; // 数量最多的组的Key
        Dictionary<string, int> result = new Dictionary<string, int>();
        foreach (var item in minGroup)
        {
            var number = BaseDal.QueryData(x => x.TargetAddress == item.Key).Count();
            result.Add(item.Key, item.Count() - number);
        }

        string minRoadwayNo = result.OrderByDescending(x => x.Value).FirstOrDefault().Key; // 数量最多的组的Key

        return minRoadwayNo;
    }

    /// <summary>
    /// 获取巷道或站台
    /// 根据区域获取巷道或站台
    /// </summary>
    /// <returns></returns>
    public async Task<string> GetRoadWayAsync(int areaCode)
@@ -1481,9 +1794,16 @@
        var minGroup = _locationRepository.QueryData(x => x.AreaId == areaCode && x.LocationStatus == (int)LocationEnum.Free)
            .GroupBy(x => x.RoadwayNo)
             .OrderBy(g => g.Count()) // 根据每个组的元素数量排序
             .First(); // 取出数量最少的组
             .ToList(); // 取出数量最少的组

        string minRoadwayNo = minGroup.Key; // 数量最少的组的Key
        Dictionary<string, int> result = new Dictionary<string, int>();
        foreach (var item in minGroup)
        {
            var number = BaseDal.QueryData(x => x.TargetAddress == item.Key).Count();
            result.Add(item.Key, item.Count() - number);
        }

        string minRoadwayNo = result.OrderByDescending(x => x.Value).FirstOrDefault().Key; // 数量最多的组的Key

        return minRoadwayNo;
    }