using HH.WCS.HangYang.api;
using HH.WCS.HangYang.core;
using HH.WCS.HangYang.dispatch;
using HH.WCS.HangYang.LISTA.models;
using HH.WCS.HangYang.LISTA.process;
using HH.WCS.HangYang.util;
using HH.WCS.HangYang.wms;
using Newtonsoft.Json;
using NLog.Fluent;
using Opc.Ua;
using SqlSugar;
using Swashbuckle.Swagger;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
using static HH.WCS.HangYang.api.OtherModel.Putaway_Order_In;
using static HH.WCS.HangYang.LISTA.process.HttpModel;
using static HH.WCS.HangYang.util.Settings;
using static HH.WCS.HangYang.wms.WMSHelper;
using static System.Runtime.CompilerServices.RuntimeHelpers;

namespace HH.WCS.HangYang.process
{
    internal class TaskProcess
    {
        #region 任务相关
        //--------------------------------------------------任务相关--------------------------------------------------
        /// <summary>
        /// 取货卸货完成，缓存位状态更新
        /// </summary>
        /// <param name="mst"></param>
        /// <param name="v"></param>
        internal static void CacheBitUpdate(WCSTask mst, bool load)
        {
            var trayCarryCount = mst.N_CNTR_COUNT > 0 ? mst.N_CNTR_COUNT : 1;
            if (load)
            {
                LogHelper.Info($"任务{mst.S_CODE} 货位{mst.S_START_LOC}取货完成，起点解绑容器{mst.S_CNTR_CODE}");
                LocationHelper.UnBindingLoc(mst.S_START_LOC, mst.S_CNTR_CODE.Split(',').ToList());

            }
            else
            {

                LogHelper.Info($"任务{mst.S_CODE} 货位{mst.S_END_LOC}卸货完成，终点绑定容器{mst.S_CNTR_CODE}");
                LocationHelper.BindingLoc(mst.S_END_LOC, mst.S_CNTR_CODE.Split(',').ToList(), mst.S_NOTE);
            }

        }

        /// <summary>
        /// 任务取消，缓存位状态更新
        /// </summary>
        /// <param name="mst"></param>
        internal static void CacheBitCancelUpdate(WCSTask mst)
        {
            //任务取消，取货完成前的，起点的loadingCount和终点unLoadingCount都清除，取货完成的只处理终点
            if (WCSHelper.CheckActionRecordExist(mst.S_CODE, 4))
            {
                //根据客户现场要求，如果取货完成任务失败人工拉到终点，我们就当卸货完成处理；如果是人工拉走到其它区域，我们就解锁终点，删除托盘。
                //终点绑定
                CacheBitUpdate(mst, false);
                LocationHelper.UnLockLoc(mst.S_END_LOC);
            }
            else
            {

                //起点终点解锁
                LocationHelper.UnLockLoc(mst.S_START_LOC);
                LocationHelper.UnLockLoc(mst.S_END_LOC);

            }

        }


        /// <summary>
        /// 任务拦截
        /// </summary>
        /// <param name="task"></param>
        /// <returns></returns>
        internal static bool Intercept(WCSTask mst)
        {
            var result = false;

            return result;
        }

        /// <summary>
        /// 任务状态更新处理
        /// </summary>
        /// <param name="mst"></param>
        /// <param name="state"></param>
        internal static void OperateStatus(WCSTask mst, int state)
        {
            if (state == 4)
            {
                CacheBitUpdate(mst, true);
            }
            if (state == 6)//卸货完成
            {
                CacheBitUpdate(mst, false);
            }
            if (state == 7)
            {
                CacheBitCancelUpdate(mst);
            }
        }

        /// <summary>
        /// 推送任务
        /// </summary>
        /// <param name="mst"></param>
        internal static bool SendTask(WCSTask mst)
        {


            var result = false;
            var start = "0"; var end = "0";
            var taskType = mst.S_TYPE.Trim();
            // if (mst.N_B_STATE == 0) {
            if (mst.N_SCHEDULE_TYPE == 1)
            {
                start = LocationHelper.GetAgvSite(mst.S_START_LOC);
                end = LocationHelper.GetAgvSite(mst.S_END_LOC);


                Console.WriteLine($"SendTask {mst.S_CODE}");
                Console.WriteLine("start=" + start);
                Console.WriteLine("end= " + end);
                var dic = new Dictionary<string, string>();
                dic.Add("Pri", mst.N_PRIORITY.ToString());
                dic.Add("From", start.ToString());
                dic.Add("To", end.ToString());
                dic.Add("No", mst.S_CODE.Trim());// dic.Add("Ext1", "1"); dic.Add("Ext2", "CALLADDAGV"); dic.Add("N_CNTR_COUNT", "");
                var res = NDC.AddNewOrder(5, dic);
                if (res != null && (res.Res.ErrCode == 0 || res.Res.ErrCode == 50009))
                {
                    //推送成功，修改任务优先级
                    mst.N_B_STATE = 1;
                    WCSHelper.UpdateStatus(mst);
                    result = true;
                }
            }
            //else if (mst.N_SCHEDULE_TYPE == 5) {
            //    //调第三方接口
            //    var model = new HanAo.TaskInfoModel
            //    {
            //        requestPk = mst.S_CODE,
            //        frmPos = mst.S_START_LOC,
            //        toPos = mst.S_END_LOC,
            //        trkType = mst.S_OP_NAME == "入库" ? "1" : "2",
            //        contNo = mst.S_CNTR_CODE
            //    };
            //    if (HanAo.CreateOrder(model)) {
            //        mst.N_B_STATE = 1;
            //        WCSHelper.UpdateStatus(mst);
            //    }
            //}
            //else if (mst.N_SCHEDULE_TYPE == 3)
            //{
            //    var code = GZRobot.CreateOrder(mst.S_CODE, mst.N_PRIORITY, JsonConvert.SerializeObject(new { src = mst.S_START_LOC, dst = mst.S_END_LOC }), "p2p");
            //    if (code > 0)
            //    {
            //        更新任务状态
            //        mst.N_B_STATE = 1;
            //        mst.S_EQ_TASK_CODE = code.ToString();
            //        WCSHelper.UpdateStatus(mst);
            //        WCSHelper.UpdateEQNo(mst);

            //    }
            //}

            //}
            return result;
        }

        /// <summary>
        /// 国自推送任务
        /// </summary>
        /// <param name="mst"></param>
        internal static bool SendGZTask(WCSTask mst)
        {
            var result = false;
            var taskState = mst.S_B_STATE.Trim();
            if (taskState == "等待")
            {
                Console.WriteLine($"任务mst {JsonConvert.SerializeObject(mst)}");
                LogHelper.Info($"任务mst {JsonConvert.SerializeObject(mst)}", "任务");
                var startLoc = LocationHelper.GetLoc(mst.S_START_LOC);
                var endLoc = LocationHelper.GetLoc(mst.S_END_LOC);
                if (startLoc != null && endLoc != null)
                {
                    //"parameters": "{\"src\":\"a\",\"dst\":\"b\",\" carcode \":\"aaaaa\",\" orderid \":1}"
                    //src:起点, dst:终点，carcode:车号，orderid:
                    string src = $"\"src\":\"{startLoc.S_AGV_SITE}\","; ;
                    string dst = $"\"dst\":\"{endLoc.S_AGV_SITE}\"";
                    string parmeS = "{";
                    string parmeD = "}";
                    string parme = parmeS + src + dst + parmeD;
                    LogHelper.Info($"推送任务参数{parme}", "任务");
                    var res = GZRobot.CreateOrder(mst.S_CODE, mst.N_PRIORITY, parme);
                    if (res > 0)
                    {
                        //更新任务状态
                        mst.N_B_STATE = 1;
                        mst.S_EQ_TASK_CODE = res.ToString();
                        WCSHelper.UpdateStatus(mst);
                        WCSHelper.UpdateEQNo(mst);

                        ////推送成功，修改任务状态
                        //TaskHelper.UpdateStatus(mst, "已推送");
                        ////推送成功，修改国自ID
                        //TaskHelper.UpdateGzId(mst, res);
                        LogHelper.Info($"任务mst {mst.S_CODE}推送成功", "任务");
                        result = true;
                    }
                }


            }
            else { result = true; }
            return result;
        }


        /// <summary>
        /// 创建搬运任务
        /// </summary>
        /// <param name="start"></param>
        /// <param name="end"></param>
        /// <param name="taskType"></param>
        /// <param name="cntrs"></param>
        /// <param name="startLayer"></param>
        /// <param name="endLayer"></param>
        /// <param name="trayCarryCount"></param>
        /// <param name="priority"></param>
        /// <returns></returns>
        public static bool CreateTransport(string start, string end, string taskType, List<string> cntrs, int startLayer, int endLayer, int trayCarryCount = 1, int priority = 1)
        {
            var result = false;
            //批次号存托盘号，1~3个托盘
            var trayCodes = string.Join(",", cntrs);
            var taskNo = DateTime.Now.Ticks.ToString();


            var res = WCSHelper.CreateTask(taskNo, start.Trim(), end.Trim(), taskType, priority, trayCodes, trayCarryCount, startLayer, endLayer);
            if (res)
            {
                result = true;
                //任务创建成功，起点货位出库锁定，终点货位入库锁定
                LocationHelper.LockLoc(start, 2);
                LocationHelper.LockLoc(end, 1);
            }
            return result;
        }


        public static bool CreateTransport(string start, string end, string taskType, List<string> cntrs, int priority = 1)
        {
            var result = false;
            //批次号存托盘号，1~3个托盘
            var trayCodes = string.Join(",", cntrs);
            var taskNo = DateTime.Now.Ticks.ToString();


            var res = WCSHelper.CreateTask(taskNo, start.Trim(), end.Trim(), taskType, priority, trayCodes, 1, 1, 1);
            if (res)
            {
                result = true;
                LocationHelper.LockLoc(start, 2);
                LocationHelper.LockLoc(end, 1);

            }
            return result;
        }

        internal static Result cancelTask1(cancleTaskParme model)
        {
            var result = new Result();
            LogHelper.Info("cancelTask1取消任务信息：" + JsonConvert.SerializeObject(model), "API");
            if (model == null)
            {

                result.success = false;
                result.errMsg = "参数为null";
                result.errCode = 1;
                return result;
            }
            var task = WCSHelper.GetTask(model.taskNo);
            if (task != null)
            {
                if (task.S_B_STATE.Trim() == "未执行")
                {
                    //未执行直接修改状态为取消
                    TaskProcess.OperateStatus(task, 7);
                    WCSHelper.UpdateStatus(task, "取消");
                    result.success = true;
                    result.errMsg = "取消任务成功";
                    result.errCode = 0;
                }
                else if (task.S_B_STATE.Trim() != "取消" && task.S_B_STATE.Trim() != "完成")
                {

                    if (GZRobot.CancelOrder(int.Parse(task.S_EQ_TASK_CODE)))
                    {
                        TaskProcess.OperateStatus(task, 7);
                        WCSHelper.Fail(task);
                        result.success = true;
                        result.errMsg = "国自取消任务成功";
                        result.errCode = 0;
                    }
                    else
                    {
                        result.success = false;
                        result.errMsg = "国自取消任务失败";
                        result.errCode = 1;
                    }

                }
                else
                {
                    result.success = false;
                    result.errMsg = "任务已经结束";
                    result.errCode = 1;
                }
            }
            else
            {
                result.success = false;
                result.errMsg = "任务不存在";
                result.errCode = 1;
            }
            LogHelper.Info("cancelTask1取消任务返回结果：" + JsonConvert.SerializeObject(result), "API");
            return result;
        }


        #endregion

        #region 杭氧
        /// <summary>
        /// 杭氧创建搬运任务
        /// </summary>
        /// <param name="start">起点</param>
        /// <param name="end">终点</param>
        /// <param name="taskType">任务类型</param>
        /// <param name="cntrs">托盘号</param>
        /// <param name="priority">优先级</param>
        /// <param name="taskNo">作业编码</param>
        /// <returns></returns>
        public static bool HYCreateTransport(string start, string end, string taskType, string cntrs, string taskNo = "", int priority = 1)
        {
            var result = false;
            //批次号存托盘号，1~3个托盘
            var trayCodes = string.Join(",", cntrs);
            //var taskNo = DateTime.Now.Ticks.ToString();


            var res = WCSHelper.CreateTask(taskNo, start.Trim(), end.Trim(), taskType, priority, trayCodes);
            if (res)
            {
                result = true;
                //任务创建成功，起点货位出库锁定，终点货位入库锁定
                LocationHelper.LockLoc(start, 2);
                LocationHelper.LockLoc(end, 1);
            }
            return result;
        }

        /// <summary>
        /// 入库单新增
        /// </summary>
        /// <param name="model">入库单</param>
        /// <returns></returns>
        public static Result GetMaterialData(List<MES_Material> model)
        {
            Result result = new Result() { success = false, };
            try
            {
                if (model == null)
                {
                    result.errMsg = "入库单不可为空值！";
                    return result;
                }

                //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;
                //}
                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($"GetInboundOrder入库单新增出现错误！！", 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 GetInboundOrder(InOrder model)
        {
            Result result = new Result() { success = false, };
            try
            {
                if (model == null || !model.InOrderDetail.Any())
                {
                    result.errMsg = "入库单不可为空值！";
                    return result;
                }

                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;
                    item.S_ITEM_NAME = itemType.S_ITEM_NAME;
                }

                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,
                                          S_FACTORY = "HY001",
                                          S_WH_CODE = "CK001",
                                          S_AREA_CODE = group.Key.Equals("料箱库") ? "LXLKQ" : "TPLKQ",
                                          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;
                }
                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($"GetInboundOrder入库单新增出现错误！！", 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 GetOutboundOrder(OutOrder model)
        {
            Result result = new Result() { success = false };
            try
            {
                if (model == null || !model.OutOrderDetail.Any())
                {
                    result.errMsg = "出库单不可为空值！";
                    return result;
                }

                // 第一步：设置物料属性信息
                foreach (var item in model.OutOrderDetail)
                {
                    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;
                    item.S_ITEM_NAME = itemType.S_ITEM_NAME;
                    item.C_CLEAN = itemType.C_CLEAN;
                }

                // 第二步：先按物料属性分组，再按是否清洗分组
                var groupedOrders = model.OutOrderDetail
                    .GroupBy(detail => new
                    {
                        MaterialType = detail.S_EXT_ATTR1,
                        IsClean = detail.C_CLEAN
                    }) // 按物料属性和是否清洗双重分组
                    .Select((group, index) => new OutOrder
                    {
                        S_NO = $"{model.S_BS_NO}_{index + 1}",
                        S_BS_NO = model.S_BS_NO,
                        S_OP_TYPE = model.S_OP_TYPE,
                        S_OUT_TO = model.S_OUT_TO,
                        S_NOTE = model.S_NOTE,
                        S_BS_TYPE = "ERP",
                        S_FACTORY = "HY001",
                        S_WH_CODE = "CK001",
                        S_AREA_CODE = group.Key.MaterialType.Equals("料箱库") ? "LXLKQ" : "TPLKQ",
                        C_CLEAN = group.Key.IsClean, // 添加是否清洗标记
                        OutOrderDetail = group.Select(detail =>
                        {
                            detail.S_OO_NO = $"{model.S_BS_NO}_{index + 1}";
                            detail.S_BS_NO = model.S_BS_NO;
                            return detail;
                        }).ToList()
                    })
                    .ToList();

                // 第三步：调用创建出库单方法
                var res = WMSHelper.CreateOrderOut(groupedOrders);
                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($"GetOutboundOrder出库单新增出现错误！", ex);
                    LogHelper.Error($"文件名: {frame.GetFileName()}", ex);
                    LogHelper.Error($"行号: {frame.GetFileLineNumber()}", ex);
                    LogHelper.Error($"列号: {frame.GetFileColumnNumber()}", ex);
                }
                return result;
            }
        }

        ///// <summary>
        ///// 获取作业创建入库任务
        ///// </summary>
        ///// <param name="mst"></param>
        ///// <returns></returns>
        //internal static bool CreateInTask(WMSTask mst)
        //{
        //    try
        //    {
        //        var result = false;
        //        var taskState = mst.S_B_STATE.Trim();
        //        if (taskState == "等待")
        //        {
        //            if (!string.IsNullOrEmpty(mst.S_START_LOC))
        //            {
        //                //杭氧所有库区
        //                var reservoirs = Settings.ReservoirAreas.ToList();
        //                if (!reservoirs.Any() || reservoirs == null)
        //                {
        //                    LogHelper.Info("Settings出现错误未查询到杭氧的库区！", "杭氧");
        //                    return false;
        //                }
        //                if (mst.S_TYPE == "托盘转运")
        //                {
        //                    var lxAnyLoc = LocationHelper.GetLocAreaList(reservoirs.Where(s => s.areaName == "料箱入库缓存位").FirstOrDefault().areaCode);
        //                    if (lxAnyLoc.Any())
        //                    {
        //                        var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, lxAnyLoc.FirstOrDefault().S_CODE, "料箱缓存位入库", mst.S_CNTR_CODE, mst.S_CODE);
        //                        if (!res)
        //                        {
        //                            LogHelper.Info("料箱缓存位入库任务创建失败！", "杭氧");
        //                            return false;
        //                        }
        //                        WMSHelper.UpdateStatus(mst, 1);
        //                    }
        //                    else
        //                    {
        //                        var rkAnyLoc = LocationHelper.GetLocAreaList(reservoirs.Where(s => s.areaName == "入库缓存区").FirstOrDefault().areaCode);
        //                        if (rkAnyLoc.Any())
        //                        {
        //                            var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, rkAnyLoc.FirstOrDefault().S_CODE, "料箱码盘缓存入库", mst.S_CNTR_CODE, mst.S_CODE);
        //                            if (!res)
        //                            {
        //                                LogHelper.Info("码盘缓存入库任务创建失败！", "杭氧");
        //                                return false;
        //                            }
        //                            WMSHelper.UpdateStatus(mst, 1);
        //                            //标记为合托
        //                            ContainerHelper.UpdateCntrAbouts(mst.S_CNTR_CODE, "料箱合托");
        //                        }
        //                        else
        //                        {
        //                            LogHelper.Info("入库缓存区没有空货位！", "杭氧");
        //                            return false;
        //                        }
        //                    }
        //                }
        //                if (mst.S_TYPE == "托盘入库")
        //                {
        //                    //1.查询下下库里面是否有要合托的托盘
        //                    var locMerge = WMSHelper.GetLocMerge(mst.S_CNTR_CODE);
        //                    if (locMerge != null)
        //                    {
        //                        //（1.1）如果有要合托的托盘就去判断一下合托工位是否为空
        //                        var anyLoc = LocationHelper.GetLocAreaList(reservoirs.Where(s => s.areaName == "合托区").FirstOrDefault().areaCode);
        //                        if (anyLoc.Any())
        //                        {

        //                            foreach (var item in anyLoc)
        //                            {
        //                                //生成一条出库的任务
        //                                var relevancys = Settings.Relevancys.Where(s => s.InLoc == item.S_CODE).FirstOrDefault();
        //                                if (relevancys == null)
        //                                {
        //                                    LogHelper.Info($"Settings未查询到合托入库位{item.S_CODE}对应的出库位！", "杭氧");
        //                                    continue;
        //                                }
        //                                //生成到合托区的任务
        //                                var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, item.S_CODE, "码盘合托入库", mst.S_CNTR_CODE, mst.S_CODE);
        //                                if (!res)
        //                                {
        //                                    LogHelper.Info("码盘合托入库任务创建失败！", "杭氧");
        //                                    return false;
        //                                }
        //                                res = TaskProcess.HYCreateTransport(locMerge.S_LOC_CODE, relevancys.OutLoc, "码盘合托出库", locMerge.S_CNTR_CODE, mst.S_CODE);
        //                                if (!res)
        //                                {
        //                                    LogHelper.Info("码盘合托出库任务创建失败！", "杭氧");
        //                                    return false;
        //                                }
        //                                //（1.2）如果合托工位为空就直接合托到合托工位里面，同时生成一个出库任务把被合托的托盘出出来（标记为要合托）
        //                                ContainerHelper.UpdateCntrAbouts(mst.S_CNTR_CODE, "合托");
        //                                WMSHelper.UpdateStatus(mst, 1);
        //                                break;
        //                            }


        //                        }
        //                        else
        //                        {
        //                            //（1.3）如果合托工位不为空就去入库缓存区（标记为要合托）
        //                            //生成到入库缓存区的任务
        //                            var rkAnyLoc = LocationHelper.GetLocAreaList(reservoirs.Where(s => s.areaName == "入库缓存区").FirstOrDefault().areaCode);
        //                            if (rkAnyLoc.Any())
        //                            {
        //                                var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, rkAnyLoc.FirstOrDefault().S_CODE, "码盘缓存入库", mst.S_CNTR_CODE, mst.S_CODE);
        //                                if (!res)
        //                                {
        //                                    LogHelper.Info("码盘缓存入库任务创建失败！", "杭氧");
        //                                    return false;
        //                                }
        //                                WMSHelper.UpdateStatus(mst, 1);
        //                                //标记为合托
        //                                ContainerHelper.UpdateCntrAbouts(mst.S_CNTR_CODE, "合托");
        //                            }
        //                            else
        //                            {
        //                                LogHelper.Info("入库缓存区没有空货位！", "杭氧");
        //                                return false;
        //                            }
        //                        }

        //                    }
        //                    else
        //                    {
        //                        //2.如果没有要合托的托盘
        //                        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
        //                        {
        //                            //(2.2)如果入库接驳位不为空，则生成到入库缓存区的任务（标记为不合托）
        //                            //生成到入库缓存区的任务
        //                            var rkAnyLoc = LocationHelper.GetLocAreaList(reservoirs.Where(s => s.areaName == "入库缓存区").FirstOrDefault().areaCode);
        //                            if (rkAnyLoc.Any())
        //                            {
        //                                var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, rkAnyLoc.FirstOrDefault().S_CODE, "码盘缓存入库", mst.S_CNTR_CODE, mst.S_CODE);
        //                                if (!res)
        //                                {
        //                                    LogHelper.Info("码盘缓存入库任务创建失败！", "杭氧");
        //                                    return false;
        //                                }
        //                                WMSHelper.UpdateStatus(mst, 1);
        //                                //标记为不合托
        //                                ContainerHelper.UpdateCntrAbouts(mst.S_CNTR_CODE, "不合托");
        //                            }
        //                            else
        //                            {
        //                                LogHelper.Info("入库缓存区没有空货位！", "杭氧");
        //                                return false;
        //                            }

        //                        }

        //                    }
        //                }
        //                if (mst.S_TYPE == "合托回库")
        //                {
        //                    var trayLst = ContainerHelper.GetCntrItemRel(mst.S_CNTR_CODE);
        //                    if (trayLst.Any())
        //                    {
        //                        //满托回库
        //                        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
        //                        {
        //                            //(2.2)如果入库接驳位不为空，则生成到入库缓存区的任务（标记为不合托）
        //                            //生成到入库缓存区的任务
        //                            var rkAnyLoc = LocationHelper.GetLocAreaList(reservoirs.Where(s => s.areaName == "入库缓存区").FirstOrDefault().areaCode);
        //                            if (rkAnyLoc.Any())
        //                            {
        //                                var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, rkAnyLoc.FirstOrDefault().S_CODE, "码盘缓存入库", mst.S_CNTR_CODE, mst.S_CODE);
        //                                if (!res)
        //                                {
        //                                    LogHelper.Info("码盘缓存入库任务创建失败！", "杭氧");
        //                                    return false;
        //                                }
        //                                WMSHelper.UpdateStatus(mst, 1);
        //                                //标记为不合托
        //                                ContainerHelper.UpdateCntrAbouts(mst.S_CNTR_CODE, "不合托");
        //                            }
        //                            else
        //                            {
        //                                LogHelper.Info("入库缓存区没有空货位！", "杭氧");
        //                                return false;
        //                            }

        //                        }
        //                    }
        //                    else
        //                    {
        //                        //空托回库
        //                        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 rkAnyLoc = LocationHelper.GetLocAreaList(reservoirs.Where(s => s.areaName == "入库缓存区").FirstOrDefault().areaCode);
        //                            if (rkAnyLoc.Any())
        //                            {
        //                                var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, rkAnyLoc.FirstOrDefault().S_CODE, "码盘缓存入库", mst.S_CNTR_CODE, mst.S_CODE);
        //                                if (!res)
        //                                {
        //                                    LogHelper.Info("码盘缓存入库任务创建失败！", "杭氧");
        //                                    return false;
        //                                }
        //                                //标记为不合托
        //                                ContainerHelper.UpdateCntrAbouts(mst.S_CNTR_CODE, "不合托");
        //                                WMSHelper.UpdateStatus(mst, 1);

        //                            }
        //                            else
        //                            {
        //                                LogHelper.Info("入库缓存区没有空货位！", "杭氧");
        //                                return false;
        //                            }
        //                        }
        //                    }
        //                }
        //                if (mst.S_TYPE == "料箱出库")
        //                {

        //                    //满托回库
        //                    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
        //                    {
        //                        LogHelper.Info("料箱码盘区未有可用货位！", "杭氧");
        //                    }
        //                }
        //            }
        //        }
        //        else { result = true; }
        //        return result;
        //    }
        //    catch (Exception ex)
        //    {
        //        var st = new System.Diagnostics.StackTrace(ex, true);
        //        var frame = st.GetFrame(0); // 获取第一个堆栈帧
        //        if (frame != null)
        //        {
        //            LogHelper.Error($"CreateInTask获取作业创建入库任务出现错误！！", ex);
        //            LogHelper.Error($"文件名: {frame.GetFileName()}", ex);
        //            LogHelper.Error($"行号: {frame.GetFileLineNumber()}", ex);
        //            LogHelper.Error($"列号: {frame.GetFileColumnNumber()}", ex);
        //        }
        //        return false;
        //    }

        //}

        #region 等待作业

        /// <summary>
        /// 获取作业创建入库任务
        /// </summary>
        /// <param name="mst"></param>
        /// <returns></returns>
        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;

                var reservoirs = Settings.ReservoirAreas?.ToList();
                if (reservoirs == null || !reservoirs.Any())
                {
                    LogHelper.Info("Settings出现错误未查询到杭氧的库区！", "杭氧");
                    return false;
                }

                switch (mst.S_TYPE)
                {
                    case "托盘转运":
                        return HandlePalletTransport(mst, reservoirs);
                    case "托盘入库":
                        return HandlePalletStorage(mst, reservoirs);
                    case "合托回库":
                        return HandleMergeReturn(mst, reservoirs);
                    case "分拣回库":
                        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 "发货暂存":
                        return PreShipmentStage(mst);
                    case "发货清洗":
                        return PreShipmentStage(mst);
                    case "发货装配":
                        return PreShipmentStage(mst);
                    default:
                        return true;
                }
            }
            catch (Exception ex)
            {
                LogErrorDetails(ex);
                return false;
            }
        }

        /// <summary>
        /// 托盘转运
        /// </summary>
        /// <param name="mst"></param>
        /// <param name="reservoirs"></param>
        /// <returns></returns>
        private static bool HandlePalletTransport(WMSTask mst, List<ReservoirArea> reservoirs)
        {
            var res = true;
            var lxArea = reservoirs.FirstOrDefault(s => s.areaName == "料箱入库缓存位");
            if (lxArea != null)
            {
                var lxLocations = LocationHelper.GetLocAreaList(lxArea.areaCode);
                if (lxLocations.Any())
                {
                    res = TaskProcess.HYCreateTransport(mst.S_START_LOC, lxLocations.FirstOrDefault().S_CODE, "料箱缓存位入库", mst.S_CNTR_CODE, mst.S_CODE);
                    if (!res)
                    {
                        LogHelper.Info("料箱缓存位入库任务创建失败！", "杭氧");
                        return false;
                    }
                    WMSHelper.UpdateStatus(mst, 1);
                }
            }

            var rkArea = reservoirs.FirstOrDefault(s => s.areaName == "入库缓存区");
            if (rkArea == null) return false;

            var rkLocations = LocationHelper.GetLocAreaList(rkArea.areaCode);
            if (!rkLocations.Any())
            {
                LogHelper.Info("入库缓存区没有空货位！", "杭氧");
                return false;
            }

            res = TaskProcess.HYCreateTransport(mst.S_START_LOC, rkLocations.FirstOrDefault().S_CODE, "料箱码盘缓存入库", mst.S_CNTR_CODE, mst.S_CODE);
            if (!res)
            {
                LogHelper.Info("码盘缓存入库任务创建失败！", "杭氧");
                return false;
            }
            WMSHelper.UpdateStatus(mst, 1);
            //标记为合托
            ContainerHelper.UpdateCntrAbouts(mst.S_CNTR_CODE, "料箱合托");
            return true;
        }

        /// <summary>
        /// 托盘入库
        /// </summary>
        /// <param name="mst"></param>
        /// <param name="reservoirs"></param>
        /// <returns></returns>
        private static bool HandlePalletStorage(WMSTask mst, List<ReservoirArea> reservoirs)
        {
            var result = true;
            var locMerge = WMSHelper.GetLocMerge(mst.S_CNTR_CODE);
            if (locMerge != null)
            {
                //（1.1）如果有要合托的托盘就去判断一下合托工位是否为空
                var anyLoc = LocationHelper.GetLocAreaList(reservoirs.Where(s => s.areaName == "合托区").FirstOrDefault().areaCode);
                if (anyLoc.Any())
                {
                    foreach (var item in anyLoc)
                    {
                        //生成一条出库的任务
                        var relevancys = Settings.Relevancys.Where(s => s.InLoc == item.S_CODE).FirstOrDefault();
                        if (relevancys == null)
                        {
                            LogHelper.Info($"Settings未查询到合托入库位{item.S_CODE}对应的出库位！", "杭氧");
                            continue;
                        }
                        //生成到合托区的任务
                        var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, item.S_CODE, "码盘合托入库", mst.S_CNTR_CODE, mst.S_CODE);
                        if (!res)
                        {
                            LogHelper.Info("码盘合托入库任务创建失败！", "杭氧");
                            return false;
                        }
                        res = TaskProcess.HYCreateTransport(locMerge.S_LOC_CODE, relevancys.OutLoc, "码盘合托出库", locMerge.S_CNTR_CODE, mst.S_CODE);
                        if (!res)
                        {
                            LogHelper.Info("码盘合托出库任务创建失败！", "杭氧");
                            return false;
                        }
                        //（1.2）如果合托工位为空就直接合托到合托工位里面，同时生成一个出库任务把被合托的托盘出出来（标记为要合托）
                        ContainerHelper.UpdateCntrAbouts(mst.S_CNTR_CODE, "合托");
                        WMSHelper.UpdateStatus(mst, 1);
                        break;
                    }
                }
                else
                {
                    //（1.3）如果合托工位不为空就去入库缓存区（标记为要合托）
                    //生成到入库缓存区的任务
                    var rkAnyLoc = LocationHelper.GetLocAreaList(reservoirs.Where(s => s.areaName == "入库缓存区").FirstOrDefault().areaCode);
                    if (rkAnyLoc.Any())
                    {
                        var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, rkAnyLoc.FirstOrDefault().S_CODE, "码盘缓存入库", mst.S_CNTR_CODE, mst.S_CODE);
                        if (!res)
                        {
                            LogHelper.Info("码盘缓存入库任务创建失败！", "杭氧");
                            return false;
                        }
                        WMSHelper.UpdateStatus(mst, 1);
                        //标记为合托
                        ContainerHelper.UpdateCntrAbouts(mst.S_CNTR_CODE, "合托");
                    }
                    else
                    {
                        LogHelper.Info("入库缓存区没有空货位！", "杭氧");
                        return false;
                    }
                }

            }
            else
            {
                //2.如果没有要合托的托盘
                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
                {
                    //(2.2)如果入库接驳位不为空，则生成到入库缓存区的任务（标记为不合托）
                    //生成到入库缓存区的任务
                    var rkAnyLoc = LocationHelper.GetLocAreaList(reservoirs.Where(s => s.areaName == "入库缓存区").FirstOrDefault().areaCode);
                    if (rkAnyLoc.Any())
                    {
                        var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, rkAnyLoc.FirstOrDefault().S_CODE, "码盘缓存入库", mst.S_CNTR_CODE, mst.S_CODE);
                        if (!res)
                        {
                            LogHelper.Info("码盘缓存入库任务创建失败！", "杭氧");
                            return false;
                        }
                        WMSHelper.UpdateStatus(mst, 1);
                        //标记为不合托
                        ContainerHelper.UpdateCntrAbouts(mst.S_CNTR_CODE, "不合托");
                    }
                    else
                    {
                        LogHelper.Info("入库缓存区没有空货位！", "杭氧");
                        return false;
                    }

                }

            }
            return result;
        }

        /// <summary>
        /// 合托回库
        /// </summary>
        /// <param name="mst"></param>
        /// <param name="reservoirs"></param>
        /// <returns></returns>
        private static bool HandleMergeReturn(WMSTask mst, List<ReservoirArea> reservoirs)
        {
            var trayLst = ContainerHelper.GetCntrItemRel(mst.S_CNTR_CODE);
            if (trayLst.Any())
            {
                //满托回库
                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
                {
                    //(2.2)如果入库接驳位不为空，则生成到入库缓存区的任务（标记为不合托）
                    //生成到入库缓存区的任务
                    var rkAnyLoc = LocationHelper.GetLocAreaList(reservoirs.Where(s => s.areaName == "入库缓存区").FirstOrDefault().areaCode);
                    if (rkAnyLoc.Any())
                    {
                        var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, rkAnyLoc.FirstOrDefault().S_CODE, "码盘缓存入库", mst.S_CNTR_CODE, mst.S_CODE);
                        if (!res)
                        {
                            LogHelper.Info("码盘缓存入库任务创建失败！", "杭氧");
                            return false;
                        }
                        WMSHelper.UpdateStatus(mst, 1);
                        //标记为不合托
                        ContainerHelper.UpdateCntrAbouts(mst.S_CNTR_CODE, "不合托");
                    }
                    else
                    {
                        LogHelper.Info("入库缓存区没有空货位！", "杭氧");
                        return false;
                    }

                }
            }
            else
            {
                //空托回库
                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 rkAnyLoc = LocationHelper.GetLocAreaList(reservoirs.Where(s => s.areaName == "入库缓存区").FirstOrDefault().areaCode);
                    if (rkAnyLoc.Any())
                    {
                        var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, rkAnyLoc.FirstOrDefault().S_CODE, "码盘缓存入库", mst.S_CNTR_CODE, mst.S_CODE);
                        if (!res)
                        {
                            LogHelper.Info("码盘缓存入库任务创建失败！", "杭氧");
                            return false;
                        }
                        //标记为不合托
                        ContainerHelper.UpdateCntrAbouts(mst.S_CNTR_CODE, "不合托");
                        WMSHelper.UpdateStatus(mst, 1);

                    }
                    else
                    {
                        LogHelper.Info("入库缓存区没有空货位！", "杭氧");
                        return false;
                    }
                }
            }
            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>
        /// 料箱出库
        /// </summary>
        /// <param name="mst"></param>
        /// <param name="reservoirs"></param>
        /// <returns></returns>
        private static bool HandleBoxOutbound(WMSTask mst, List<ReservoirArea> reservoirs)
        {
            var result = true;
            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
            {
                LogHelper.Info("料箱码盘区未有可用货位！", "杭氧");
            }
            return result;
        }

        /// <summary>
        /// 发货暂存 || 发货清洗 || 发货装配 (暂时使用一个方法处理)
        /// </summary>
        /// <param name="mst"></param>
        /// <returns></returns>
        private static bool PreShipmentStage(WMSTask mst)
        {
            var locList = LocationHelper.GetLocAreaList(mst.S_END_AREA);
            if (locList.Any())
            {
                var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, locList.FirstOrDefault().S_CODE, mst.S_TYPE, mst.S_CNTR_CODE, mst.S_CODE);
                if (!res)
                {
                    LogHelper.Info($"{mst.S_TYPE}入库任务创建失败！", "杭氧");
                    return false;
                }
                WMSHelper.UpdateStatus(mst, 1);
            }
            return true;
        }

        /// <summary>
        /// 发货清洗
        /// </summary>
        /// <param name="mst"></param>
        /// <returns></returns>
        private static bool OutboundCleaning(WMSTask mst)
        {
            return true;
        }

        /// <summary>
        /// 发货装配
        /// </summary>
        /// <param name="mst"></param>
        /// <returns></returns>
        private static bool OutboundAssembly(WMSTask mst)
        {
            return true;
        }
        #endregion

        #region 执行作业

        /// <summary>
        /// 获取执行的作业创建任务
        /// </summary>
        /// <param name="mst"></param>
        /// <returns></returns>
        internal static bool exeCreateInTask(WMSTask mst)
        {
            try
            {
                if (mst.S_B_STATE.Trim() != "执行") return true;
                if (string.IsNullOrEmpty(mst.S_START_LOC)) return false;

                var reservoirs = Settings.ReservoirAreas?.ToList();
                if (reservoirs == null || !reservoirs.Any())
                {
                    LogHelper.Info("Settings出现错误未查询到杭氧的库区！", "杭氧");
                    return false;
                }

                switch (mst.S_TYPE)
                {
                    case "配盘出库":
                        return PalletOutbound(mst);
                    default:
                        return true;
                }
            }
            catch (Exception ex)
            {
                LogErrorDetails(ex);
                return false;
            }
        }

        /// <summary>
        /// 配盘出库
        /// </summary>
        /// <param name="mst"></param>
        /// <param name="reservoirs"></param>
        /// <returns></returns>
        private static bool PalletOutbound(WMSTask mst)
        {
            var relevancys = Settings.OutRelevancys.Where(s => s.conLoc == mst.S_END_LOC).FirstOrDefault();
            if (relevancys == null)
            {
                LogHelper.Info($"Settings未查询到集货位{mst.S_END_LOC}对应的分拣位！", "杭氧");
                return false;
            }
            var locList = LocationHelper.GetLocListEmptyFree(relevancys.sorLoc.ToList());
            if (locList.Any())
            {
                var startLoc = WMSHelper.GetCntrLoc(mst.S_CNTR_CODE);
                if (startLoc != null)
                {
                    // 创建出库任务
                    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




        /// <summary>
        /// 错误日志记录
        /// </summary>
        /// <param name="ex">错误信息</param>
        private static void LogErrorDetails(Exception ex)
        {
            var st = new System.Diagnostics.StackTrace(ex, true);
            var frame = st.GetFrame(0);
            if (frame == null) return;

            var errorDetails = new StringBuilder()
                .AppendLine($"错误信息: {ex.Message}")
                .AppendLine($"文件名: {frame.GetFileName()}")
                .AppendLine($"行号: {frame.GetFileLineNumber()}")
                .AppendLine($"列号: {frame.GetFileColumnNumber()}")
                .ToString();

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





        /// <summary>
        /// 循环入库缓存区查询合托工位和入库接驳位是否有空货位（创建任务）
        /// </summary>
        /// <returns></returns>
        internal static bool BatchInWork()
        {
            try
            {
                bool res = false;
                //杭氧所有库区
                var reservoirs = Settings.ReservoirAreas.ToList();
                if (!reservoirs.Any() || reservoirs == null)
                {
                    LogHelper.Info("Settings出现错误未查询到的杭氧库区！", "杭氧");
                    return false;
                }

                var rkAnyLoc = reservoirs.Where(s => s.areaName == "入库缓存区").FirstOrDefault();
                if (rkAnyLoc == null)
                {
                    LogHelper.Info("Settings出现错误未查询到入库缓存区！", "杭氧");
                    return false;
                }

                //合托逻辑
                var cntrAbouts = ContainerHelper.GetCntrAbouts(rkAnyLoc.areaCode, "合托").FirstOrDefault();
                if (cntrAbouts != null)
                {
                    var area = reservoirs.Where(s => s.areaName == "合托区").FirstOrDefault();
                    if (area != null)
                    {
                        //1.查询合托工位的状态
                        var anyLoc = LocationHelper.GetLocAreaList(area.areaCode);
                        if (anyLoc.Any())
                        {
                            var list = WMSHelper.GetWmsTaskList("执行", cntrAbouts.S_CNTR_CODE);
                            if (list == null)
                            {
                                LogHelper.Info($"未查询到在执行中的作业:{cntrAbouts.S_CNTR_CODE}！", "杭氧");
                                return false;
                            }
                            //1.2创建码盘合托入库的任务，同时生成一个码盘合托出库的任务
                            //查询下要出库合托的托盘
                            var locMerge = WMSHelper.GetLocMerge(cntrAbouts.S_CNTR_CODE);
                            if (locMerge == null)
                            {
                                return false;
                            }

                            //生成一条出库的任务
                            var relevancys = Settings.Relevancys.Where(s => s.InLoc == anyLoc.FirstOrDefault().S_CODE).FirstOrDefault();
                            if (relevancys == null)
                            {
                                LogHelper.Info("Settings出现错误未查询到合托入库位对应的出库位！", "杭氧");
                                return false;
                            }
                            //生成到合托区的任务
                            res = TaskProcess.HYCreateTransport(cntrAbouts.S_LOC_CODE, anyLoc.FirstOrDefault().S_CODE, "码盘合托入库", cntrAbouts.S_CNTR_CODE, list.S_CODE);
                            if (!res)
                            {
                                LogHelper.Info("码盘合托入库任务创建失败！", "杭氧");
                                return false;
                            }
                            res = TaskProcess.HYCreateTransport(locMerge.S_LOC_CODE, relevancys.OutLoc, "码盘合托出库", locMerge.S_CNTR_CODE, list.S_CODE);
                            if (!res)
                            {
                                LogHelper.Info("码盘合托出库任务创建失败！", "杭氧");
                                return false;
                            }
                        }
                    }
                    else
                    {
                        LogHelper.Info("Settings出现错误未查询到合托区！", "杭氧");
                        return false;
                    }
                }

                //不合托逻辑
                var noCntrAbouts = ContainerHelper.GetCntrAbouts(rkAnyLoc.areaCode, "不合托").FirstOrDefault();
                if (noCntrAbouts != null)
                {
                    //2.查询入库接驳位的状态
                    var area = reservoirs.Where(s => s.areaName == "入库接驳位").FirstOrDefault();
                    if (area != null)
                    {
                        var anyLoc = LocationHelper.GetLocAreaList(area.areaCode);
                        if (anyLoc.Any())
                        {
                            var list = WMSHelper.GetWmsTaskList("执行", noCntrAbouts.S_CNTR_CODE);
                            if (list == null)
                            {
                                LogHelper.Info($"未查询到在执行中的作业:{noCntrAbouts.S_CNTR_CODE}！", "杭氧");
                                return false;
                            }
                            //2.2如果入库接驳位为空创建码盘接驳入库的任务
                            //生成到接驳位的任务
                            res = TaskProcess.HYCreateTransport(noCntrAbouts.S_LOC_CODE, anyLoc.FirstOrDefault().S_CODE, "码盘接驳入库", noCntrAbouts.S_CNTR_CODE, list.S_CODE);
                            if (!res)
                            {
                                LogHelper.Info("码盘接驳入库任务创建失败！", "杭氧");
                                return false;
                            }
                        }
                    }
                    else
                    {
                        LogHelper.Info("Settings出现错误未查询到入库接驳位！", "杭氧");
                        return false;
                    }
                }

                //料箱合托逻辑
                var lxCntrAbouts = ContainerHelper.GetCntrAbouts(rkAnyLoc.areaCode, "料箱合托").FirstOrDefault();
                if (lxCntrAbouts != null)
                {
                    //2.查询入库接驳位的状态
                    var area = reservoirs.Where(s => s.areaName == "料箱入库缓存位").FirstOrDefault();
                    if (area != null)
                    {
                        var anyLoc = LocationHelper.GetLocAreaList(area.areaCode);
                        if (anyLoc.Any())
                        {
                            var list = WMSHelper.GetWmsTaskList("执行", lxCntrAbouts.S_CNTR_CODE);
                            if (list == null)
                            {
                                LogHelper.Info($"未查询到在执行中的作业:{lxCntrAbouts.S_CNTR_CODE}！", "杭氧");
                                return false;
                            }
                            //生成到接驳位的任务
                            res = TaskProcess.HYCreateTransport(lxCntrAbouts.S_LOC_CODE, anyLoc.FirstOrDefault().S_CODE, "料箱缓存入库", lxCntrAbouts.S_CNTR_CODE, list.S_CODE);
                            if (!res)
                            {
                                LogHelper.Info("料箱缓存入库任务创建失败！", "杭氧");
                                return false;
                            }
                        }
                    }
                    else
                    {
                        LogHelper.Info("Settings出现错误未查询到料箱入库缓存位！", "杭氧");
                        return false;
                    }
                }

                return res;
            }
            catch (Exception ex)
            {
                var st = new System.Diagnostics.StackTrace(ex, true);
                var frame = st.GetFrame(0); // 获取第一个堆栈帧
                if (frame != null)
                {
                    LogHelper.Error($"BatchInWork循环入库缓存区出现错误！！", ex);
                    LogHelper.Error($"文件名: {frame.GetFileName()}", ex);
                    LogHelper.Error($"行号: {frame.GetFileLineNumber()}", ex);
                    LogHelper.Error($"列号: {frame.GetFileColumnNumber()}", ex);
                }
                return false;
            }

        }

        /// <summary>
        /// WCS调用设备信号反馈
        /// </summary>
        /// <param name="model">请求参数</param>
        /// <returns></returns>
        public static async Task<Result> notifyDeviceSignal(List<Wcsmodel> model)
        {
            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 && list.S_TYPE.Contains("回库"))
                        {
                            list.S_END_AREA = "TPLKQ";
                        }
                    }
                    if (list == null)
                    {
                        result.errMsg = "未查询到在等待中的作业！";
                        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.errMsg = "立库区未查询到可用货位！";
                        return result;
                    }

                    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, "");
                }


                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($"notifyDeviceSignalWCS调用设备信号反馈出现错误！！", ex);
                    LogHelper.Error($"文件名: {frame.GetFileName()}", ex);
                    LogHelper.Error($"行号: {frame.GetFileLineNumber()}", ex);
                    LogHelper.Error($"列号: {frame.GetFileColumnNumber()}", ex);
                }
                return result;
            }
        }

        /// <summary>
        /// 根据配盘单生成出库任务
        /// </summary>
        /// <param name="distributionCntr">配盘单</param>
        /// <returns></returns>
        internal static bool GenerateFromPicking(List<DistributionCntr> distributionCntr)
        {
            try
            {
                // 创建调度器
                var scheduler = new DoubleDeepOutboundScheduler(distributionCntr);

                var listOut = new List<Outbound>();
                foreach (var item in distributionCntr)
                {
                    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 = "配盘出库"
                    });
                }
                // 请求出库
                var tasks = scheduler.GenerateOutboundTasks(listOut);

                foreach (var item in tasks)
                {
                    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;
                                }
                            }
                        }
                    }
                }
                return true;
            }
            catch (Exception ex)
            {
                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);
                }
                return false;
            }

        }

        #endregion



    }
}