YG-OPP-WCS/Projects/永冠OPP/WCS.Service/Works/Station/涂布入库.cs

using DBHelper;
using Microsoft.EntityFrameworkCore;
using System;
using System.Collections.Generic;
using System.Linq;
using WCS.Core;
using WCS.Entity;
using WCS.Entity.Protocol;
using WCS.Entity.Protocol.SRM;
using WCS.Service.Extensions;
using WCS.Service.Handlers;
using WCS.Service.Helpers;
using WCS.Service.Log;

namespace WCS.Service.Works.Station
{
    /// <summary>
    /// 涂布入库AGV交互
    /// </summary>
    [WorkTitle(typeof(CoatingHandler), "涂布入库AGV交互")]
    public class 涂布入库agv交互 : Work<StationDeviceGroup>
    {
        protected override void Do(StationDeviceGroup obj)
        {
            obj.EX(stationDeviceGroup =>
            {
                var station = stationDeviceGroup.Entity.CODE;

                #region 处理新增AGV任务

                DB.Do(db =>
                {
                    //找到所有的AGV任务
                    var agvTasks = db.Default.Set<WCS_AGVTask>().Where(v => v.TaskType == AGVTaskType.入库)
                    .Where(v => v.Status < AGVTaskStatus.完成).OrderByDescending(v => v.Status).ThenBy(v => v.CreateTime).ToArray();

                    foreach (var tasking in agvTasks)
                    {
                        var position = tasking.Position;
                        if (!ProtocolProxy.AllDatas.ContainsKey(position))
                            ProtocolProxy.AllDatas[position] = new ProdLineData();
                        var pld = ProtocolProxy.AllDatas[position] as ProdLineData;
                        pld!.Frame = LogicHandler.Frame;
                        pld.Code = position;
                        pld.TaskList.Add(tasking);

                        if (tasking.Status == AGVTaskStatus.新建)
                        {
                            var qty = db.Default.Set<WCS_AGVTask>().Where(v => v.TaskType == AGVTaskType.入库 && v.Status > AGVTaskStatus.新建 && v.Status < AGVTaskStatus.完成);
                            //同时最多只能有10个任务被确认
                            if (qty.Count() >= 10)
                            {
                                InfoLog.INFO_WarnDb($"{stationDeviceGroup.Entity.CODE}正在执行的入库任务数量已达{qty.Count()},暂停入库", stationDeviceGroup.Entity.CODE, WCS_EXCEPTIONTYPE.逻辑异常);
                                continue;
                            }

                            tasking.Status = AGVTaskStatus.执行;
                            tasking.UpdateTime = DateTime.Now;
                            db.Default.SaveChanges();
                            tasking.AGVStatusChange(AGVTaskStatus.执行, "变更");
                            return;
                        }
                        //agv到达指定位置给确认后分配站台
                        else if (tasking.Status == AGVTaskStatus.执行 && tasking.AGVStatus == AGVTaskStatus.确认 && string.IsNullOrEmpty(tasking.Station))
                        {
                            //判断提升机是否被禁用
                            stationDeviceGroup.BcrStationIsForbid();

                            if (stationDeviceGroup.Items.Any(v => !v.Data3.Status.HasFlag(StationStatus.自动)))
                            {
                                InfoLog.INFO_INFO($"{station}手动状态");
                                continue;
                            }

                            var qty = db.Default.Set<WCS_AGVTask>().Where(v => v.TaskType == AGVTaskType.入库 && v.Status > AGVTaskStatus.新建 && v.Status < AGVTaskStatus.完成);
                            if (qty.Count(v => v.Station == stationDeviceGroup.Entity.CODE) > qty.Count(v => v.Station != stationDeviceGroup.Entity.CODE && !string.IsNullOrEmpty(v.Station)))
                            {
                                InfoLog.INFO_INFO($"{station}触发均分");
                                continue;
                            }

                            tasking.Station = stationDeviceGroup.Entity.CODE;
                            tasking.Status = AGVTaskStatus.执行;
                            tasking.UpdateTime = DateTime.Now;
                            db.Default.SaveChanges();
                            tasking.AGVStatusChange(AGVTaskStatus.执行, "变更");
                            return;
                        }
                        else if (tasking.Status < tasking.AGVStatus)
                        {
                            if (tasking.Station != stationDeviceGroup.Entity.CODE)
                            {
                                InfoLog.INFO_INFO($"{stationDeviceGroup.Entity.CODE}不是当前站台的AGV任务");
                                continue;
                            }
                            if (tasking.AGVStatus == AGVTaskStatus.请求_允许)
                            {
                                if (stationDeviceGroup.Items.Any(v => !v.Data3.Status.HasFlag(StationStatus.自动)))
                                {
                                    InfoLog.INFO_INFO("不在自动状态");
                                    continue;
                                }
                                if (stationDeviceGroup.Items.Any(v => v.Data3.Status.HasFlag(StationStatus.运行状态位)))
                                {
                                    InfoLog.INFO_INFO("设备运行中");
                                    continue;
                                }
                                if (stationDeviceGroup.Items.Any(v => !v.Data3.Status.HasFlag(StationStatus.高位)))
                                {
                                    InfoLog.INFO_WarnDb("不在高位", stationDeviceGroup.Entity.CODE, WCS_EXCEPTIONTYPE.设备异常);
                                    continue;
                                }
                                if (stationDeviceGroup.Items.Any(v => v.Data2.Status.HasFlag(IstationStatus.光电状态)))
                                {
                                    InfoLog.INFO_WarnDb("AGV请求放货,但有光电", stationDeviceGroup.Entity.CODE, WCS_EXCEPTIONTYPE.设备异常);
                                    continue;
                                }
                                if (stationDeviceGroup.Items.Any(v => v.Data2.Status.HasFlag(IstationStatus.AGV放货完成信号)))
                                {
                                    InfoLog.INFO_WarnDb("AGV放货完成信号未清除", stationDeviceGroup.Entity.CODE, WCS_EXCEPTIONTYPE.设备异常);
                                    continue;
                                }
                                if (stationDeviceGroup.Items.Any(v => v.Data2.Tasknum > 0))
                                {
                                    InfoLog.INFO_WarnDb("已有WCS任务号", stationDeviceGroup.Entity.CODE, WCS_EXCEPTIONTYPE.设备异常);
                                    continue;
                                }

                                if (db.Default.Set<WCS_AGVTask>().Any(v => v.Station == tasking.Station && v.Status >= AGVTaskStatus.请求_允许 && v.Status < AGVTaskStatus.完成扫码 && v.ID != tasking.ID)) //只能允许一个
                                {
                                    InfoLog.INFO_WarnDb("上一个允许放货的AGV任务未完成", stationDeviceGroup.Entity.CODE, WCS_EXCEPTIONTYPE.设备异常);
                                    continue;
                                }
                                //判断1435扫码位置条件
                                var judge = Device.Find("1435").Device<IStation520, IStation521, IStation523>();
                                if (stationDeviceGroup.Entity.CODE == "G1394")
                                {
                                    if (!judge.Data3.Status.HasFlag(StationStatus.自动))
                                    {
                                        InfoLog.INFO_INFO("不在自动状态1435");
                                        continue;
                                    }

                                    if (judge.Data3.Status.HasFlag(StationStatus.运行状态位))
                                    {
                                        InfoLog.INFO_INFO("设备运行中1435");
                                        continue;
                                    }

                                    //判断是否有货
                                    if (judge.Data2.Status.HasFlag(IstationStatus.光电状态))
                                    {
                                        InfoLog.INFO_WarnDb("前方有光电，不可放货", stationDeviceGroup.Entity.CODE, WCS_EXCEPTIONTYPE.设备异常);
                                        continue;
                                    }

                                    if (judge.Data2.Tasknum > 0)
                                    {
                                        InfoLog.INFO_WarnDb("已 有WCS任务号", stationDeviceGroup.Entity.CODE, WCS_EXCEPTIONTYPE.设备异常);
                                        continue;
                                    }
                                }

                                tasking.Status = tasking.AGVStatus;
                                tasking.UpdateTime = DateTime.Now;
                                db.Default.SaveChanges();
                                tasking.AGVStatusChange(tasking.AGVStatus);
                                return;
                            }
                            else if (tasking.AGVStatus == AGVTaskStatus.取放完成)
                            {
                                if (stationDeviceGroup.Items.Any(v => v.Data2.Status.HasFlag(IstationStatus.AGV放货完成信号)))
                                {
                                    InfoLog.INFO_WarnDb("AGV放货完成信号未清楚", stationDeviceGroup.Entity.CODE, WCS_EXCEPTIONTYPE.设备异常);
                                    continue;
                                }
                                if (!stationDeviceGroup.Items.Any(v => v.Data2.Status.HasFlag(IstationStatus.光电状态)))
                                {
                                    InfoLog.INFO_WarnDb("放货完成无光电", stationDeviceGroup.Entity.CODE, WCS_EXCEPTIONTYPE.设备异常);
                                    continue;
                                }

                                tasking.Status = tasking.AGVStatus;
                                tasking.UpdateTime = DateTime.Now;
                                db.Default.SaveChanges();
                                foreach (var dev in stationDeviceGroup.Items)
                                {
                                    if (!dev.Data2.Status.HasFlag(IstationStatus.光电状态)) continue;
                                    dev.Data.Goodsnum = (short)tasking.Goodsnum;
                                    dev.Data.Istation521Status = IstationStatus.AGV放货完成信号;
                                }
                                tasking.AGVStatusChange(tasking.AGVStatus);
                                return;
                            }
                            else if (Ltc.Do(tasking, v => v.AGVStatus == AGVTaskStatus.完成))
                            {
                                tasking.Status = tasking.AGVStatus;
                                tasking.UpdateTime = DateTime.Now;
                                db.Default.SaveChanges();
                                var devise = Device.Find(tasking.Station).Create<StationDeviceGroup>();
                                foreach (var dev in devise.Items)
                                {
                                    dev.Data.Goodscode = tasking.ID;
                                }
                                tasking.AGVStatusChange(tasking.AGVStatus);
                                return;
                            }
                            else if (Ltc.Do(tasking, v => v.AGVStatus == AGVTaskStatus.取消))
                            {
                                tasking.Status = tasking.AGVStatus;
                                tasking.UpdateTime = DateTime.Now;
                                db.Default.SaveChanges();
                                tasking.AGVStatusChange(tasking.AGVStatus);
                                return;
                            }
                        }
                    }
                });

                #endregion 处理新增AGV任务
            });
        }

        protected override bool SelectDevice(WCS_DEVICE dev)
        {
            return dev.CODE is "G1394" or "G1386";
        }
    }

    /// <summary>
    /// 涂布扫码入库
    /// </summary>
    [WorkTitle(typeof(CoatingHandler), "涂布入库")]
    public class 涂布扫码入库 : Work<StationDeviceGroup>
    {
        protected override void Do(StationDeviceGroup obj)
        {
            obj.EX(stationDeviceGroup =>
            {
                stationDeviceGroup.BcrStationIsForbid();
                //设备组无论单卷还是双卷都必须满足的条件
                if (stationDeviceGroup.Items.Any(v => v.Data.VoucherNo != v.Data2.VoucherNo)) throw new WarnException($"等待任务执行--凭证号不一致");
                if (stationDeviceGroup.Items.Any(v => v.Data3.Status.HasFlag(StationStatus.运行状态位))) throw new WarnException($"设备运行中");

                if (stationDeviceGroup.Entity.CODE == "G1386")
                {
                    if (stationDeviceGroup.Items.Any(v => !v.Data3.Status.HasFlag(StationStatus.低位))) throw new DoException("不在低位");
                }

                var devise = stationDeviceGroup.GetBcrValid();
                devise.Valid();
                var infos = devise.GetWMSInTask();
                WCS_AGVTask agvTask = null;

                //成功创建的任务
                var finishTaskList = new List<FinishTaskList<int>>();
                //创建对应的任务
                DB.Do(db =>
                {
                    if (!stationDeviceGroup.Items.Any(v => v.Data2.Status.HasFlag(IstationStatus.手动入库)))
                    {
                        if (stationDeviceGroup.Entity.CODE == "G1435")
                        {
                            agvTask = db.Default.Set<WCS_AGVTask>().FirstOrDefault(v => v.Status == AGVTaskStatus.完成 && v.Station == "G1394") ?? throw new WarnException("无完成AGV任务");
                        }
                        else
                        {
                            agvTask = db.Default.Set<WCS_AGVTask>().FirstOrDefault(v => v.Status == AGVTaskStatus.完成 && v.Station == stationDeviceGroup.Entity.CODE) ?? throw new WarnException("无完成AGV任务");
                        }

                        if (agvTask.Status != AGVTaskStatus.完成扫码)
                        {
                            agvTask.Status = AGVTaskStatus.完成扫码;
                            agvTask.UpdateTime = DateTime.Now;
                        }
                    }

                    foreach (var item in devise)
                    {
                        var dev = item.Station;
                        var next = dev.Entity.GetPath("SRM");
                        var info = infos.FirstOrDefault(v => item.FinishCode.Contains(v.ContainerCode + "}"));
                        if (db.Default.Set<WCS_TASK>().AsNoTracking().Any(v => v.BARCODE == info.ContainerCode && v.STATUS < TaskStatus.已完成 && v.TYPE == TaskType.入库))
                            throw new WarnException($"生产条码{info?.ContainerCode}存在未完成任务,请检查是否为标签卡重复使用");

                        var task = new WCS_TASK
                        {
                            BARCODE = info?.ContainerCode,
                            TYPE = TaskType.入库,
                            STATUS = TaskStatus.执行中,
                            ADDRFROM = dev.Entity.CODE,
                            ADDRTO = info?.EndPostion,
                            STARTTIME = DateTime.Now,
                            UPDATEUSER = "WCS",
                            UPDATETIME = DateTime.Now,
                            WMSTASK = int.Parse(info?.WMSTaskNum!),
                            TaskGroupKey = info?.TaskGroupKey,
                            ADDRNEXT = next.CODE,
                            HEIGHT = dev.Data2.GoodsSize,
                            AgvTask = agvTask?.ID ?? 0,
                            FLOOR = 2
                        };

                        db.Default.Set<WCS_TASK>().Add(task);
                        finishTaskList.Add(new FinishTaskList<int>(task.WMSTASK, item.Station));

                        
                    }
                    //两个任务一起创建
                    db.Default.SaveChanges();
                });

                //检查对应的任务是否已创建成功
                DB.Do(db =>
                {
                    foreach (var finishTask in finishTaskList)
                    {
                        var task = db.Default.Set<WCS_TASK>().FirstOrDefault(v => v.WMSTASK == finishTask.FinishCode);
                        if (task == null) continue;
                        finishTask.Station.Data.Tasknum = task.ID;
                        finishTask.Station.Data.Goodsstart = task.ADDRFROM.ToShort();
                        finishTask.Station.Data.Goodsend = task.ADDRNEXT.ToShort();
                        finishTask.Station.Data.Goodsnum = (short)finishTaskList.Count;
                        finishTask.Station.Data.CmdType = IstationCmdType.扫码入库;
                        finishTask.Station.Data.VoucherNo++;
                    }
                });
            });
        }

        protected override bool SelectDevice(WCS_DEVICE dev)
        {
            return dev.CODE is "G1386" or "G1435";
        }
    }

    /// <summary>
    /// 涂布入库分配巷道
    /// </summary>
    [WorkTitle(typeof(CoatingHandler), "涂布入库分配巷道")]
    public class 涂布入库分配巷道 : Work<StationDeviceGroup>
    {
        protected override void Do(StationDeviceGroup obj)
        {
            obj.EX(stationDeviceGroup =>
            {
                const string key = $"WCS:Lock:CoatingAllocationTunnel";
                try
                {
                    if (ProtocolProxy.YG150Redis.Get(key) != null) throw new WarnException($"[CoatingAllocationTunnel]--触发并发管控");
                    ProtocolProxy.YG150Redis.Set(key, key);
                    var code = stationDeviceGroup.Entity.CODE;
                    //两个设备都必须满足的条件
                    if (stationDeviceGroup.Items.Any(v => v.Data.VoucherNo != v.Data2.VoucherNo)) throw new WarnException("等待执行任务，凭证号不一致");
                    if (stationDeviceGroup.Items.Any(v => v.Data3.Status.HasFlag(StationStatus.运行状态位))) throw new DoException("运行状态");

                    //成功分配巷道的任务的任务
                    var finishTaskList = new List<FinishTaskList<int>>();
                    var devise = stationDeviceGroup.Items.Where(v => v.Data2.Status.HasFlag(IstationStatus.光电状态) && v.Data2.Request == IstationRequest.请求分配目标地址)
                                               .Where(v => v.Data2.Tasknum > 10000 && v.Data2.Goodsend != 0);
                    var enumerable = devise as Device<IStation520, IStation521, IStation523>[] ?? devise.ToArray();
                    if (!enumerable.Any()) return; //无可执行任务
                    var taskIds = enumerable.Select(dev => dev.Data2.Tasknum).ToList();
                    //变更数据库信息
                    DB.Do(db =>
                    {
                        var taskList = db.Default.Set<WCS_TASK>().Where(v => taskIds.Contains(v.ID)).ToList();

                        taskList.ValidTaskCheck(enumerable.Count(), db);

                        var res = WMS.GetTunnelList(taskList.Select(v => v.WMSTASK.ToString()).ToList(), code);
                        if (string.IsNullOrEmpty(res.TunnelNum)) throw new WarnException($"WMS未返回巷道");
                        var tunnelNo = res.TunnelNum.Split(',').Select(v => "TY" + v).ToList();

                        var tunnels = Device.Where(v => tunnelNo.Contains(v.CODE)).ToList();

                        var tunnelInfos = new List<TunnelInfo>();
                        foreach (var item in tunnels)
                        {
                            //当前巷道的取货点
                            var allIn = Device.Where(v => v.Is(DF.SRM涂布取货)) //二楼所有取货点
                                              .Where(v => v.ROUTES.Any(p => p.NEXT == item)) //下一个点为当前巷道的取货点
                                              .Select(v => v.CODE)
                                              .ToList();

                            //下一个目标地址包含取货点的设备,此时获得的数据是旋转台
                            var turntable = Device.Where(v => v.IsConv() && v.ROUTES.Any(p => p.NEXT != null && allIn.Contains(p.NEXT.CODE))).Select(v => v.CODE);
                            //获得RGV的交货点
                            var rgvDeliveryPoint = Device.Where(v => v.IsConv() && v.ROUTES.Any(p => p.NEXT != null && turntable.Contains(p.NEXT.CODE)))
                                          .Select(v => v.Create<StationDevice>()) //取所有可以到达取货点设备的信息
                                          .Where(v => !v.Data3.Status.HasFlag(StationStatus.运行状态位)
                                                   && !v.Data2.Status.HasFlag(IstationStatus.光电状态)
                                                   && v.Data2.Tasknum < 10000
                                                   && v.Data3.Status.HasFlag(StationStatus.自动))//筛选出空闲的路径点，此处因输送机都是一个动力，因此可以先找路径点再找设备组
                                          .Distinct()
                                          .FirstOrDefault();//去一次重
                            if (rgvDeliveryPoint == null) continue;
                            var taskInStation = Device.Where(p => p.CODE.StartsWith("G") && p.DEVICEGROUP.Any(d => d.MEMBER == rgvDeliveryPoint.Entity)).MinBy(p => p.CODE);
                            //只能有一组任务的下一个地址是交货点
                            if (db.Default.Set<WCS_TASK>().Any(v => v.ADDRNEXT == taskInStation.CODE && v.STATUS < TaskStatus.已完成)) continue;

                            //RGV是否有正在前往这个地址的任务
                            var rgvList = Device.Where(v => v.Is(DF.涂布RGV)).Select(v => v.Create<RGVDevice>());
                            if (rgvList.Any(v => (!v.Data2.SystemStatus.HasFlag(WCS.Entity.Protocol.RGV.RGVRunStatus.空闲) || !v.Data2.WorkMode.HasFlag(WCS.Entity.Protocol.RGV.RGVMode.自动))
                                                && v.Data2.TaskType_1 == WCS.Entity.Protocol.RGV.RGVTaskType.放货
                                                && v.Data2.DestPosition_1 == taskInStation?.CODE.Replace("G", "").ToShort())) continue;

                            tunnelInfos.Add(new TunnelInfo
                            {
                                Tunnel = item,
                                taskIN = taskInStation, //找到放货点设备所在组
                                SRM = Device.Where(p => p.IsSC()).FirstOrDefault(p => item.ROUTES.Any(d => d.NEXT.CODE == p.CODE)).Create<SRMDevice>()
                            });
                        }
                        //筛选出优先级最高的可用巷道
                        var tunnelInfo = tunnelInfos.Where(v => { try { return v.SRM.Data3.SCAlarm == 0 && v.SRM.Data2.SRMMode == SCMode.远程; } catch { return false; } })
                            .Where(v => !db.Default.Set<WCS_TASK>().Any(p => p.Priority > 0 && p.DEVICE == v.SRM.Entity.CODE && p.STATUS < TaskStatus.堆垛机完成)).MinBy(v => tunnelNo.IndexOf(v.Tunnel.CODE));
                        if (tunnelInfo == null) throw new WarnException("无可用巷道");

                        //开始变更任务信息
                        foreach (var item in enumerable)
                        {
                            var dev = item.Entity.Create<StationDevice>();
                            var task = taskList.FirstOrDefault(p => p.ID == dev.Data2.Tasknum);
                            if (task == null) throw new WarnException($"WCS无该任务{dev.Data2.Tasknum}--{dev.Entity.CODE}");

                            task.DEVICE = tunnelInfo.SRM.Entity.CODE;
                            task.TUNNEL = tunnelInfo.Tunnel.CODE;
                            task.ADDRNEXT = tunnelInfo.taskIN.CODE;
                            task.TaskGroupKey = res.WMSTaskGroupKey;
                            task.ADDRTO = task.DEVICE;
                            task.CreateStatusLog(db,$"一次分配至堆垛机{task.DEVICE}", this.GetType());
                            finishTaskList.Add(new FinishTaskList<int>(task.ID, dev));
                        }
                        db.Default.SaveChanges();
                    });

                    // 开始将任务信息写入到设备
                    DB.Do(db =>
                    {
                        foreach (var finishTask in finishTaskList)
                        {
                            var task = db.Default.Set<WCS_TASK>().Find(finishTask.FinishCode);
                            if (task == null) continue;

                            finishTask.Station.Data.Tasknum = task.ID;
                            finishTask.Station.Data.Goodsstart = stationDeviceGroup.Entity.CODE.Replace("G", "").ToShort();
                            finishTask.Station.Data.Goodsend = task.ADDRNEXT.Replace("G", "").ToShort();
                            finishTask.Station.Data.Goodsnum = finishTaskList.Count.ToShort();
                            finishTask.Station.Data.CmdType = IstationCmdType.分配目标地址;
                            finishTask.Station.Data.VoucherNo++;
                        }
                    });
                }
                finally
                {
                    ProtocolProxy.YG150Redis.Del(key);
                }
            });
        }

        protected override bool SelectDevice(WCS_DEVICE dev)
        {
            return dev.CODE is "G2" or "G3";
        }
    }

    /// <summary>
    /// 涂布入库旋转台二次分配巷道
    /// </summary>
    [WorkTitle(typeof(CoatingHandler), "涂布入库旋转台二次分配巷道")]
    public class 涂布入库旋转台二次分配巷道 : Work<StationDeviceGroup>
    {
        protected override void Do(StationDeviceGroup obj)
        {
            obj.EX(stationDeviceGroup =>
            {
                var code = stationDeviceGroup.Entity.CODE;

                //两个设备都必须满足的条件
                if (stationDeviceGroup.Items.Any(v => v.Data.VoucherNo != v.Data2.VoucherNo)) throw new WarnException("等待执行任务--凭证号不一致");
                if (stationDeviceGroup.Items.Any(v => v.Data3.Status.HasFlag(StationStatus.运行状态位))) throw new DoException("运行中");
                //成功分配巷道的任务的任务
                var finishTaskList = new List<FinishTaskList<int>>();
                var devise = stationDeviceGroup.Items.Where(v => v.Data2.Status.HasFlag(IstationStatus.光电状态) && v.Data2.Request == IstationRequest.请求分配目标地址)
                                          .Where(v => v.Data2.Tasknum > 10000);
                var enumerable = devise as Device<IStation520, IStation521, IStation523>[] ?? devise.ToArray();
                if (!enumerable.Any()) return; //无可执行任务
                var taskIds = enumerable.Select(dev => dev.Data2.Tasknum).ToList();
                //变更数据库信息
                DB.Do(db =>
                {
                    var taskList = db.Default.Set<WCS_TASK>().Where(v => taskIds.Contains(v.ID)).ToList();

                    taskList.ValidTaskCheck(enumerable.Count(), db);

                    if (taskList.Any(v => v.TYPE == TaskType.倒库))
                    {
                        foreach (var item in taskList)
                        {
                            var dev = enumerable.FirstOrDefault(v => v.Data2.Tasknum == item.ID).Entity.Create<StationDevice>();
                            finishTaskList.Add(new FinishTaskList<int>(item.ID, dev));
                        }
                    }
                    else
                    {
                        var res = WMS.GetTunnelList(taskList.Select(v => v.WMSTASK.ToString()).ToList(), code);
                        if (string.IsNullOrEmpty(res.TunnelNum)) throw new WarnException($"WMS未返回巷道");
                        var tunnelNo = res.TunnelNum.Split(',').Select(v => "TY" + v).ToList();

                        var tunnels = Device.Where(v => tunnelNo.Contains(v.CODE)).ToList();

                        var tunnelInfos = new List<TunnelInfo>();
                        foreach (var item in tunnels)
                        {
                            //当前巷道的取货点
                            var allIn = Device.Where(v => v.Is(DF.SRM涂布取货)) //一楼所有取货点
                                              .Where(v => v.ROUTES.Any(p => p.NEXT == item)) //下一个点为当前巷道的取货点
                                              .Select(v => v.CODE)
                                              .ToList();
                            //下一个目标地址包含取货点的设备,此时获得的数据是旋转台
                            var turntable = Device.Where(v => v.IsConv() && v.ROUTES.Any(p => p.NEXT != null && allIn.Contains(p.NEXT.CODE)))
                                                  .Where(v => stationDeviceGroup.Items.Any(p => p.Entity == v))// 筛选出包含在当前设备组的设备
                                                  .Distinct()
                                                  .FirstOrDefault();//去一次重
                            if (turntable == null) continue;
                            var dev = Device.Where(p => p.CODE.StartsWith("G") && p.DEVICEGROUP.Any(d => d.MEMBER == turntable)).MinBy(p => p.CODE);

                            tunnelInfos.Add(new TunnelInfo
                            {
                                Tunnel = item,
                                taskIN = dev, //找到放货点设备所在组
                                SRM = Device.Where(p => p.IsSC()).FirstOrDefault(p => item.ROUTES.Any(d => d.NEXT.CODE == p.CODE)).Create<SRMDevice>()
                            });
                        }
                        //筛选出优先级最高的可用巷道
                        var tunnelInfo = tunnelInfos.Where(v => { try { return v.SRM.Data3.SCAlarm == 0 && v.SRM.Data2.SRMMode == SCMode.远程 && v.SRM.Data2.SRMStatus == SCRunStatus.空闲; } catch { return false; } }).MinBy(v => tunnelNo.IndexOf(v.Tunnel.CODE));
                        if (tunnelInfo == null) throw new WarnException("无可用巷道");

                        //开始变更任务信息
                        foreach (var item in enumerable)
                        {
                            var dev = item.Entity.Create<StationDevice>();
                            var task = taskList.FirstOrDefault(p => p.ID == dev.Data2.Tasknum);

                            if (task == null) throw new WarnException($"WCS无该任务{dev.Data2.Tasknum}--{dev.Entity.CODE}");

                            task.DEVICE = tunnelInfo.SRM.Entity.CODE;
                            task.TUNNEL = tunnelInfo.Tunnel.CODE;
                            task.ADDRNEXT = dev.Entity.GetPath(task.DEVICE).CODE;
                            task.TaskGroupKey = res.WMSTaskGroupKey;
                            task.ADDRTO = task.DEVICE;

                            task.CreateStatusLog(db,$"二次分配至堆垛机{task.DEVICE}", this.GetType());
                            finishTaskList.Add(new FinishTaskList<int>(task.ID, dev));
                        }
                        db.Default.SaveChanges();
                    }
                });

                // 开始将任务信息写入到设备
                DB.Do(db =>
                {
                    foreach (var finishTask in finishTaskList)
                    {
                        var task = db.Default.Set<WCS_TASK>().Find(finishTask.FinishCode);
                        if (task == null) continue;

                        finishTask.Station.Data.Tasknum = task.ID;
                        finishTask.Station.Data.Goodsstart = stationDeviceGroup.Entity.CODE.Replace("G", "").ToShort();
                        if (task.TYPE == TaskType.倒库)
                        {
                            finishTask.Station.Data.Goodsend = finishTask.Station.Entity.GetPath(task.DEVICEDL).CODE.ToShort();
                        }
                        else
                        {
                            finishTask.Station.Data.Goodsend = finishTask.Station.Entity.GetPath(task.DEVICE).CODE.ToShort();
                        }
                        finishTask.Station.Data.Goodsnum = finishTaskList.Count.ToShort();
                        finishTask.Station.Data.CmdType = IstationCmdType.分配目标地址;
                        finishTask.Station.Data.VoucherNo++;
                    }
                });
            });
        }

        protected override bool SelectDevice(WCS_DEVICE dev)
        {
            return _devCodes.Contains(dev.CODE);
        }

        private readonly List<string> _devCodes = new()
        {
            "G1404",
            "G1413",
            "G1420",
            "G1429",
        };
    }
}