WcsFramework/YWGC/FJK/WCS.WorkEngineering/Systems/AgvSystems.cs

using FreeRedis;
using Newtonsoft.Json;
using PlcSiemens.Core.Extension;
using ServiceCenter.Extensions;
using ServiceCenter.Logs;
using ServiceCenter.SqlSugars;
using System.ComponentModel;
using System.Security.Cryptography.Xml;
using System.Threading.Tasks;
using WCS.Core;
using WCS.Entity;
using WCS.Entity.Protocol.Station;
using WCS.WorkEngineering.Extensions;
using WCS.WorkEngineering.WebApi.Controllers;
using WCS.WorkEngineering.WebApi.Models.WMS.Request;
using WCS.WorkEngineering.WebApi.Models.WMS.Response;
using WCS.WorkEngineering.Worlds;
using TaskStatus = WCS.Entity.TaskStatus;

namespace WCS.WorkEngineering.Systems
{
    /// <summary>
    ///  Agv交互系统
    /// </summary>
    [BelongTo(typeof(MainWorld))]
    [Description("Agv交互系统")]
    public class AgvSystems : DeviceSystem<Device<IStation520>>
    {
        protected override bool ParallelDo => true;

        public AgvSystems()
        {
        }

        public override void Do(Device<IStation520> obj)
        {
            if (obj.Entity.Code == "AGVOut")
            {
                var agvTaskInfos = new List<WCS_AgvTaskInfo>();
                //获取所有未结束的叫料及背负式补空AGV任务
                SqlSugarHelper.Do(db =>
                {
                    agvTaskInfos = db.Default.Queryable<WCS_AgvTaskInfo>().ReadPast().Where(v => v.TaskType == AGVTaskType.CallMaterial)
                                                                         .Where(v => v.Status < AGVTaskStatus.MissionCompleted)
                                                                         .SplitTable(tabs => tabs.Take(2)).OrderBy(v => v.AddTime).ToList();
                });
                //有需要处理的AGV任务
                if (agvTaskInfos.Any())
                {
                    this.ExRecord(obj.Entity.Code, "可用出库AGV任务列表", agvTaskInfos.Select(v => v.ID).ToList());
                    var taskInfos = new List<WCS_TaskInfo>();

                    foreach (var agv in agvTaskInfos)
                    {
                        try
                        {
                            SqlSugarHelper.Do(db =>
                            {
                                switch (agv.AgvStatus)
                                {
                                    //取货点安全交互
                                    case AGVTaskStatus.RequestOrPermission2 when agv.Status != AGVTaskStatus.RequestOrPermission2:
                                        {
                                            var taskInfoPick = db.Default.Queryable<WCS_TaskInfo>().NoLock().First(v => v.ID == agv.TaskId);
                                            if(taskInfoPick == null) throw new Exception($"未找到对应的WCS任务{agv.TaskId}");
                                            agv.Status = AGVTaskStatus.RequestOrPermission2;
                                            db.Default.UpdateableRowLock(agv).SplitTable(x => x.Take(2)).ExecuteCommand();
                                            taskInfoPick.AddWCS_TASK_DTL(db.Default, "agv", $"允许AGV任务{agv.ID}在站台{agv.Station}取货");
                                            AgvApi.ContinueTask(agv.AgvID, agv.Station);
                                            break;
                                        }
                                    case AGVTaskStatus.PutRequestOrPermission when agv.Status != AGVTaskStatus.PutRequestOrPermission:
                                        {
                                            agv.Status = AGVTaskStatus.PutRequestOrPermission;
                                            db.Default.UpdateableRowLock(agv).SplitTable(x => x.Take(2)).ExecuteCommand();
                                            AgvApi.ContinueTask(agv.AgvID, agv.Station);
                                            break;
                                        }
                                    case AGVTaskStatus.LeaveGet when agv.Status != AGVTaskStatus.LeaveGet:
                                        var taskInfo = db.Default.Queryable<WCS_TaskInfo>().NoLock().First(v => v.ID == agv.TaskId);
                                        if (taskInfo == null) throw new Exception($"未找到对应的WCS任务{agv.TaskId}");
                                        World.Log($"AGV取货结束:开始{agv.ID}--{agv.Station}");
                                        var devinfo = new Device<IStation520>(Device.All.First(x => x.Code == agv.Station), World);
                                        if (!taskInfo.AddrFrom.StartsWith("92"))
                                        {
                                            devinfo.Data.CmdType = StationCmd.Res5;
                                        }
                                        if (taskInfo.AddrFrom.StartsWith("92") && taskInfo.Device == "CR")
                                        {
                                            var res = WmsApi.SrmPickOutCompleted(taskInfo.ID);
                                            if (res.ResCode != ResponseStatusCodeEnum.Sucess)
                                            {
                                                throw new Exception(res.ResMsg);
                                            }
                                        }
                                        agv.Status = AGVTaskStatus.LeaveGet;
                                        db.Default.UpdateableRowLock(agv).SplitTable(x => x.Take(2)).ExecuteCommand();
                                        World.Log($"AGV取货结束:结束{agv.ID}--{agv.Station}");
                                        break;
                                    //完成任务
                                    case AGVTaskStatus.MissionCompleted when agv.Status != AGVTaskStatus.MissionCompleted:
                                        {
                                            if (agv.TaskType is AGVTaskType.CallForMaterial or AGVTaskType.ForkliftFilling or AGVTaskType.CallMaterial)
                                            {
                                                var taskInfoFinish = db.Default.Queryable<WCS_TaskInfo>().RowLock().First(v => v.AgvTaskID == agv.ID);
                                                //if (taskInfo == null) throw new Exception($"未找到AGV任务{agv.ID}对应WCS任务");
                                                //更新AGV任务状态
                                                agv.Status = AGVTaskStatus.MissionCompleted;
                                                db.Default.UpdateableRowLock(agv).SplitTable(x => x.Take(2)).ExecuteCommand();
                                                //更新WCS任务状态
                                                if (taskInfoFinish != null)
                                                {
                                                    taskInfoFinish.Status = Entity.TaskStatus.Finish;
                                                    taskInfoFinish.EndTime = DateTime.Now;
                                                    db.Default.UpdateableRowLock(taskInfoFinish).UpdateColumns(x => new { x.Status, x.EndTime }).ExecuteCommand();
                                                    taskInfoFinish.AddWCS_TASK_DTL(db.Default, "agv", "任务完成");
                                                    taskInfos.Add(taskInfoFinish);
                                                }  
                                            }
                                            else
                                            {
                                                agv.Status = AGVTaskStatus.MissionCompleted;
                                                db.Default.UpdateableRowLock(agv).SplitTable(x => x.Take(2)).ExecuteCommand();
                                            }

                                            break;
                                        }
                                }
                            });
                        }
                        catch (Exception ex)
                        {
                            World.Log(ex.Message, LogLevelEnum.Mid);
                            this.ExRecord(obj.Entity.Code, ex.Message);
                        }
                    }
                }
            }
            else if (obj.Entity.Code == "AGVIn")
            {
                List<WCS_AgvTaskInfo> agvTaskInfos = new List<WCS_AgvTaskInfo>();
                //获取所有未结束的入库AGV任务
                SqlSugarHelper.Do(db =>
                {
                    agvTaskInfos = db.Default.Queryable<WCS_AgvTaskInfo>()
                                             .Where(v => v.Status < AGVTaskStatus.MissionCompleted && v.TaskType == AGVTaskType.EnterDepot)
                                             .SplitTable(tabs => tabs.Take(2)).OrderBy(v => v.EditTime).ToList();
                });

                if (agvTaskInfos.Any())
                {
                    foreach (var agv in agvTaskInfos)
                    {
                        try
                        {
                            SqlSugarHelper.Do(db =>
                            {
                                #region 开始跟据AGV状态做出处理

                                switch (agv.AgvStatus)
                                {
                                    case AGVTaskStatus.NewBuild when agv.Status == AGVTaskStatus.NewBuild:
                                        if (agv.WorkShop != 111)
                                        {
                                            agv.AgvID = agv.ID.ToString();
                                            agv.Status = AGVTaskStatus.Confirm;
                                            agv.AgvStatus = AGVTaskStatus.Confirm;
                                            db.Default.UpdateableRowLock(agv).SplitTable(x => x.Take(2)).ExecuteCommand();
                                        }                                                                             
                                        //人工满托入库
                                        if (agv.TaskType == AGVTaskType.EnterDepot &&(agv.Station == "2535" || agv.Station == "2935" || agv.Station == "2735" || agv.Station == "3135"))
                                        {
                                            fjSysConfig config = new fjSysConfig();
                                            var config1 = db.Default.Queryable<fjSysConfig>().NoLock().First(x => x.Code == "FullPalletInMax");
                                            if (config1 != null)
                                            {
                                                if (!(db.Default.Queryable<WCS_TaskInfo>().NoLock().Where(x => x.Status < TaskStatus.Finish && x.BusType == "人工满托入库").Count() < config.SContent.ToShort()))
                                                {
                                                    throw new Exception($"人工组盘任务数已达{config1.SContent.ToShort()},暂停下发任务");
                                                }
                                            }
                                            AgvApi.满托入库(agv.Position, agv.ID.ToString(), agv.Station);
                                            var tasknew = db.Default.Queryable<WCS_TaskInfo>().NoLock().Where(x => x.ID == agv.TaskId).First();
                                            if (tasknew != null)
                                            {
                                                tasknew.Status = TaskStatus.AGVExecution;
                                                tasknew.EditTime = DateTime.Now;
                                                db.Default.UpdateableRowLock(tasknew).UpdateColumns(x => new { x.Status, x.EditTime }).ExecuteCommand();
                                                tasknew.AddWCS_TASK_DTL(db.Default, "agv", "任务下发agv执行");
                                            }
                                            else
                                            {
                                                throw new Exception($"未找到WCS任务{agv.TaskId},请确认任务状态");
                                            }
                                        }
                                        //退料重绕
                                        else if (agv.WorkShop == 222)
                                        {
                                            AgvApi.退料重绕(agv.Position, agv.ID.ToString(), agv.Station);
                                            var tasknew = db.Default.Queryable<WCS_TaskInfo>().NoLock().Where(x => x.ID == agv.TaskId).First();
                                            if (tasknew != null)
                                            {
                                                tasknew.Status = TaskStatus.AGVExecution;
                                                tasknew.EditTime = DateTime.Now;
                                                db.Default.UpdateableRowLock(tasknew).UpdateColumns(x => new { x.Status, x.EditTime }).ExecuteCommand();
                                                tasknew.AddWCS_TASK_DTL(db.Default, "agv", "任务下发agv执行");
                                            }
                                            else
                                            {
                                                throw new Exception($"未找到WCS任务{agv.TaskId},请确认任务状态");
                                            }
                                        }
                                        //重绕退料区搬运
                                        else if (agv.WorkShop == 333)
                                        {
                                            AgvApi.退料搬运(agv.Position, agv.ID.ToString(), agv.Station);                                        
                                        }
                                        else if(agv.WorkShop != 111)
                                        {
                                            AgvApi.托盘回库(agv.Position, agv.ID.ToString(), agv.Station);
                                        }

                                        break;
                                    //巷道分配
                                    case AGVTaskStatus.RequestOrPermission1 when agv.Status != AGVTaskStatus.Complete1:
                                        {
                                            var task = db.Default.Queryable<WCS_TaskOld>().NoLock().Where(x => x.Id == agv.TaskId).SplitTable(x => x.Take(2)).First();
                                            if (task == null) throw new Exception($"未找到对应的WCS任务{agv.TaskId}");
                                            if (task.BusType != TaskBusType.帘线退料重绕.GetDescription())
                                            {
                                                //获取当前任务可以去的目标地址
                                                var positionList = new List<string>(); //当前分配点对应的放货点
                                                //var allPositionList = new List<string>(); //同库区另一侧的放货点
                                                //var nearPositionList = new List<string>(); //所有的放货点

                                                //GetPositionList(positionList, nearPositionList, allPositionList, task.WarehouseCode);
                                                switch (agv.Station)
                                                {
                                                    case "2501":
                                                        positionList.AddRange(new List<string>() { "2501", "2505", "2509", "2513" });
                                                        
                                                        break;

                                                    case "2701":
                                                        positionList.AddRange(new List<string>() { "2701", "2705", "2709", "2713" });
                                                        
                                                        break;

                                                    case "2901":
                                                        positionList.AddRange(new List<string>() { "2901", "2905", "2909", "2913" });
                                                       
                                                        break;

                                                    case "3101":
                                                        positionList.AddRange(new List<string>() { "3101", "3105", "3109", "3113" });
                                                        
                                                        break;

                                                    case "3301":
                                                        positionList.AddRange(new List<string>() { "3301", "3305", "3309", "3313" });
                                                        
                                                        break;

                                                    case "3501":
                                                        positionList.AddRange(new List<string>() { "3501", "3505", "3509", "3513" });
                                                        
                                                        break;
                                                }

                                                List<WCS_AgvTaskInfo> agvs = new List<WCS_AgvTaskInfo>(); //当前分配点对应的放货点已用点
                                                //List<WCS_AgvTaskInfo> agvsNear = new List<WCS_AgvTaskInfo>(); //同库区另一侧的放货点已用点
                                                //List<WCS_AgvTaskInfo> agvsAll = new List<WCS_AgvTaskInfo>(); //所有的放货点已用点

                                                agvs = db.Default.Queryable<WCS_AgvTaskInfo>().Where(v => v.Status > AGVTaskStatus.Confirm && v.Status < AGVTaskStatus.MissionCompleted && v.TaskType == AGVTaskType.EnterDepot && positionList.Contains(v.Station))
                                                    .SplitTable(v => v.Take(2)).ToList();
                                                //agvsAll = db.Default.Queryable<WCS_AgvTaskInfo>().Where(v => v.Status > AGVTaskStatus.Confirm && v.Status < AGVTaskStatus.MissionCompleted && v.TaskType == AGVTaskType.EnterDepot && allPositionList.Contains(v.Station))
                                                //    .SplitTable(v => v.Take(2)).ToList();
                                                //agvsNear = db.Default.Queryable<WCS_AgvTaskInfo>().Where(v => v.Status > AGVTaskStatus.Confirm && v.Status < AGVTaskStatus.MissionCompleted && v.TaskType == AGVTaskType.EnterDepot && nearPositionList.Contains(v.Station))
                                                //    .SplitTable(v => v.Take(2)).ToList();
                                                //获取放货点
                                                var agvPositionLists = agvs.Select(x => x.Station).Distinct();
                                                //var agvPositionListsNear = agvsNear.Select(x => x.Station).Distinct();
                                                //var agvPositionListsAll = agvsAll.Select(x => x.Station).Distinct();
                                                //获取各区域可用点
                                                var endDev = positionList.Where(x => !agvPositionLists.Contains(x)).ToList();
                                                //var endNearDev = nearPositionList.Where(x => !agvPositionListsNear.Contains(x)).ToList();
                                                //var endAllDev = allPositionList.Where(x => !agvPositionListsAll.Contains(x)).ToList();

                                                World.Log($"agv可用巷道信息:{JsonConvert.SerializeObject(endDev)}");
                                                //World.Log($"agv可用巷道信息(所有):{JsonConvert.SerializeObject(endAllDev)}");

                                                if (!endDev.Any() /*&& !endAllDev.Any() && !endNearDev.Any()*/)//没有可用放货站台
                                                {
                                                    var msg = $"任务{agv.ID}已无可用放货站台";
                                                    foreach (var ag in agvs)
                                                    {
                                                        msg += $"[任务号:{ag.ID},目标地址:{ag.Station}]";
                                                    }
                                                    throw new Exception(msg);
                                                }

                                                //获取没有光电信息的设备集合
                                                try
                                                {
                                                    // 获取可用站台
                                                    var devs = Device.All.Where(x => endDev.Contains(x.Code)).Select(x =>
                                                        new Device<IStation520, IStation521, IStation523>(x, World));
                                                    devs = devs.Where(x =>
                                                        !x.Data3.Status.HasFlag(StationStatus.Run) &&
                                                        !x.Data3.Status.HasFlag(StationStatus.PH_Status) &&
                                                        x.Data3.Status.HasFlag(StationStatus.Auto)).ToList();

                                                    //var devsNear = Device.All.Where(x => endNearDev.Contains(x.Code)).Select(x =>
                                                    //    new Device<IStation520, IStation521, IStation523>(x, World));
                                                    //devsNear = devsNear.Where(x =>
                                                    //    !x.Data3.Status.HasFlag(StationStatus.Run) &&
                                                    //    !x.Data3.Status.HasFlag(StationStatus.PH_Status) &&
                                                    //    x.Data3.Status.HasFlag(StationStatus.Auto)).ToList();

                                                    //var devsAll = Device.All.Where(x => endAllDev.Contains(x.Code)).Select(x =>
                                                    //    new Device<IStation520, IStation521, IStation523>(x, World));
                                                    //devsAll = devsAll.Where(x =>
                                                    //    !x.Data3.Status.HasFlag(StationStatus.Run) &&
                                                    //    !x.Data3.Status.HasFlag(StationStatus.PH_Status) &&
                                                    //    x.Data3.Status.HasFlag(StationStatus.Auto)).OrderBy(v => allPositionList.Contains(v.Entity.Code)).ToList();
                                                    if (!devs.Any()) //自身所属位置无可用放货点
                                                    {
                                                        throw new Exception($"当前任务{agv.ID}无可用站台");
                                                        #region  弃用
                                                        //if (devsNear.Any())//先判断同库一侧
                                                        //{
                                                        //    foreach (var dev in devsNear)
                                                        //    {
                                                        //        if (!dev.Data3.Status.HasFlag(StationStatus.Run) && !dev.Data3.Status.HasFlag(StationStatus.PH_Status) && dev.Data3.Status.HasFlag(StationStatus.Auto))
                                                        //        {
                                                        //            World.Log($"任务执行过程:开始{agv.ID}-{JsonConvert.SerializeObject(devsAll.Select(x => x.Entity.Code).ToList())}");
                                                        //            agv.Status = AGVTaskStatus.Complete1;
                                                        //            agv.Station = dev.Entity.Code;
                                                        //            db.Default.UpdateableRowLock(agv).SplitTable(x => x.Take(2)).ExecuteCommand();
                                                        //            World.Log($"任务执行过程:完成agv任务更新{agv.ID}--{agv.Station}");
                                                        //            task.AddWCS_TASK_DTL(db.Default, "皮盘返库任务分配巷道", agv.Station, $"任务分配至:{agv.Station}");
                                                        //            World.Log($"任务执行过程:完成任务明细添加{agv.Station}");
                                                        //            AgvApi.ContinueTask(agv.AgvID, agv.Station);
                                                        //            World.Log($"任务执行过程:任务成功下发AGV{agv.AgvID}--{agv.Station}");
                                                        //            return;
                                                        //        }
                                                        //    }
                                                        //}
                                                        //else if (devsAll.Any())
                                                        //{
                                                        //    foreach (var dev in devsAll)
                                                        //    {
                                                        //        if (!dev.Data3.Status.HasFlag(StationStatus.Run) && !dev.Data3.Status.HasFlag(StationStatus.PH_Status) && dev.Data3.Status.HasFlag(StationStatus.Auto))
                                                        //        {
                                                        //            World.Log($"任务执行过程:开始{agv.ID}-{JsonConvert.SerializeObject(devsAll.Select(x => x.Entity.Code).ToList())}");
                                                        //            agv.Status = AGVTaskStatus.Complete1;
                                                        //            agv.Station = dev.Entity.Code;
                                                        //            db.Default.UpdateableRowLock(agv).SplitTable(x => x.Take(2)).ExecuteCommand();
                                                        //            World.Log($"任务执行过程:完成agv任务更新{agv.ID}--{agv.Station}");
                                                        //            task.AddWCS_TASK_DTL(db.Default, "皮盘返库任务分配巷道", agv.Station, $"任务分配至:{agv.Station}");
                                                        //            World.Log($"任务执行过程:完成任务明细添加{agv.Station}");
                                                        //            AgvApi.ContinueTask(agv.AgvID, agv.Station);
                                                        //            World.Log($"任务执行过程:任务成功下发AGV{agv.AgvID}--{agv.Station}");
                                                        //            return;
                                                        //        }
                                                        //    }
                                                        //}
                                                        World.Log("可用站台均有货或有执行中任务");
                                                        return;
                                                        #endregion
                                                    }
                                                    World.Log($"任务执行过程:开始{agv.ID}-{JsonConvert.SerializeObject(devs.Select(x => x.Entity.Code).ToList())}");
                                                    agv.Status = AGVTaskStatus.Complete1;
                                                    agv.Station = devs.MinBy(x => x.Entity.Code).Entity.Code;
                                                    db.Default.UpdateableRowLock(agv).SplitTable(x => x.Take(2)).ExecuteCommand();
                                                    World.Log($"任务执行过程:完成agv任务更新{agv.ID}--{agv.Station}");
                                                    task.AddWCS_TASK_DTL(db.Default, "皮盘返库任务分配巷道", agv.Station, $"任务分配至:{agv.Station}");
                                                    World.Log($"任务执行过程:完成任务明细添加{agv.Station}");
                                                    AgvApi.ContinueTask(agv.AgvID, agv.Station);
                                                    World.Log($"任务执行过程:任务成功下发AGV{agv.AgvID}--{agv.Station}");
                                                }
                                                catch (Exception e)
                                                {
                                                    throw new Exception($"{e.Message}");
                                                }
                                            }
                                            else if (task.BusType == TaskBusType.帘线退料重绕.GetDescription())
                                            {
                                                var con = db.Default.Queryable<fjSysConfig>().NoLock().First(x => x.Code == "CRTLZone").SContent;
                                                var isUse = false || con != null && con == "1";
                                                //首先判断退料输送线是否可放货                                               
                                                var ph_9001 = new Device<IStation523>(Device.All.First(x => x.Code == "9001"), World);
                                                var ph_9101 = new Device<IStation523>(Device.All.First(x => x.Code == "9101"), World);
                                                var flag1 = !db.Default.Queryable<WCS_AgvTaskInfo>().NoLock().Where(v => v.Status > AGVTaskStatus.Confirm && v.Status < AGVTaskStatus.MissionCompleted && v.TaskType == AGVTaskType.EnterDepot && v.Station == "9001")
                                                    .SplitTable(v => v.Take(2)).Any() && !ph_9001.Data.Status.HasFlag(StationStatus.PH_Status);
                                                var flag2 = !db.Default.Queryable<WCS_AgvTaskInfo>().NoLock().Where(v => v.Status > AGVTaskStatus.Confirm && v.Status < AGVTaskStatus.MissionCompleted && v.TaskType == AGVTaskType.EnterDepot && v.Station == "9101")
                                                    .SplitTable(v => v.Take(2)).Any() && !ph_9101.Data.Status.HasFlag(StationStatus.PH_Status);
                                                var taskApply = db.Default.Queryable<WCS_TaskInfo>().NoLock().Where(x => x.ID == agv.TaskId).First();
                                                if (flag2)
                                                {
                                                    if (taskApply != null)
                                                    {
                                                        agv.Status = AGVTaskStatus.Complete1;
                                                        agv.Station = "9101";
                                                        db.Default.UpdateableRowLock(agv).SplitTable(x => x.Take(2)).ExecuteCommand();
                                                        AgvApi.ContinueTask(agv.AgvID, agv.Station);
                                                        taskApply.AddrTo = agv.Station;
                                                        db.Default.UpdateableRowLock(taskApply).UpdateColumns(x => new { x.AddrTo }).ExecuteCommand();
                                                        World.Log($"帘线退料重绕分配目标放货点,任务{agv.ID}分配至:{agv.Station}");
                                                        taskApply.AddWCS_TASK_DTL(db.Default, "agv", $"帘线退料重绕分配目标放货点,任务分配至:{agv.Station}");
                                                    }
                                                    else
                                                    {
                                                        throw new Exception($"未找到WCS任务{agv.TaskId},请确认任务状态");
                                                    }
                                                    return;
                                                }
                                                else if (flag1)
                                                {
                                                    if (taskApply != null)
                                                    {
                                                        agv.Status = AGVTaskStatus.Complete1;
                                                        agv.Station = "9001";
                                                        db.Default.UpdateableRowLock(agv).SplitTable(x => x.Take(2)).ExecuteCommand();
                                                        AgvApi.ContinueTask(agv.AgvID, agv.Station);
                                                        taskApply.AddrTo = agv.Station;
                                                        db.Default.UpdateableRowLock(taskApply).UpdateColumns(x => new { x.AddrTo }).ExecuteCommand();
                                                        World.Log($"帘线退料重绕分配目标放货点,任务{agv.ID}分配至:{agv.Station}");
                                                        taskApply.AddWCS_TASK_DTL(db.Default, "agv", $"帘线退料重绕分配目标放货点,任务分配至:{agv.Station}");
                                                    }
                                                    else
                                                    {
                                                        throw new Exception($"未找到WCS任务{agv.TaskId},请确认任务状态");
                                                    }
                                                    return;
                                                }
                                                else if (isUse)//请求WMS分配可用放货点
                                                {
                                                    List<string> allDevs = new List<string> { "9210", "9211", "9212", "9213", "9214",/* "9215", "9216", "9217", "9218" */};

                                                    var agvStas = db.Default.Queryable<WCS_AgvTaskInfo>().NoLock().Where(v => v.Status > AGVTaskStatus.Confirm && v.Status < AGVTaskStatus.MissionCompleted && v.TaskType == AGVTaskType.EnterDepot && (allDevs.Contains(v.Station)|| allDevs.Contains(v.Position)))
                                                    .SplitTable(v => v.Take(2)).ToList();
                                                    var agvStaLists = agvStas.Select(x => x.Station).Distinct();
                                                    var devs = allDevs.Where(x => !agvStaLists.Contains(x)).ToList();
                                                    var devsPut = Device.All.Where(x => devs.Contains(x.Code)).Select(x =>
                                                        new Device<IStation520, IStation521, IStation523>(x, World));
                                                    devsPut = devsPut.Where(x =>
                                                        !x.Data3.Status.HasFlag(StationStatus.Run) &&
                                                        !x.Data3.Status.HasFlag(StationStatus.PH_Status) &&
                                                        x.Data3.Status.HasFlag(StationStatus.Auto)).ToList();
                                                    if (taskApply == null)
                                                    {
                                                        throw new Exception($"找不到对应wcs任务{agv.TaskId}");
                                                    }

                                                    if (devsPut.Any())
                                                    {
                                                        foreach (var dev in devsPut)
                                                        {
                                                            if (!dev.Data3.Status.HasFlag(StationStatus.PH_Status) &&
                                                                !db.Default.Queryable<WCS_AgvTaskInfo>().NoLock().Where(v => v.Status > AGVTaskStatus.Confirm && v.Status < AGVTaskStatus.MissionCompleted && v.TaskType == AGVTaskType.EnterDepot && (v.Station == dev.Entity.Code || v.Position == dev.Entity.Code))
                                                                .SplitTable(v => v.Take(2)).Any())
                                                            {
                                                                var sta = dev.Entity.Code; 
                                                                var res = WmsApi.GetFlatLocalIn(agv.TaskId,"T2",dev.Entity.Code,1);
                                                                if (res.ResCode == ResponseStatusCodeEnum.Sucess && res.ResData.CellNo == dev.Entity.Code)
                                                                {
                                                                    sta = dev.Entity.Code;
                                                                }
                                                                else if (res.ResCode == ResponseStatusCodeEnum.Sucess)
                                                                {
                                                                    sta = res.ResData.CellNo;
                                                                    World.Log($"{dev.Entity.Code}分配货位{res.ResData.CellNo}");
                                                                }
                                                                else
                                                                {
                                                                    continue;
                                                                }
                                                                agv.Status = AGVTaskStatus.Complete1;
                                                                agv.Station = dev.Entity.Code;
                                                                db.Default.UpdateableRowLock(agv).SplitTable(x => x.Take(2)).ExecuteCommand();
                                                                AgvApi.ContinueTask(agv.AgvID, agv.Station);
                                                                taskApply.AddrTo = agv.Station;
                                                                db.Default.UpdateableRowLock(taskApply).UpdateColumns(x => new { x.AddrTo }).ExecuteCommand();
                                                                taskApply.AddWCS_TASK_DTL(db.Default, "agv", $"帘线退料重绕分配目标放货点,任务分配至:{agv.Station}");
                                                                World.Log($"帘线退料重绕分配目标放货点,任务{agv.ID}分配至:{agv.Station}");
                                                                return;
                                                            }
                                                        }
                                                    }
                                                    else
                                                    {
                                                        throw new Exception("已无可用放货站台,请等待");
                                                    }
                                                }
                                                else
                                                {
                                                    throw new Exception("已无可用放货站台,请等待");
                                                }
                                            }                                            
                                            break;
                                        }
                                    //放货站点安全交互
                                    case AGVTaskStatus.RequestOrPermission2 when agv.Status != AGVTaskStatus.RequestOrPermission2:
                                        {
                                            if (agv.Station.IsNullOrEmpty()) throw new Exception($"无有效放货地址");
                                            //var dev = Device.All.First(x => x.Code == agv.Station);
                                            var devPut = new Device<IStation520, IStation521,IStation523>(Device.All.First(x => x.Code == agv.Station), World);
                                            var taskPut = db.Default.Queryable<WCS_TaskOld>().NoLock().Where(x => x.Id == agv.TaskId).SplitTable(x => x.Take(2)).First();
                                            var flag = false;
                                            if (taskPut == null)
                                            {
                                                throw new Exception($"未找到WCS任务{agv.TaskId},请确认任务状态");
                                            }
                                            else if(taskPut.BusType == "人工满托入库")                                           
                                            {
                                                flag = true;
                                            }
                                            
                                            if (devPut.Data3.Status.HasFlag(StationStatus.PH_Status))
                                            {
                                                throw new Exception($"{agv.Station}站台有光电小车无法放货，请检查实际情况并处理");
                                            }
                                            if (flag)
                                            {
                                                if (!devPut.Data3.Status.HasFlag(StationStatus.Low_Station_2))
                                                {
                                                    throw new Exception($"{agv.Station}站台不在低位小车无法放货，请检查并处理");
                                                }
                                                var tasking = db.Default.Queryable<WCS_AgvTaskInfo>().NoLock().Where(v => v.Status < AGVTaskStatus.MissionCompleted && v.TaskType == AGVTaskType.EnterDepot
                                                        && v.Station == agv.Station && v.GoodsSum == 1).SplitTable(tabs => tabs.Take(2)).First();
                                                if (tasking != null)
                                                {
                                                    throw new Exception($"{agv.Station}站台有执行中任务{tasking.ID}，请确认该任务实际位置");
                                                }
                                                agv.GoodsSum = 1;
                                            }
                                            agv.Status = AGVTaskStatus.RequestOrPermission2;
                                            db.Default.UpdateableRowLock(agv).SplitTable(x => x.Take(2)).ExecuteCommand();
                                            //taskPut.AddWCS_TASK_DTL(db.Default, "agv", $"允许agv任务{agv.ID}放货");
                                            if (taskPut.BusType != TaskBusType.帘线退料重绕.GetDescription() && taskPut.BusType != TaskBusType.重绕满托入库.GetDescription())
                                            {
                                                devPut.Data.CmdType = StationCmd.Res1;
                                            }
                                            
                                            //调继续执行任务接口
                                            AgvApi.ContinueTask(agv.AgvID, agv.Station);
                                            break;
                                        }
                                    case AGVTaskStatus.LeavePut when agv.Status != AGVTaskStatus.LeavePut:


                                        break;
                                   
                                    //完成任务
                                    case AGVTaskStatus.MissionCompleted when agv.Status != AGVTaskStatus.MissionCompleted:
                                        var taskold = db.Default.Queryable<WCS_TaskOld>().NoLock().Where(x => x.Id == agv.TaskId).SplitTable(x => x.Take(2)).First();
                                        if (agv.TaskType == AGVTaskType.EnterDepot)
                                        {
                                            agv.Status = AGVTaskStatus.MissionCompleted;
                                            db.Default.UpdateableRowLock(agv).SplitTable(x => x.Take(2)).ExecuteCommand();
                                            var devinfo = new Device<IStation520, IStation521>(Device.All.First(x => x.Code == agv.Station), World);
                                            if (taskold.BusType != TaskBusType.帘线退料重绕.GetDescription() && taskold.BusType != TaskBusType.重绕满托入库.GetDescription())
                                            {
                                                devinfo.Data.CmdType = StationCmd.Res2;
                                            }
                                            
                                            if (taskold.LastInteractionPoint == "2" || taskold.BusType == TaskBusType.重绕满托入库.GetDescription() || taskold.BusType == TaskBusType.帘线退料重绕.GetDescription()) //如果是单独取空任务直接完成
                                            {
                                                var task = db.Default.Queryable<WCS_TaskInfo>().NoLock().Where(x => x.ID == agv.TaskId).First();
                                                if (task != null)
                                                {
                                                    task.Status = TaskStatus.Finish;
                                                    task.EndTime = DateTime.Now;
                                                    db.Default.UpdateableRowLock(task).UpdateColumns(x => new { x.Status, x.EndTime }).ExecuteCommand();
                                                    task.AddWCS_TASK_DTL(db.Default, "agv", "任务完成");
                                                }
                                            }
                                            else if (taskold.BusType == "人工满托入库")
                                            {
                                                var task = db.Default.Queryable<WCS_TaskInfo>().NoLock().Where(x => x.ID == agv.TaskId).First();
                                                if (task != null)
                                                {
                                                    task.Status = TaskStatus.ConveyorExecution;
                                                    devinfo.Data.TaskNumber = task.ID;
                                                    task.EndTime = DateTime.Now;
                                                    db.Default.UpdateableRowLock(task).UpdateColumns(x => new { x.Status, x.EndTime }).ExecuteCommand();
                                                    task.AddWCS_TASK_DTL(db.Default, "agv", "任务放货完成");
                                                }
                                            }
                                        }
                                        break;

                                    case AGVTaskStatus.Cancel when agv.Status != AGVTaskStatus.Cancel:
                                        var taskold1 = db.Default.Queryable<WCS_TaskOld>().NoLock().Where(x => x.Id == agv.TaskId).SplitTable(x => x.Take(2)).First();
                                        agv.Status = AGVTaskStatus.Cancel;
                                        db.Default.UpdateableRowLock(agv).SplitTable(x => x.Take(2)).ExecuteCommand();
                                        if (taskold1.LastInteractionPoint == "2") //如果是单独取空任务直接取消
                                        {
                                            var task = db.Default.Queryable<WCS_TaskInfo>().NoLock().Where(x => x.ID == agv.TaskId).First();
                                            if (task != null)
                                            {
                                                task.Status = TaskStatus.Cancel;
                                                task.EndTime = DateTime.Now;
                                                db.Default.UpdateableRowLock(task).UpdateColumns(x => new { x.Status, x.EndTime }).ExecuteCommand();
                                                task.AddWCS_TASK_DTL(db.Default, "agv", "任务取消");
                                            }   
                                        }
                                        break;
                                }

                                #endregion 开始跟据AGV状态做出处理
                            });
                        }
                        catch (Exception ex)
                        {
                            if (ex.Message.Contains("SqlTransaction")) World.Log($"{ex.Message}:{ex.StackTrace}");
                            else World.Log(ex.Message, LogLevelEnum.Mid);
                        }
                    }
                }
            }
        }

        public override bool Select(Device dev)
        {
            return dev.Code is "AGVIn" or "AGVOut";
        }

        /// <summary>
        ///  获取可用放货点
        /// </summary>
        /// <param name="positionList"></param>
        /// <param name="nearPositionList"></param>
        /// <param name="allPositionList"></param>
        /// <param name="warehouseCode"></param>
        private void GetPositionList(List<string> positionList, List<string> nearPositionList, List<string> allPositionList, string warehouseCode)
        {
            switch (warehouseCode)
            {
                case "1N":
                    positionList.AddRange(new List<string>() { "2501", "2505", "2509", "2513" });
                    nearPositionList.AddRange(new List<string>() {
                                                        "2701", "2705", "2709", "2713" });
                    allPositionList.AddRange(new List<string>() {
                                                        "2901", "2905", "2909", "2913","3101", "3105", "3109", "3113", "3301", "3305", "3309", "3313","3501", "3505", "3509", "3513"});
                    break;

                case "1S":
                    positionList.AddRange(new List<string>() { "2701", "2705", "2709", "2713" });
                    nearPositionList.AddRange(new List<string>() {
                                                        "2501", "2505", "2509", "2513" });
                    allPositionList.AddRange(new List<string>() {
                                                        "3101", "3105", "3109", "3113", "2901", "2905", "2909", "2913", "3501", "3505", "3509", "3513", "3301", "3305", "3309", "3313"});
                    break;

                case "2N":
                    positionList.AddRange(new List<string>() { "2901", "2905", "2909", "2913" });
                    nearPositionList.AddRange(new List<string>() {
                                                        "3101", "3105", "3109", "3113" });
                    allPositionList.AddRange(new List<string>() {
                                                        "2501" , "2505" , "2509" , "2513" , "2701", "2705", "2709", "2713","3301", "3305", "3309", "3313", "3501", "3505", "3509", "3513"});
                    break;

                case "2S":
                    positionList.AddRange(new List<string>() { "3101", "3105", "3109", "3113" });
                    nearPositionList.AddRange(new List<string>() {
                                                        "2901", "2905", "2909", "2913" });
                    allPositionList.AddRange(new List<string>() {
                                                        "2701" , "2705" , "2709" , "2713" ,"2501" , "2505" , "2509" , "2513" ,  "3501" , "3505" , "3509" , "3513","3301", "3305", "3309", "3313"});
                    break;

                case "3N":
                    positionList.AddRange(new List<string>() { "3301", "3305", "3309", "3313" });
                    nearPositionList.AddRange(new List<string>() {
                                                        "3501", "3505", "3509", "3513" });
                    allPositionList.AddRange(new List<string>() {
                                                        "2901", "2905", "2909", "2913", "3101", "3105", "3109", "3113","2501" , "2505" , "2509" , "2513" , "2701", "2705", "2709", "2713" });
                    break;

                case "3S":
                    positionList.AddRange(new List<string>() { "3501", "3505", "3509", "3513" });
                    nearPositionList.AddRange(new List<string>() {
                                                        "3301", "3305", "3309", "3313" });
                    allPositionList.AddRange(new List<string>() {
                                                        "3101", "3105", "3109", "3113", "2901", "2905", "2909", "2913", "2701" , "2705" , "2709" , "2713" ,"2501" , "2505" , "2509" , "2513" });
                    break;
            }
        }
    }
}