test

pengmn

2025-06-24 51141e4955e3021058664bea526f16b368738b3a

 HH.WCS.Mobox3.HangYang/process/TaskProcess.cs

@@ -12,6 +12,7 @@
using Swashbuckle.Swagger;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Security.Cryptography;
@@ -373,9 +374,9 @@
        }

        /// <summary>
        /// 入库单新增
        /// 杭氧物料主数据新增接口
        /// </summary>
        /// <param name="model">入库单</param>
        /// <param name="model">物料主数据</param>
        /// <returns></returns>
        public static Result GetMaterialData(List<MES_Material> model)
        {
@@ -384,44 +385,25 @@
            {
                if (model == null)
                {
                    result.errMsg = "入库单不可为空值！";
                    result.errMsg = "物料主数据不可为空值！";
                    return result;
                }
                var materialList = new List<TN_Material>();

                //foreach (var item in model.InOrderDetail)
                //{
                //    var itemType = WMSHelper.GetItemType(item.S_ITEM_CODE);
                //    if (itemType == null)
                //    {
                //        result.errMsg = $"未查询到物料{item.S_ITEM_CODE}的物料属性！";
                //        return result;
                //    }
                //    item.S_EXT_ATTR1 = itemType.S_ITEM_TYPE;
                //}

                //var groupedInOrders = model.InOrderDetail
                //                      .GroupBy(detail => detail.S_EXT_ATTR1) // 按物料属性分组
                //                      .Select((group, index) => new InOrder
                //                      {
                //                          S_NO = $"{model.S_BS_NO}_{index + 1}", // 拼接来源单号
                //                          S_BS_NO = model.S_BS_NO,
                //                          S_OP_TYPE = model.S_OP_TYPE,
                //                          S_BS_TYPE = model.S_BS_TYPE,
                //                          S_NOTE = model.S_NOTE,
                //                          InOrderDetail = group.Select(detail =>
                //                          {
                //                              // 修改 group 中的 S_IO_NO 字段为 S_NO 的值
                //                              detail.S_IO_NO = $"{model.S_BS_NO}_{index + 1}";
                //                              detail.S_BS_NO = model.S_BS_NO;
                //                              return detail;
                //                          }).ToList() // 分组后的明细
                //                      })
                //                      .ToList();
                //var res = WMSHelper.CreateOrderIn(groupedInOrders);
                //if (res)
                //{
                //    result.success = true;
                //}
                foreach (var item in model)
                {
                    materialList.Add(new TN_Material
                    {
                        S_ITEM_CODE = item.S_ITEM_CODE,
                        S_ITEM_NAME = item.S_ITEM_NAME,
                        S_ITEM_TYPE = item.S_AREA_CODE,
                        S_ITEM_SPEC = item.S_MATERIAL_SPEC,
                        S_MATERIAL = item.S_MATERIAL,
                        S_UOM = item.S_UOM,
                        C_CLEAN = item.C_CLEAN,
                    });
                }
                WMSHelper.CreateMaterialData(materialList);
                return result;
            }
            catch (Exception ex)
@@ -432,7 +414,7 @@
                var frame = st.GetFrame(0); // 获取第一个堆栈帧
                if (frame != null)
                {
                    LogHelper.Error($"GetInboundOrder入库单新增出现错误！！", ex);
                    LogHelper.Error($"GetMaterialData物料主数据新增出现错误！！", ex);
                    LogHelper.Error($"文件名: {frame.GetFileName()}", ex);
                    LogHelper.Error($"行号: {frame.GetFileLineNumber()}", ex);
                    LogHelper.Error($"列号: {frame.GetFileColumnNumber()}", ex);
@@ -443,7 +425,7 @@
        }

        /// <summary>
        /// 入库单新增
        /// 入库单新增以及修改
        /// </summary>
        /// <param name="model">入库单</param>
        /// <returns></returns>
@@ -517,9 +499,9 @@
        }

        /// <summary>
        /// 出库单新增
        /// 出库单新增以及修改
        /// </summary>
        /// <param name="model">入库单</param>
        /// <param name="model">出库单</param>
        /// <returns></returns>
        public static Result GetOutboundOrder(OutOrder model)
        {
@@ -598,6 +580,85 @@
                return result;
            }
        }

        /// <summary>
        /// 入库单取消
        /// </summary>
        /// <param name="model">入库单</param>
        /// <returns></returns>
        public static Result CancelInboundOrder(InOrder model)
        {
            Result result = new Result() { success = false, };
            try
            {
                if (model == null || !model.OrderDetail.Any())
                {
                    result.errMsg = "入库单取消不可为空值！";
                    return result;
                }
                var res = WMSHelper.CancelOrderIn(model);
                if (res)
                {
                    result.success = true;
                }
                return result;
            }
            catch (Exception ex)
            {
                result.success = false;
                result.errMsg = ex.Message;
                var st = new System.Diagnostics.StackTrace(ex, true);
                var frame = st.GetFrame(0); // 获取第一个堆栈帧
                if (frame != null)
                {
                    LogHelper.Error($"CancelInboundOrder入库单取消出现错误！！", ex);
                    LogHelper.Error($"文件名: {frame.GetFileName()}", ex);
                    LogHelper.Error($"行号: {frame.GetFileLineNumber()}", ex);
                    LogHelper.Error($"列号: {frame.GetFileColumnNumber()}", ex);
                }
                return result;
            }
        }

        /// <summary>
        /// 出库单取消
        /// </summary>
        /// <param name="model">出库单</param>
        /// <returns></returns>
        public static Result CancelOutboundOrder(OutOrder model)
        {
            Result result = new Result() { success = false };
            try
            {
                if (model == null || !model.OrderDetail.Any())
                {
                    result.errMsg = "出库单不可为空值！";
                    return result;
                }
                var res = WMSHelper.CancelOrderOut(model);
                if (res)
                {
                    result.success = true;
                }
                return result;
            }
            catch (Exception ex)
            {
                result.success = false;
                result.errMsg = ex.Message;
                var st = new System.Diagnostics.StackTrace(ex, true);
                var frame = st.GetFrame(0);
                if (frame != null)
                {
                    LogHelper.Error($"CancelOutboundOrder出库单取消出现错误！", ex);
                    LogHelper.Error($"文件名: {frame.GetFileName()}", ex);
                    LogHelper.Error($"行号: {frame.GetFileLineNumber()}", ex);
                    LogHelper.Error($"列号: {frame.GetFileColumnNumber()}", ex);
                }
                return result;
            }
        }


        ///// <summary>
        ///// 获取作业创建入库任务
@@ -924,12 +985,12 @@
        /// </summary>
        /// <param name="mst"></param>
        /// <returns></returns>
        internal static bool CreateInTask(WMSTask mst)
        internal static async Task<bool> CreateInTask(WMSTask mst)
        {
            try
            {
                if (mst.S_B_STATE.Trim() != "等待") return true;
                if (string.IsNullOrEmpty(mst.S_START_LOC)) return false;
                //if (string.IsNullOrEmpty(mst.S_START_LOC)) return false;

                var reservoirs = Settings.ReservoirAreas?.ToList();
                if (reservoirs == null || !reservoirs.Any())
@@ -947,7 +1008,13 @@
                    case "合托回库":
                        return HandleMergeReturn(mst, reservoirs);
                    case "分拣回库":
                        return HandleMergeReturn(mst, reservoirs);
                        return await SortingReturn(mst, reservoirs);
                    case "解绑回库":
                        return await UnbindReturn(mst, reservoirs);
                    case "空托回库":
                        return await EmptyPalletReturn(mst, reservoirs);
                    case "空托出库":
                        return EmptyPalletOutbound(mst);
                    case "料箱出库":
                        return HandleBoxOutbound(mst, reservoirs);
                    case "发货暂存":
@@ -1135,7 +1202,7 @@
        }

        /// <summary>
        /// 合托回库 || 分拣回库
        /// 合托回库
        /// </summary>
        /// <param name="mst"></param>
        /// <param name="reservoirs"></param>
@@ -1237,6 +1304,218 @@
                }
            }
            return true;
        }

        /// <summary>
        /// 分拣回库
        /// </summary>
        /// <param name="mst"></param>
        /// <param name="reservoirs"></param>
        /// <returns></returns>
        private static async Task<bool> SortingReturn(WMSTask mst, List<ReservoirArea> reservoirs)
        {
            var trayLst = ContainerHelper.GetCntr(mst.S_CNTR_CODE);
            if (trayLst != null && trayLst.S_TYPE.Equals("托盘"))
            {
                //托盘分拣回库
                var area = reservoirs.Where(s => s.areaName == "入库接驳位").FirstOrDefault();
                if (area == null)
                {
                    LogHelper.Info("Settings出现错误未查询到入库接驳位！", "杭氧");
                    return false;
                }
                //(2.1)先查询入库接驳位是否为空，如果为空直接生成到入库的任务
                var anyLoc = LocationHelper.GetLocAreaList(area.areaCode);
                if (anyLoc.Any())
                {
                    //生成到接驳位的任务
                    var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, anyLoc.FirstOrDefault().S_CODE, "托盘分拣回库", mst.S_CNTR_CODE, mst.S_CODE);
                    if (!res)
                    {
                        LogHelper.Info("托盘分拣回库任务创建失败！", "杭氧");
                        return false;
                    }
                    WMSHelper.UpdateStatus(mst, 1);
                }
            }
            else
            {
                //料箱回库
                var inbound = new Inbound()
                {
                    areaCode = "LXLKQ"
                };
                var wh = new Warehouse(inbound);
                var stored = await wh.StoreItemAsync();
                if (stored == null)
                {
                    LogHelper.Info($"未查询到{inbound.areaCode}可用货位！", "杭氧");
                    return false;
                }
                
                var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, stored.loationCode, "料箱分拣回库" , mst.S_CNTR_CODE, mst.S_CODE);
                if (!res)
                {
                    LogHelper.Info("料箱分拣回库任务创建失败！", "杭氧");
                    return false;
                }
                WMSHelper.UpdateStatus(mst, 1);
            }
            return true;
        }

        /// <summary>
        /// 解绑回库
        /// </summary>
        /// <param name="mst"></param>
        /// <param name="reservoirs"></param>
        /// <returns></returns>
        private static async Task<bool> UnbindReturn(WMSTask mst, List<ReservoirArea> reservoirs)
        {
            var trayLst = ContainerHelper.GetCntr(mst.S_CNTR_CODE);
            if (trayLst != null && trayLst.S_TYPE.Equals("托盘"))
            {
                //托盘分拣回库
                var area = reservoirs.Where(s => s.areaName == "入库接驳位").FirstOrDefault();
                if (area == null)
                {
                    LogHelper.Info("Settings出现错误未查询到入库接驳位！", "杭氧");
                    return false;
                }
                //(2.1)先查询入库接驳位是否为空，如果为空直接生成到入库的任务
                var anyLoc = LocationHelper.GetLocAreaList(area.areaCode);
                if (anyLoc.Any())
                {
                    //生成到接驳位的任务
                    var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, anyLoc.FirstOrDefault().S_CODE, "托盘解绑回库", mst.S_CNTR_CODE, mst.S_CODE);
                    if (!res)
                    {
                        LogHelper.Info("托盘解绑回库任务创建失败！", "杭氧");
                        return false;
                    }
                    WMSHelper.UpdateStatus(mst, 1);
                }
            }
            else
            {
                //料箱回库
                var inbound = new Inbound()
                {
                    areaCode = "LXLKQ"
                };
                var wh = new Warehouse(inbound);
                var stored = await wh.StoreItemAsync();
                if (stored == null)
                {
                    LogHelper.Info($"未查询到{inbound.areaCode}可用货位！", "杭氧");
                    return false;
                }

                var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, stored.loationCode, "料箱解绑回库", mst.S_CNTR_CODE, mst.S_CODE);
                if (!res)
                {
                    LogHelper.Info("料箱解绑回库任务创建失败！", "杭氧");
                    return false;
                }
                WMSHelper.UpdateStatus(mst, 1);
            }
            return true;
        }

        /// <summary>
        /// 空托回库
        /// </summary>
        /// <param name="mst"></param>
        /// <param name="reservoirs"></param>
        /// <returns></returns>
        private static async Task<bool> EmptyPalletReturn(WMSTask mst, List<ReservoirArea> reservoirs)
        {
            var trayLst = ContainerHelper.GetCntr(mst.S_CNTR_CODE);
            if (trayLst != null && trayLst.S_TYPE.Equals("托盘"))
            {
                //托盘空托回库
                var area = reservoirs.Where(s => s.areaName == "入库接驳位").FirstOrDefault();
                if (area == null)
                {
                    LogHelper.Info("Settings出现错误未查询到入库接驳位！", "杭氧");
                    return false;
                }
                //(2.1)先查询入库接驳位是否为空，如果为空直接生成到入库的任务
                var anyLoc = LocationHelper.GetLocAreaList(area.areaCode);
                if (anyLoc.Any())
                {
                    //生成到接驳位的任务
                    var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, anyLoc.FirstOrDefault().S_CODE, "托盘空托回库", mst.S_CNTR_CODE, mst.S_CODE);
                    if (!res)
                    {
                        LogHelper.Info("托盘空托回库任务创建失败！", "杭氧");
                        return false;
                    }
                    WMSHelper.UpdateStatus(mst, 1);
                }
            }
            else
            {
                //料箱空托回库
                var inbound = new Inbound()
                {
                    areaCode = "LXLKQ"
                };
                var wh = new Warehouse(inbound);
                var stored = await wh.StoreItemAsync();
                if (stored == null)
                {
                    LogHelper.Info($"未查询到{inbound.areaCode}可用货位！", "杭氧");
                    return false;
                }

                var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, stored.loationCode, "料箱空托回库", mst.S_CNTR_CODE, mst.S_CODE);
                if (!res)
                {
                    LogHelper.Info("料箱空托回库任务创建失败！", "杭氧");
                    return false;
                }
                WMSHelper.UpdateStatus(mst, 1);
            }
            return true;
        }

        /// <summary>
        /// 空托出库
        /// </summary>
        /// <param name="mst"></param>
        /// <param name="reservoirs"></param>
        /// <returns></returns>
        private static bool EmptyPalletOutbound(WMSTask mst)
        {
            var result = true;
            var scheduler = new EmptyPalletOutboundScheduler(mst.S_START_AREA);

            var outbound = new Outbound
            {
                endArea = mst.S_END_AREA,
                endBit = mst.S_END_LOC,
                requiredCount = 1,
                taskType = "空托出库"
            };
            // 请求出库
            var tasks = scheduler.GenerateEmptyPalletTasks(outbound);

            foreach (var item in tasks)
            {
                // 创建出库任务
                var res = TaskProcess.HYCreateTransport(item.S_START_LOC, item.S_END_LOC, item.S_TYPE, item.S_CNTR_CODE, mst.S_CODE);
                mst.S_START_LOC = item.S_START_LOC;
                mst.S_CNTR_CODE  = item.S_CNTR_CODE;
                //修改空托出库起点和托盘码
                UpdateTask(mst,1);
                if (!res)
                {
                    LogHelper.Info($"根据配盘单生成出库任务创建出库任务失败！！");
                    return false;
                }
            }
            return result;
        }

        /// <summary>
@@ -1370,18 +1649,262 @@
            if (locList.Any())
            {
                var startLoc = WMSHelper.GetCntrLoc(mst.S_CNTR_CODE);
                // 创建出库任务
                var res = TaskProcess.HYCreateTransport(startLoc.S_LOC_CODE, locList.FirstOrDefault().S_CODE, mst.S_TYPE, mst.S_CNTR_CODE, mst.S_CODE);
                if (!res)
                if (startLoc != null)
                {
                    LogHelper.Info($"根据配盘单生成出库任务创建出库任务失败！！");
                    return false;
                    // 创建出库任务
                    var res = TaskProcess.HYCreateTransport(startLoc.S_LOC_CODE, locList.FirstOrDefault().S_CODE, mst.S_TYPE, mst.S_CNTR_CODE, mst.S_CODE);
                    if (!res)
                    {
                        LogHelper.Info($"根据配盘单生成出库任务创建出库任务失败！！");
                        return false;
                    }
                }
                
            }

            return true;
        }

        #endregion

        #region WCS调用接口

        /// <summary>
        /// WCS调用设备信号反馈
        /// </summary>
        /// <param name="model">请求参数</param>
        /// <returns></returns>
        public static async Task<WcsResult> notifyDeviceSignal(List<WcsModel> model)
        {
            WcsResult result = new WcsResult() { code = 1, };
            try
            {
                foreach (var item in model)
                {
                    if (string.IsNullOrEmpty(item.cntrNo))
                    {
                        result.msg = "托盘号为空！";
                        return result;
                    }
                    var list = WMSHelper.GetWmsTaskList("等待", item.cntrNo);
                    if (list == null)
                    {
                        list = WMSHelper.GetWmsTaskList("执行", item.cntrNo);
                        if (list != null && list.S_TYPE.Contains("回库"))
                        {
                            list.S_END_AREA = "TPLKQ";
                        }
                    }
                    if (list == null)
                    {
                        result.msg = "未查询到在等待中的作业！";
                        return result;
                    }

                    var inbound = new Inbound()
                    {
                        areaCode = list.S_END_AREA
                    };
                    var wh = new Warehouse(inbound);
                    var stored = await wh.StoreItemAsync();
                    if (stored == null)
                    {
                        result.msg = "立库区未查询到可用货位！";
                        return result;
                    }

                    var startLoc = ContainerHelper.GetCntrLoc(list.S_CNTR_CODE);
                    if (startLoc == null)
                    {
                        result.msg = $"未查询到托盘{list.S_CNTR_CODE}所在的货位！";
                        return result;
                    }
                    var res = TaskProcess.HYCreateTransport(startLoc.S_LOC_CODE, stored.loationCode, list.S_B_STATE == "等待" ? "料箱入库" : "托盘入库", list.S_CNTR_CODE, list.S_CODE);
                    if (!res)
                    {
                        result.msg = "入库任务创建失败！";
                        return result;
                    }
                    WMSHelper.UpdateTaskStatus(list.S_CODE, 1);
                    ContainerHelper.UpdateCntrAbouts(list.S_CNTR_CODE, "");
                }
                result.code = 0;
                return result;
            }
            catch (Exception ex)
            {
                result.code = 2;
                result.msg = ex.Message;
                var st = new System.Diagnostics.StackTrace(ex, true);
                var frame = st.GetFrame(0); // 获取第一个堆栈帧
                if (frame != null)
                {
                    LogHelper.Error($"notifyDeviceSignal设备信号反馈出现错误！！", ex);
                    LogHelper.Error($"文件名: {frame.GetFileName()}", ex);
                    LogHelper.Error($"行号: {frame.GetFileLineNumber()}", ex);
                    LogHelper.Error($"列号: {frame.GetFileColumnNumber()}", ex);
                }
                return result;
            }
        }

        /// <summary>
        /// WCS调用任务状态反馈
        /// </summary>
        /// <param name="model">请求参数</param>
        /// <returns></returns>
        public static async Task<WcsResult> notifyTaskStatus(WcsTaskModel model)
        {
            WcsResult result = new WcsResult() { code = 1, };
            try
            {
                if (model == null)
                {
                    result.msg = "请求参数为空";
                    return result;
                }

                var task = WCSHelper.GetTask(model.taskNo);
                if (task == null)
                {
                    result.msg = "未查询到任务号";
                    return result;
                } 

                // 状态与操作的映射字典
                var stateActions = new Dictionary<int, Action>
                {
                    [1] = () => WCSHelper.Begin(task),
                    [2] = () => HandleTaskCompletion(task),
                    [3] = () => WCSHelper.UpdateStatus(task, "开始取货"),
                    [4] = () => HandlePickCompletion(task),
                    [5] = () => WCSHelper.UpdateStatus(task, "开始卸货"),
                    [6] = () => HandleUnloadCompletion(task),
                    [7] = () => HandleTaskFailure(task),
                    [8] = () => HandleTaskCompletion(task)
                };
                result.code = 0;
                return result;
            }
            catch (Exception ex)
            {
                result.code = 2;
                result.msg = ex.Message;
                var st = new System.Diagnostics.StackTrace(ex, true);
                var frame = st.GetFrame(0); // 获取第一个堆栈帧
                if (frame != null)
                {
                    LogHelper.Error($"notifyTaskStatus任务状态反馈出现错误！！", ex);
                    LogHelper.Error($"文件名: {frame.GetFileName()}", ex);
                    LogHelper.Error($"行号: {frame.GetFileLineNumber()}", ex);
                    LogHelper.Error($"列号: {frame.GetFileColumnNumber()}", ex);
                }
                return result;
            }
        }

        // 处理任务完成逻辑
        private static void HandleTaskCompletion(WCSTask task)
        {
            WCSHelper.End(task);

            // 根据任务类型处理不同的完成逻辑
            if (Settings.CompleteTasks.taskType.Contains(task.S_TYPE))
            {
                WMSHelper.UpdateWmsTask(task, 2);
                WMSHelper.UpdateDistributionCntrState(2, 3, task.S_CNTR_CODE);
            }

            if (new List<string> { "料箱入库", "托盘入库" }.Contains(task.S_TYPE))
            {
                ContainerHelper.UpdateCntrItem(task.S_CNTR_CODE);
            }

            // 处理区域变更
            HandleAreaChange(task);
        }

        // 处理取货完成逻辑
        private static void HandlePickCompletion(WCSTask task)
        {
            WCSHelper.UpdateStatus(task, "取货完成");
            TaskProcess.OperateStatus(task, 4);
        }

        // 处理卸货完成逻辑
        private static void HandleUnloadCompletion(WCSTask task)
        {
            WCSHelper.UpdateStatus(task, "卸货完成");
            TaskProcess.OperateStatus(task, 6);
        }

        // 处理任务失败逻辑
        private static void HandleTaskFailure(WCSTask task)
        {
            TaskProcess.OperateStatus(task, 7);
            WCSHelper.Fail(task);
        }

        // 处理区域变更逻辑
        private static void HandleAreaChange(WCSTask task)
        {
            var areas = new List<string> { "TPLKQ", "LXLKQ" };
            var area = new List<string> { "配盘出库", "配盘缓存" };

            if (areas.Contains(task.S_START_AREA) && !area.Contains(task.S_TYPE))
            {
                WMSHelper.DeleteChange(task);
            }

            if (areas.Contains(task.S_END_AREA))
            {
                WMSHelper.AddChange(task);
            }
        }

        /// <summary>
        /// WCS调用申请终点
        /// </summary>
        /// <param name="model">请求参数</param>
        /// <returns></returns>
        public static async Task<WcsResult> applyDest(WcsTaskEnd model)
        {
            WcsResult result = new WcsResult() { code = 1, };
            try
            {
                if (model == null)
                {
                    result.msg = "请求参数为空";
                    return result;
                }

                var task = WCSHelper.GetTask(model.taskNo);
                if (task == null)
                {
                    result.msg = "未查询到任务号";
                    return result;
                }

                result.code = 0;
                result.data.Add(new DataModel { taskNo = task.S_CODE, cntrCode = task.S_CNTR_CODE, end = task.S_END_LOC });
                return result;
            }
            catch (Exception ex)
            {
                result.code = 2;
                result.msg = ex.Message;
                var st = new System.Diagnostics.StackTrace(ex, true);
                var frame = st.GetFrame(0); // 获取第一个堆栈帧
                if (frame != null)
                {
                    LogHelper.Error($"applyDest申请终点出现错误！！", ex);
                    LogHelper.Error($"文件名: {frame.GetFileName()}", ex);
                    LogHelper.Error($"行号: {frame.GetFileLineNumber()}", ex);
                    LogHelper.Error($"列号: {frame.GetFileColumnNumber()}", ex);
                }
                return result;
            }
        }
        #endregion


@@ -1406,10 +1929,6 @@

            LogHelper.Error("CreateInTask获取作业创建入库任务出现错误！" + errorDetails, ex);
        }





        /// <summary>
        /// 循环入库缓存区查询合托工位和入库接驳位是否有空货位（创建任务）
@@ -1575,202 +2094,212 @@
        }

        /// <summary>
        /// WCS调用设备信号反馈
        /// 根据配盘单生成出库任务
        /// </summary>
        /// <param name="model">请求参数</param>
        /// <param name="distributionCntrs">配盘单</param>
        /// <returns></returns>
        public static async Task<Result> notifyDeviceSignal(List<Wcsmodel> model)
        internal static bool GenerateFromPicking(List<DistributionCntr> distributionCntrs)
        {
            Result result = new Result() { success = false, };
            try
            {
                foreach (var item in model)
                {
                    if (string.IsNullOrEmpty(item.cntrNo))
                    {
                        result.errMsg = "托盘号为空！";
                        return result;
                    }
                    var list = WMSHelper.GetWmsTaskList("等待", item.cntrNo);
                    if (list == null)
                    {
                        list = WMSHelper.GetWmsTaskList("执行", item.cntrNo);
                    }
                    if (list == null)
                    {
                        result.errMsg = "未查询到在等待中的作业！";
                        return result;
                    }
                // 1. 初始化调度器和出库任务列表
                var scheduler = new DoubleDeepOutboundScheduler(distributionCntrs);
                var outboundTasks = CreateOutboundTasks(distributionCntrs);

                    var inbound = new Inbound()
                    {
                        areaCode = list.S_END_AREA
                    };
                    var wh = new Warehouse(inbound);
                    var stored = await wh.StoreItemAsync();
                    if (stored == null)
                    {
                        result.errMsg = "立库区未查询到可用货位！";
                        return result;
                    }
                // 2. 计算货位生成任务数据
                var tasks = scheduler.GenerateOutboundTasks(outboundTasks);
                if (!tasks.Any()) return false;

                    var startLoc = ContainerHelper.GetCntrLoc(list.S_CNTR_CODE);
                    if (startLoc == null)
                    {
                        result.errMsg = $"未查询到托盘{list.S_CNTR_CODE}所在的货位！";
                        return result;
                    }
                    var res = TaskProcess.HYCreateTransport(startLoc.S_LOC_CODE, stored.loationCode, list.S_B_STATE == "等待" ? "料箱入库" : "托盘入库", list.S_CNTR_CODE, list.S_CODE);
                    if (!res)
                    {
                        result.errMsg = "入库任务创建失败！";
                        return result;
                    }
                    WMSHelper.UpdateTaskStatus(list.S_CODE, 1);
                    ContainerHelper.UpdateCntrAbouts(list.S_CNTR_CODE, "");
                }
                // 3. 创建WMS作业
                var mainTask = CreateMainWmsTask(tasks.Where(s=>s.S_TYPE == "配盘出库").First());
                if (!WMSHelper.CreateWmsTask(mainTask)) return false;


                result.success = true;
                return result;
                // 4. 生成WMS主任务
                return ProcessAllTransportTasks(tasks, mainTask.S_CODE);
            }
            catch (Exception ex)
            {
                result.success = false;
                result.errMsg = ex.Message;
                var st = new System.Diagnostics.StackTrace(ex, true);
                var frame = st.GetFrame(0); // 获取第一个堆栈帧
                if (frame != null)
                {
                    LogHelper.Error($"notifyDeviceSignalWCS调用设备信号反馈出现错误！！", ex);
                    LogHelper.Error($"文件名: {frame.GetFileName()}", ex);
                    LogHelper.Error($"行号: {frame.GetFileLineNumber()}", ex);
                    LogHelper.Error($"列号: {frame.GetFileColumnNumber()}", ex);
                }
                return result;
                LogErrorWithStackTrace("根据配盘单生成出库任务失败", ex);
                return false;
            }
        }

        /// <summary>
        /// 根据配盘单生成出库任务
        /// </summary>
        /// <param name="distributionCntr">配盘单</param>
        /// <returns></returns>
        internal static bool GenerateFromPicking(List<DistributionCntr> distributionCntr)
        // --------------------- 辅助方法 ---------------------

        private static List<Outbound> CreateOutboundTasks(List<DistributionCntr> distributionCntrs)
        {
            try
            return distributionCntrs.Select(item => new Outbound
            {
                // 创建调度器
                var scheduler = new DoubleDeepOutboundScheduler(distributionCntr);
                locCode = item.S_LOC_CODE,
                areaCode = item.S_AREA_CODE,
                endArea = item.S_EXIT_AREA_CODE,
                endBit = item.S_EXIT_LOC_CODE,
                trayCode = item.S_CNTR_CODE,
                taskType = "配盘出库"
            }).ToList();
        }

                var listOut = new List<Outbound>();
                foreach (var item in distributionCntr)
        private static WMSTask CreateMainWmsTask(WCSTask firstTask)
        {
            return new WMSTask
            {
                S_CNTR_CODE = firstTask.S_CNTR_CODE,
                S_CODE = WMSHelper.GenerateTaskNo(),
                S_START_LOC = firstTask.S_START_LOC,
                S_START_AREA = firstTask.S_START_AREA,
                S_END_LOC = firstTask.S_END_LOC,
                S_END_AREA = firstTask.S_END_AREA,
                S_START_WH = "CK001",
                S_END_WH = "CK001",
                N_B_STATE = 1,
                S_B_STATE = "执行",
                N_TYPE = 2,
                S_TYPE = "配盘出库"
            };
        }

        private static bool ProcessAllTransportTasks(List<WCSTask> tasks, string wmsTaskCode)
        {
            foreach (var task in tasks.OrderBy(t => t.N_PRIORITY))
            {
                if (IsLxLkqOrRelocationTask(task))
                {
                    listOut.Add(new Outbound
                    {
                        locCode = item.S_LOC_CODE,
                        areaCode = item.S_AREA_CODE,
                        endArea = item.S_EXIT_AREA_CODE,
                        endBit = item.S_EXIT_LOC_CODE,
                        trayCode = item.S_CNTR_CODE,
                        taskType = "配盘出库"
                    });
                    if (!ProcessLxLkqTransportTask(task, wmsTaskCode))
                        return false;
                }
                // 请求出库
                var tasks = scheduler.GenerateOutboundTasks(listOut);

                foreach (var item in tasks)
                else
                {
                    var wmsTask = new WMSTask();
                    if (string.IsNullOrEmpty(item.S_OP_CODE))
                    {
                        wmsTask = new WMSTask
                        {
                            S_CNTR_CODE = item.S_CNTR_CODE,
                            S_CODE = WMSHelper.GenerateTaskNo(),
                            S_START_LOC = item.S_START_LOC,
                            S_START_AREA = item.S_START_AREA,
                            S_END_LOC = item.S_END_LOC,
                            S_END_AREA = item.S_END_AREA,
                            S_START_WH = "CK001",
                            S_END_WH = "CK001",
                            N_B_STATE = 1,
                            S_B_STATE = "执行",
                            N_TYPE = 2,
                            S_TYPE = "配盘出库"
                        };
                        if (!WMSHelper.CreateWmsTask(wmsTask))
                        {
                            return false;
                        }
                    }

                    if (item.S_END_AREA == "LXLKQ")
                    {
                        // 创建出库任务
                        var res = TaskProcess.HYCreateTransport(item.S_START_LOC, item.S_END_LOC, item.S_TYPE, item.S_CNTR_CODE, wmsTask.S_CODE);
                        UpdateDistributionCntrState(1, 2, item.S_CNTR_CODE);
                        if (!res)
                        {
                            LogHelper.Info($"根据配盘单生成出库任务创建出库任务失败！！");
                            return false;
                        }
                    }
                    else
                    {
                        //根据分拣货位去查询配置，如果分拣区没有空货位就去出库分拣暂存区
                        var relevancys = Settings.OutRelevancys.Where(s => s.conLoc == item.S_END_LOC).FirstOrDefault();
                        if (relevancys == null)
                        {
                            LogHelper.Info($"Settings未查询到集货位{item.S_END_LOC}对应的分拣位！", "杭氧");
                            break;
                        }
                        var locList = LocationHelper.GetLocListEmptyFree(relevancys.sorLoc.ToList());
                        if (locList.Any())
                        {
                            // 创建出库任务
                            var res = TaskProcess.HYCreateTransport(item.S_START_LOC, locList.FirstOrDefault().S_CODE, item.S_TYPE, item.S_CNTR_CODE, wmsTask.S_CODE);
                            UpdateDistributionCntrState(1, 2, item.S_CNTR_CODE);
                            if (!res)
                            {
                                LogHelper.Info($"根据配盘单生成出库任务创建出库任务失败！！");
                                return false;
                            }
                        }
                        else
                        {
                            var reservoirs = Settings.ReservoirAreas.Where(s => s.areaName == "拣选缓存区").FirstOrDefault();
                            var lxLocations = LocationHelper.GetLocAreaList(reservoirs.areaCode);
                            if (lxLocations.Any())
                            {
                                // 创建出库任务
                                var res = TaskProcess.HYCreateTransport(item.S_START_LOC, lxLocations.FirstOrDefault().S_CODE, "配盘缓存", item.S_CNTR_CODE, wmsTask.S_CODE);
                                UpdateDistributionCntrState(1, 2, item.S_CNTR_CODE);
                                if (!res)
                                {
                                    LogHelper.Info($"根据配盘单生成出库任务创建出库任务失败！！");
                                    return false;
                                }
                            }
                        }
                    }
                    if (!ProcessNormalTransportTask(task, wmsTaskCode))
                        return false;
                }
                return true;
            }
            catch (Exception ex)
            return true;
        }

        private static bool IsLxLkqOrRelocationTask(WCSTask task)
        {
            return task.S_START_AREA == "LXLKQ" || task.S_TYPE == "深位移库";
        }

        /// <summary>
        /// 生成LXLKQ || 深位移库的配盘任务
        /// </summary>
        /// <param name="task"></param>
        /// <param name="wmsTaskCode"></param>
        /// <returns></returns>
        private static bool ProcessLxLkqTransportTask(WCSTask task, string wmsTaskCode)
        {
            bool success = false;
            if (task.S_TYPE == "深位移库")
            {
                var st = new System.Diagnostics.StackTrace(ex, true);
                var frame = st.GetFrame(0); // 获取第一个堆栈帧
                if (frame != null)
                {
                    LogHelper.Error($"根据配盘单生成出库任务失败{ex.Message}！！", ex);
                    LogHelper.Error($"文件名: {frame.GetFileName()}", ex);
                    LogHelper.Error($"行号: {frame.GetFileLineNumber()}", ex);
                    LogHelper.Error($"列号: {frame.GetFileColumnNumber()}", ex);
                }
                success = TaskProcess.HYCreateTransport(
                task.S_START_LOC,
                task.S_END_LOC,
                task.S_TYPE,
                task.S_CNTR_CODE,
                wmsTaskCode,
                task.N_PRIORITY);
                return  success;
            }
            var relevancy = Settings.OutRelevancys.FirstOrDefault(s => s.conLoc == task.S_END_LOC);
            if (relevancy == null)
            {
                LogHelper.Info($"Settings未查询到集货位{task.S_END_LOC}对应的分拣位！", "杭氧");
                return false;
            }


            // 尝试使用分拣位
            var emptyLoc = LocationHelper.GetLocListEmptyFree(relevancy.sorLoc.ToList()).FirstOrDefault();
            if (emptyLoc != null)
            {
                success = TaskProcess.HYCreateTransport(
                task.S_START_LOC,
                emptyLoc.S_CODE,
                task.S_TYPE,
                task.S_CNTR_CODE,
                wmsTaskCode,
                task.N_PRIORITY);
                if (success && task.S_TYPE != "深位移库")
                {
                    UpdateDistributionCntrState(1, 2, task.S_CNTR_CODE);
                }
            }
            return success;
        }

        /// <summary>
        /// 生成TPLKQ的配盘任务
        /// </summary>
        /// <param name="task"></param>
        /// <param name="wmsTaskCode"></param>
        /// <returns></returns>
        private static bool ProcessNormalTransportTask(WCSTask task, string wmsTaskCode)
        {
            var relevancy = Settings.OutRelevancys.FirstOrDefault(s => s.conLoc == task.S_END_LOC);
            if (relevancy == null)
            {
                LogHelper.Info($"Settings未查询到集货位{task.S_END_LOC}对应的分拣位！", "杭氧");
                return false;
            }

            // 尝试使用分拣位
            var emptyLoc = LocationHelper.GetLocListEmptyFree(relevancy.sorLoc.ToList()).FirstOrDefault();
            if (emptyLoc != null)
            {
                return CreateAndLogTransport(
                    task.S_START_LOC,
                    emptyLoc.S_CODE,
                    task.S_TYPE,
                    task.S_CNTR_CODE,
                    wmsTaskCode,
                    task.N_PRIORITY);
            }

            // 尝试使用拣选缓存区
            var reservoir = Settings.ReservoirAreas.FirstOrDefault(s => s.areaName == "拣选缓存区");
            if (reservoir == null) return false;

            var lxLocation = LocationHelper.GetLocAreaList(reservoir.areaCode).FirstOrDefault();
            if (lxLocation == null) return false;

            return CreateAndLogTransport(
                task.S_START_LOC,
                lxLocation.S_CODE,
                "配盘缓存",
                task.S_CNTR_CODE,
                wmsTaskCode,
                task.N_PRIORITY);
        }

        private static bool CreateAndLogTransport(string startLoc, string endLoc, string taskType,
            string cntrCode, string wmsTaskCode, int priority)
        {
            var success = TaskProcess.HYCreateTransport(
                startLoc, endLoc, taskType, cntrCode, wmsTaskCode, priority);

            if (success)
            {
                UpdateDistributionCntrState(1, 2, cntrCode);
            }
            else
            {
                LogHelper.Info("根据配盘单生成出库任务创建出库任务失败！！");
            }

            return success;
        }

        private static void LogErrorWithStackTrace(string message, Exception ex)
        {
            var st = new StackTrace(ex, true);
            var frame = st.GetFrame(0);
            if (frame == null) return;

            LogHelper.Error($"{message}{ex.Message}！！", ex);
            LogHelper.Error($"文件名: {frame.GetFileName()}", ex);
            LogHelper.Error($"行号: {frame.GetFileLineNumber()}", ex);
            LogHelper.Error($"列号: {frame.GetFileColumnNumber()}", ex);
        }

        #endregion