WcsFramework/YWGC/FJK/WCS.WorkEngineering/Systems/分拣支线/环形库分流点.cs

using PlcSiemens.Core.Extension;
using ServiceCenter.Extensions;
using ServiceCenter.Logs;
using ServiceCenter.SqlSugars;
using SqlSugar;
using System.ComponentModel;
using WCS.Core;
using WCS.Entity;
using WCS.Entity.Protocol.Station;
using WCS.WorkEngineering.Extensions;
using WCS.WorkEngineering.Model.WMS;
using WCS.WorkEngineering.WebApi.Controllers;
using WCS.WorkEngineering.WebApi.Models.WMS.Request;
using WCS.WorkEngineering.Worlds;
using TaskStatus = WCS.Entity.TaskStatus;

namespace WCS.WorkEngineering.Systems
{
    /// <summary>
    ///  分流点
    /// </summary>
    [BelongTo(typeof(SortingBranchWorld))]
    [Description("环形库分流点")]
    public class 环形库分流点 : DeviceSystem<Device<IStation520, IStation521, IStation523, IStation91>>
    {
        protected override bool ParallelDo => true;

        public override void Do(Device<IStation520, IStation521, IStation523, IStation91> obj)
        {
            #region 执行条件检查

            if (CheckVoucherNoMismatch(obj)) return;
            if (obj.Data3.Status.HasFlag(StationStatus.Run))
            {
                World.Log("设备运行中");
                return;
            }
            if (!obj.Data3.Status.HasFlag(StationStatus.OT_Status))
            {
                World.Log("站台货物信息与实际占用不一致", LogLevelEnum.Mid);
                return;
            }
            if (!obj.Data3.Status.HasFlag(StationStatus.PH_Status))
            {
                World.Log("站台无光电信息", LogLevelEnum.Mid);
                return;
            }
            if (obj.Data2.Request != 1)
            {
                World.Log("无请求", LogLevelEnum.Mid);
                return;
            }

            #endregion 执行条件检查

            var isPut = false;
            var nextAdd = GetNext(obj);
            if (nextAdd == 9999) return;
            var goodsType = obj.Data4.Length.ToInt();
            int taskId = 0;
            SqlSugarHelper.Do(_db =>
            {
                var db = _db.Default;

                WCS_TaskInfo? taskInfo = null;

                #region 处理异常任务

                if (obj.Data2.TaskNumber == 1 || obj.Data2.TaskNumber == 3 || obj.Data2.TaskNumber == 2)
                {
                    if (HandleExceptionTask(db, taskInfo, obj.Entity.Code, obj.Data2.TaskNumber, goodsType)) return;
                }

                #endregion 处理异常任务

                taskInfo = db.Queryable<WCS_TaskInfo>().NoLock().First(v => v.ID == obj.Data2.TaskNumber && v.Status < TaskStatus.FinishOfShunt);
                if (taskInfo == null)
                {
                    taskInfo = db.Queryable<WCS_TaskInfo>().NoLock().First(x => x.AddrFrom == obj.Entity.Code && x.BarCode.Contains("Error") && x.Status == TaskStatus.WaitingToExecute && x.AddrNext == null && x.GoodsType == goodsType);
                    if (taskInfo == null)
                    {
                        World.Log($"未找到对应的WCS任务{obj.Data2.TaskNumber}，1", LogLevelEnum.High);
                        return;
                    }
                }

                if (taskInfo.AddTime < DateTime.Now.AddHours(-12) && obj.Data2.TaskNumber == taskInfo.ID)
                {
                    obj.Data.TaskNumber = 1;
                    obj.Data.GoodsEnd = obj.Entity.Code.ToShort();
                    obj.Data.VoucherNo++;
                    World.Log($"超时执行记录:任务号[{taskInfo.ID}]-[{obj.Data.TaskNumber}]-[{obj.Data.VoucherNo}]");
                    return;
                }
                if (taskInfo.Grade != null && (taskInfo.Grade.ToUpper() != "A") && obj.Data2.TaskNumber == taskInfo.ID)
                {
                    obj.Data.TaskNumber = 3;
                    obj.Data.GoodsEnd = obj.Entity.Code.ToShort();
                    obj.Data.VoucherNo++;
                    World.Log($"BC执行记录:任务号[{taskInfo.ID}]-[{obj.Data.TaskNumber}]-[{obj.Data.VoucherNo}]");
                    return;
                }

                if (!taskInfo.BarCode.Contains("Error"))
                {
                    switch (goodsType)
                    {
                        case 9 when !taskInfo.BarCode.Contains("HAWS09"):
                            World.Log($"外检结果与任务条码不匹配--外检结果:[{goodsType}]-条码[{taskInfo.BarCode}]", LogLevelEnum.High);
                            return;

                        case 18 when !taskInfo.BarCode.Contains("HAWS18"):
                            World.Log($"外检结果与任务条码不匹配--外检结果:[{goodsType}]-条码[{taskInfo.BarCode}]", LogLevelEnum.High);
                            return;

                        case 34 when !taskInfo.BarCode.Contains("HAWS34"):
                            World.Log($"外检结果与任务条码不匹配--外检结果:[{goodsType}]-条码[{taskInfo.BarCode}]", LogLevelEnum.High);
                            return;

                        case 50 when !taskInfo.BarCode.Contains("HAWS50"):
                            World.Log($"外检结果与任务条码不匹配--外检结果:[{goodsType}]-条码[{taskInfo.BarCode}]", LogLevelEnum.High);
                            return;
                    }
                }

                switch (obj.Entity.Code)
                {
                    case "418":
                        if (taskInfo.WarehouseCode != "1N")
                        {
                            if (taskInfo.WarehouseCode.Contains("N"))
                            {
                                EditFlow(taskInfo, "1N", db, obj.Entity.Code);
                                return;
                            }

                            WriteInfo(obj, taskInfo);
                            return;
                        }

                        break;

                    case "618":
                        if (taskInfo.WarehouseCode != "1S")
                        {
                            if (taskInfo.WarehouseCode.Contains("S"))
                            {
                                EditFlow(taskInfo, "1S", db, obj.Entity.Code);
                                return;
                            }

                            WriteInfo(obj, taskInfo);
                            return;
                        }

                        break;

                    case "818":
                        if (taskInfo.WarehouseCode != "2N")
                        {
                            if (taskInfo.WarehouseCode.Contains("N"))
                            {
                                EditFlow(taskInfo, "2N", db, obj.Entity.Code);
                                return;
                            }
                            WriteInfo(obj, taskInfo);
                            return;
                        }

                        break;

                    case "1018":
                        if (taskInfo.WarehouseCode != "2S")
                        {
                            if (taskInfo.WarehouseCode.Contains("S"))
                            {
                                EditFlow(taskInfo, "2S", db, obj.Entity.Code);
                                return;
                            }

                            WriteInfo(obj, taskInfo);
                            return;
                        }

                        break;

                    case "1218":
                        if (taskInfo.WarehouseCode != "3N")
                        {
                            if (taskInfo.WarehouseCode.Contains("N"))
                            {
                                EditFlow(taskInfo, "3N", db, obj.Entity.Code);
                                return;
                            }

                            WriteInfo(obj, taskInfo);
                            return;
                        }

                        break;

                    case "1418":
                        if (taskInfo.WarehouseCode != "3S")
                        {
                            if (taskInfo.WarehouseCode.Contains("S"))
                            {
                                EditFlow(taskInfo, "3S", db, obj.Entity.Code);
                                return;
                            }

                            WriteInfo(obj, taskInfo);
                            return;
                        }

                        break;
                }

                var isTruss = false; //表示这个工字轮是要去桁架区域码垛的，默认不作处理
                if (goodsType == 18)
                {
                    //判断这个垛型是否是到桁架区域进行码垛
                    var toTruss = db.Queryable<BillBomsetgrp>().NoLock().First(x => x.BomCode.Contains(taskInfo.MatCode) && x.IsStop == 0);
                    if (toTruss == null)
                    {
                        World.Log($"未找到任务{taskInfo.ID}对应垛型信息，请确认垛型是否停用", LogLevelEnum.Mid);
                        return;
                    }

                    if (toTruss.IsTruss)
                    {
                        nextAdd = obj.Entity.Code switch
                        {
                            "418" => 455,
                            "618" => 655,
                            "818" => 855,
                            "1018" => 1055,
                            "1218" => 1255,
                            "1418" => 1455,
                            _ => 9999
                        };
                        isTruss = true;
                    }
                }
                taskInfo = db.Queryable<WCS_TaskInfo>().ReadPastUpdLock().First(v => v.ID == obj.Data2.TaskNumber && v.Status < TaskStatus.FinishOfShunt && !v.BarCode.Contains("Error"));
                if (taskInfo == null)
                {
                    taskInfo = db.Queryable<WCS_TaskInfo>().ReadPastUpdLock().First(x => x.AddrFrom == obj.Entity.Code && x.BarCode.Contains("Error") && x.Status == TaskStatus.WaitingToExecute && x.AddrNext == null && x.GoodsType == goodsType);
                    if (taskInfo == null)
                    {
                        World.Log($"未找到对应的WCS任务{obj.Data2.TaskNumber}，2", LogLevelEnum.Mid);
                        return;
                    }
                    ;
                }
                taskId = taskInfo.ID;
                if (goodsType != 9 && !isTruss) //09工字轮在环形库分流点只分配下一个地址，不作任何变更
                {
                    //判断是否为直接码垛
                    var robot = GetRobotDevice(obj.Entity);
                    if (robot == null)
                    {
                        World.Log($"未检索到对应的机械臂设备号", LogLevelEnum.High);
                        return;
                    }
                    if (robot.GetIsDirectPalletizing(db)) //是直接码垛
                    {
                        var warehouseCode = taskInfo.WarehouseCode.Contains("R") ? taskInfo.WarehouseCode : taskInfo.WarehouseCode + "R";
                        var wareHouse = db.Queryable<BaseWarehouse>().First(x => x.Code == warehouseCode);
                        //获取两个对应的环形库码垛工位
                        List<string> maDuoZhanTaiList = new List<string>();
                        switch (robot.Code)
                        {
                            case "Robot1":
                                maDuoZhanTaiList.Add("1661");
                                maDuoZhanTaiList.Add("1666");
                                break;

                            case "Robot2":
                                maDuoZhanTaiList.Add("1676");
                                maDuoZhanTaiList.Add("1681");
                                break;

                            case "Robot3":
                                maDuoZhanTaiList.Add("1691");
                                maDuoZhanTaiList.Add("1696");
                                break;

                            case "Robot4":
                                maDuoZhanTaiList.Add("1706");
                                maDuoZhanTaiList.Add("1711");
                                break;

                            case "Robot5":
                                maDuoZhanTaiList.Add("1721");
                                maDuoZhanTaiList.Add("1726");
                                break;

                            case "Robot6":
                                maDuoZhanTaiList.Add("1736");
                                maDuoZhanTaiList.Add("1741");
                                break;
                        }

                        #region 判断两个位置是否都有码垛信息，为没有的创建码垛信息

                        var maDuoXinXiList = db.Queryable<BillRingPalletizingInfo>().Where(x => maDuoZhanTaiList.Contains(x.MaDuoGongWei) && x.Out == false).ToList();

                        bool isCreateStackingInfo = false;
                        foreach (var maDuoZhanTai in maDuoZhanTaiList)
                        {
                            if (!maDuoXinXiList.Any(x => x.MaDuoGongWei == maDuoZhanTai))
                            {
                                if (CreateStackingInfo(db, taskInfo, wareHouse, maDuoZhanTai)) continue;
                                isCreateStackingInfo = true;
                            }
                        }
                        if (isCreateStackingInfo) return;

                        #endregion 判断两个位置是否都有码垛信息，为没有的创建码垛信息

                        #region 选取创建事件已分分配任务数量较多、或者创建事件较早的码垛信息,默认一个库就跑一个垛型，多个垛型会混料

                        maDuoXinXiList = db.Queryable<BillRingPalletizingInfo>().Where(x => maDuoZhanTaiList.Contains(x.MaDuoGongWei) && x.Out == false).ToList().OrderByDescending(x => x.HaveQty).ThenBy(x => x.AddTime).ToList();
                        if (maDuoXinXiList.Any(x => x.HWCountQty != x.HaveQty))
                        {
                            var maDuoXinXi = maDuoXinXiList.Where(x => x.HWCountQty != x.HaveQty).First(); //获取一个应该分配目标

                            //分配当前轮子在垛形中的位置
                            if (wareHouse.Code.Contains("N")) //北侧由大到小，出的时候刚好可用反过来;
                            {
                                //取当前任务SKU在任务中已有的信息
                                var taksList = db.Queryable<WCS_TaskInfo>().Where(x => x.TaskGroupKey == maDuoXinXi.Id.ToString()).ToList();

                                if (taksList.Count != maDuoXinXi.HaveQty)
                                {
                                    World.Log($"码垛信息组【{maDuoXinXi.Id}】记录已有【{maDuoXinXi.HaveQty}】个轮子，但对应的任务信息有【{taksList.Count}】，请在WMS检查对应的任务信息", LogLevelEnum.High);
                                    return;
                                }

                                var cellMatCodeList = taksList.Where(x => x.MatCode == taskInfo.MatCode);
                                //取当前SKU在垛形明细中所有的信息
                                var bomSetInfos = db.Queryable<BillBomsetinfo>().Where(x =>
                                     x.BomSetHdrId == maDuoXinXi.BomSetGrpId && x.IsEmpty == 0 &&
                                     x.MatCode == taskInfo.MatCode).ToList();
                                //取当前SKU在垛形明细中最大的一个坐标号，初始化时默认取第一个
                                var lastXYNO = Convert.ToInt32(bomSetInfos.Select(x => Convert.ToInt32(x.XYNo))
                                    .OrderByDescending(x => x).First());
                                if (cellMatCodeList.Any()) //货位中已有当前SKU的产品，取最小数,最小数表示最近入库的
                                {
                                    lastXYNO = cellMatCodeList.OrderBy(x => x.WmsTask).First().WmsTask;
                                    var xyNo = bomSetInfos.Select(x => Convert.ToInt32(x.XYNo)).Where(x => x < lastXYNO).OrderByDescending(x => x).First();
                                    maDuoXinXi.LastXYNO = xyNo;
                                }
                                else
                                {
                                    maDuoXinXi.LastXYNO = lastXYNO;
                                }
                            }
                            else //南侧小到大，出的时候刚好可用反过来;
                            {
                                //取当前任务SKU在任务中已有的信息
                                var taksList = db.Queryable<WCS_TaskInfo>().Where(x => x.TaskGroupKey == maDuoXinXi.Id.ToString()).ToList();
                                if (taksList.Count != maDuoXinXi.HaveQty)
                                {
                                    World.Log($"码垛信息组【{maDuoXinXi.Id}】记录已有【{maDuoXinXi.HaveQty}】个轮子，但对应的任务信息有【{taksList.Count}】，请在WMS检查对应的任务信息", LogLevelEnum.High);
                                    return;
                                }

                                var cellMatCodeList = taksList.Where(x => x.MatCode == taskInfo.MatCode);
                                //取当前SKU在垛形明细中所有的信息
                                var bomSetInfos = db.Queryable<BillBomsetinfo>().Where(x =>
                                    x.BomSetHdrId == maDuoXinXi.BomSetGrpId && x.IsEmpty == 0 &&
                                    x.MatCode == taskInfo.MatCode).ToList();
                                //取当前SKU在垛形明细中最小的一个坐标号 ,初始化时默认取第一个
                                var lastXYNO = Convert.ToInt32(bomSetInfos.Select(x => Convert.ToInt32(x.XYNo)).OrderBy(x => x).First());

                                if (cellMatCodeList.Any()) //货位中已有当前SKU的产品，取最大数 最大数表示最近入库的
                                {
                                    lastXYNO = cellMatCodeList.OrderByDescending(x => x.WmsTask).First().WmsTask;
                                    var xyNo = bomSetInfos.Select(x => Convert.ToInt32(x.XYNo)).Where(x => x > lastXYNO)
                                        .OrderBy(x => x).First();
                                    maDuoXinXi.LastXYNO = xyNo;
                                }
                                else
                                {
                                    maDuoXinXi.LastXYNO = lastXYNO;
                                }
                            }

                            //检查分配位置是否已经分配过
                            if (db.Queryable<WCS_TaskInfo>().NoLock().Any(x => x.TaskGroupKey == maDuoXinXi.Id.ToString() && x.WmsTask == maDuoXinXi.LastXYNO))
                            {
                                World.Log($"当前位置已经被分配过了，请检查异常码垛信息{maDuoXinXi.Id}-{maDuoXinXi.LastXYNO}", LogLevelEnum.High);
                                return;
                            }

                            #region 更新码垛、任务相关信息

                            // 获取下一个地址
                            nextAdd = maDuoXinXi.MaDuoGongWei switch
                            {
                                "1661" => 435,
                                "1666" => 444,
                                "1676" => 635,
                                "1681" => 644,
                                "1691" => 835,
                                "1696" => 844,
                                "1706" => 1035,
                                "1711" => 1044,
                                "1721" => 1235,
                                "1726" => 1244,
                                "1736" => 1435,
                                "1741" => 1444,
                                _ => 9999
                            };

                            maDuoXinXi.HaveQty += 1;
                            taskInfo.AddrNext = nextAdd.ToString();
                            taskInfo.Status = TaskStatus.FinishOfShunt;
                            taskInfo.EditTime = DateTime.Now;
                            taskInfo.WarehouseCode = taskInfo.WarehouseCode.Contains("R") ? taskInfo.WarehouseCode : taskInfo.WarehouseCode + "R";
                            taskInfo.AddrTo = "Robot";
                            taskInfo.WmsTask = maDuoXinXi.LastXYNO;
                            taskInfo.TaskGroupKey = maDuoXinXi.Id.ToString();
                            taskInfo.GoodsType = goodsType;
                            db.UpdateableRowLock(taskInfo).UpdateColumns(x => new { x.AddrNext, x.Status, x.EditTime, x.WarehouseCode, x.AddrTo, x.GoodsType, x.WmsTask, x.TaskGroupKey }).ExecuteCommand();
                            taskInfo.AddWCS_TASK_DTL(db, obj.Entity.Code, nextAdd.ToString(), "工字轮完成环形库分流");
                            db.Updateable(maDuoXinXi).UpdateColumns(x => new { x.LastXYNO, x.HaveQty }).ExecuteCommand();

                            #endregion 更新码垛、任务相关信息
                        }
                        else //创建一个码垛信息
                        {
                            var maDuoXinXi = maDuoXinXiList.Where(x => x.HWCountQty == x.HaveQty).OrderBy(x => x.AddTime).FirstOrDefault(); //获取一个已分配完成，但未码垛结束的目标
                            CreateStackingInfo(db, taskInfo, wareHouse, maDuoXinXi.MaDuoGongWei);
                            return;
                        }

                        #endregion 选取创建事件已分分配任务数量较多、或者创建事件较早的码垛信息,默认一个库就跑一个垛型，多个垛型会混料
                    }
                    else
                    {
                        taskInfo.AddrNext = nextAdd.ToString();
                        taskInfo.Status = TaskStatus.FinishOfShunt;
                        taskInfo.EditTime = DateTime.Now;
                        taskInfo.WarehouseCode = taskInfo.WarehouseCode.Contains("R") ? taskInfo.WarehouseCode : taskInfo.WarehouseCode + "R";
                        taskInfo.AddrTo = "Robot";
                        taskInfo.GoodsType = goodsType;
                        db.UpdateableRowLock(taskInfo).UpdateColumns(x => new { x.AddrNext, x.Status, x.EditTime, x.WarehouseCode, x.AddrTo, x.GoodsType }).ExecuteCommand();
                        taskInfo.AddWCS_TASK_DTL(db, obj.Entity.Code, nextAdd.ToString(), "工字轮完成环形库分流");
                    }
                }
                else
                {
                    taskInfo.AddrNext = nextAdd.ToString();
                    taskInfo.EditTime = DateTime.Now;
                    taskInfo.GoodsType = goodsType;
                    db.UpdateableRowLock(taskInfo).UpdateColumns(x => new { x.AddrNext, x.EditTime, x.GoodsType }).ExecuteCommand();
                    taskInfo.AddWCS_TASK_DTL(db, obj.Entity.Code, nextAdd.ToString(), "工字轮途径环形库分流点");
                }
                isPut = true;
            });
            if (!isPut) return;
            obj.Data.TaskNumber = taskId;
            obj.Data.TaskNumber = taskId;
            obj.Data.GoodsStart = obj.Entity.Code.ToShort();
            obj.Data.GoodsStart = obj.Entity.Code.ToShort();
            obj.Data.GoodsEnd = nextAdd;
            obj.Data.GoodsEnd = nextAdd;
            obj.Data.SetVoucherNo();
            World.Log($"执行记录:任务号[{taskId}]-[{obj.Data.VoucherNo}]");
        }

        private void WriteInfo(Device<IStation520, IStation521, IStation523, IStation91> device, WCS_TaskInfo task)
        {
            device.Data.TaskNumber = 2;
            device.Data.GoodsEnd = device.Entity.Code.ToShort();
            device.Data.VoucherNo++;
            World.Log($"南北流错执行记录:任务号[{task.ID}]-[{device.Data.TaskNumber}]-[{device.Data.VoucherNo}]");
        }

        /// <summary>
        ///  编辑流向
        /// </summary>
        public void EditFlow(WCS_TaskInfo task, string warehouseCode, SqlSugarScopeProvider db, string locCode)
        {
            WmsApi.EditorialFlow(new FjEditorialFlowRequest() { TaskId = task.ID, LocCode = locCode, WareCode = warehouseCode });
            task.WarehouseCode = warehouseCode;
            db.UpdateableRowLock(task).UpdateColumns(x => new { x.WarehouseCode }).ExecuteCommand();
            task.AddWCS_TASK_DTL(db, locCode, $"变更流向至{warehouseCode}");
        }

        public override bool Select(Device dev)
        {
            return dev.Code is "418" or "618" or "818" or "1018" or "1218" or "1418";
        }

        /// <summary>
        ///  检查凭证号是否满足条件
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        private bool CheckVoucherNoMismatch(Device<IStation520, IStation521, IStation523, IStation91> obj)
        {
            if (obj.Data.VoucherNo != obj.Data2.VoucherNo)
            {
                if (obj.Data2.TaskNumber != 0 && obj.Data2.TaskNumber != 2)
                {
                    obj.Data.TaskNumber = obj.Data2.TaskNumber;
                    World.Log($"复写:{obj.Data.TaskNumber}");
                }
                World.Log($"凭证号不一致,DB520:{obj.Data.VoucherNo}-DB521:{obj.Data2.VoucherNo}", LogLevelEnum.Mid);
                return true;
            }
            return false;
        }

        /// <summary>
        ///  处理异常任务
        /// </summary>
        /// <param name="db">数据库连接</param>
        /// <param name="taskInfo">任务信息</param>
        /// <param name="addrFrom">异常任务起始地址，即当前设备号</param>
        /// <param name="devTaskNumber">设备中的任务号</param>
        /// <param name="goodsType">产品类型,即外检结果</param>
        /// <returns></returns>
        private bool HandleExceptionTask(SqlSugarScopeProvider db, WCS_TaskInfo? taskInfo, string addrFrom, int devTaskNumber, int goodsType)
        {
            var type = goodsType.ToString();
            //找到一条起点是当前位置且状态小于2的任务
            taskInfo = db.Queryable<WCS_TaskInfo>().NoLock().OrderBy(x => x.AddTime).First(x => x.Status < TaskStatus.FinishOfShunt && x.AddrFrom == addrFrom && x.BarCode.Contains("Error") && x.AddrNext == null && x.GoodsType == goodsType);
            if (taskInfo == null)
            {
                switch (devTaskNumber)
                {
                    case 1:
                        WmsApi.PalletizingCreateseErrorTasks(addrFrom, type);
                        break;

                    case 3: //bc质量
                        WmsApi.PalletizingCreateseErrorTasks(addrFrom, type, 3);
                        break;

                    case 2: //南北流错
                        WmsApi.PalletizingCreateseErrorTasks(addrFrom, type, 2);
                        break;
                }

                return true;
            }
            if (taskInfo.Status == TaskStatus.NewBuild)
            {
                //更新任务状态
                taskInfo.Status = TaskStatus.WaitingToExecute;
                taskInfo.EditTime = DateTime.Now;
                taskInfo.EditWho = "WCS";
                db.UpdateableRowLock(taskInfo).ExecuteCommand();
                taskInfo.AddWCS_TASK_DTL(db, addrFrom, $"初始化异常轮入库任务信息");
                return true;
            }
            return false;
        }

        /// <summary>
        ///  创建一条码垛信息
        /// </summary>
        /// <param name="db">数据库连接</param>
        /// <param name="taskInfo">任务信息</param>
        /// <param name="wareHouse">仓库信息</param>
        /// <param name="maDuoGongWei">码垛工位</param>
        /// <returns></returns>
        private bool CreateStackingInfo(SqlSugarScopeProvider db, WCS_TaskInfo taskInfo, BaseWarehouse wareHouse, string maDuoGongWei)
        {
            var bomsetGrp = db.Queryable<BillBomsetgrp>().NoLock().First(x => x.IsStop == 0 && x.BomCode.Contains(taskInfo.MatCode));
            if (bomsetGrp == null)
            {
                World.Log($"未找到对应垛型信息，请确认是否被禁用", LogLevelEnum.High);
                return true;
            }
            var xyNo = db.Queryable<BillBomsetinfo>().NoLock().Where(x => x.BomSetHdrId == bomsetGrp.Id && x.IsEmpty == 0)
                .ToList().Select(x => Convert.ToInt32(x.XYNo)).OrderByDescending(x => x).First();

            //跟据垛形信息生成
            var ringPalletizingInfo = new BillRingPalletizingInfo
            {
                Id = IdFactory.NewId(),
                WareHouseId = wareHouse.Id,
                BomSetGrpId = bomsetGrp.Id,
                HWCountQty = bomsetGrp.HWCountQty,
                BomCode = bomsetGrp.BomCode,
                HaveQty = 0,
                Out = false,
                LastXYNO = wareHouse.Code.Contains("N") ? xyNo + 1 : 0,
                MaDuoGongWei = maDuoGongWei
            };

            db.Insertable(ringPalletizingInfo);
            return false;
        }

        /// <summary>
        ///  计算非零九的去向
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public short GetNext(Device<IStation520, IStation521, IStation523, IStation91> obj)
        {
            return obj.Data4.Length switch
            {
                9 => obj.Entity.Code switch
                {
                    "418" => 455,
                    "618" => 655,
                    "818" => 855,
                    "1018" => 1055,
                    "1218" => 1255,
                    "1418" => 1455,
                    _ => 9999
                },
                18 => obj.Entity.Code switch
                {
                    "418" => 444,
                    "618" => 644,
                    "818" => 844,
                    "1018" => 1044,
                    "1218" => 1244,
                    "1418" => 1444,
                    _ => 9999
                },
                50 => obj.Entity.Code switch
                {
                    "418" => 426,
                    "618" => 626,
                    "818" => 826,
                    "1018" => 1026,
                    "1218" => 1226,
                    "1418" => 1426,
                    _ => 9999
                },
                34 => obj.Entity.Code switch
                {
                    "418" => 435,
                    "618" => 635,
                    "818" => 835,
                    "1018" => 1035,
                    "1218" => 1235,
                    "1418" => 1435,
                    _ => 9999
                },
                _ => 9999
            };
        }

        public Device? GetRobotDevice(Device dev)
        {
            var robotCode = dev.Code switch
            {
                "418" => "Robot1",
                "618" => "Robot2",
                "818" => "Robot3",
                "1018" => "Robot4",
                "1218" => "Robot5",
                "1418" => "Robot6",
                _ => "99999"
            };

            return Device.All.FirstOrDefault(v => v.Code == robotCode);
        }
    }
}