SX-WCS/业务工程/时效库/WCS.WorkEngineering/Systems/装箱码垛/入缓存扫码.cs

using Castle.Core.Internal;
using Newtonsoft.Json;
using ServiceCenter.Extensions;
using ServiceCenter.Logs;
using ServiceCenter.SqlSugars;
using SqlSugar;
using System.ComponentModel;
using System.Threading.Tasks;
using WCS.Core;
using WCS.Entity;
using WCS.Entity.Protocol.BCR;
using WCS.Entity.Protocol.Station;
using WCS.WorkEngineering.Extensions;
using WCS.WorkEngineering.WebApi.Models.WCS.Request;
using WCS.WorkEngineering.Worlds;
using TaskStatus = WCS.Entity.TaskStatus;

namespace WCS.WorkEngineering.Systems.装箱码垛
{
    [BelongTo(typeof(PalletizingWorld))]
    [Description("入缓存扫码")]
    public class 入缓存扫码 : DeviceSystem<Device<IBCR83, IStation525>>
    {
        protected override bool ParallelDo => true;

        public override void Do(Device<IBCR83, IStation525> obj)
        {
            //待处理条码组
            var pendingBcrList = obj.Data.GetBcrCodeList().Where(x => !x.IsNullOrEmpty());
            //缓存条码组
            var cacheBcrList = obj.Data2.GetBcrCodeList();
            //筛选出未处理的条码
            var codes = pendingBcrList.Where(x => !cacheBcrList.Contains(x)).ToList();

            var a = false;

            //循环处理所有缓存条码组中没有的条码
            foreach (var bcrCode in codes)
            {
                if (a) continue;
                WCS_TaskInfo taskInfo = null;
                var next = "";
                short isCP = 0; //默认非层配
                try
                {
                    #region 处理异常任务

                    var item = SqlSugarHelper.Do(db =>
                    {
                        //码垛抓取扫码异常任务直接去异常点
                        if (db.Default.Queryable<WCS_TaskInfo>().Any(v => v.BarCode == bcrCode && v.Status == Entity.TaskStatus.Error)) return null;

                        var a = db.Default.Queryable<WCS_TaskInfo>()
                            .Where(a => a.BarCode == bcrCode)
                            .First();
                        return a;
                    });

                    if (item == null)
                    {
                        MainWorld.Redis.Set($"Sx:WCSErrorInfo:{obj.Entity.Code}", JsonConvert.SerializeObject(new RedisError() { Equip = obj.Entity.Code, Con = $"扫码器{obj.Entity.Code}条码{bcrCode}找不到对应任务", Time = DateTime.Now }));
                        var error = new BaseErrorinfoWcs()
                        {
                            ContBarCode = bcrCode,
                            Message = $"码垛异常排出口|5251,扫码器{obj.Entity.Code},根据条码{bcrCode}查询出的任务不是码垛出库任务,自动异常排出,{DateTime.UtcNow.ToString("yyyyMMddHHmmfff")}",
                            Count = 1,
                            Memo = "WCS"
                        };
                        error.UpdataErrorinfo();
                        Circling(obj, 5038, 5173, bcrCode);
                        continue;
                    }
                    if (item.AddrTo != "8090" && item.AddrTo != "8092" && item.AddrTo != "8096" && item.AddrTo != "8098")
                    {
                        var error = new BaseErrorinfoWcs()
                        {
                            ContBarCode = bcrCode,
                            Message = $"码垛异常排出口|5251,扫码器{obj.Entity.Code},根据条码{bcrCode}查询出的任务不是码垛出库任务,自动异常排出,{DateTime.UtcNow.ToString("yyyyMMddHHmmfff")}",
                            Count = 1,
                            Memo = "WCS"
                        };
                        error.UpdataErrorinfo();

                        Circling(obj, 5038, 5180, bcrCode);
                        continue;
                    }

                    #endregion 处理异常任务

                    SqlSugarHelper.Do(db =>
                    {
                        var task = db.Default.Queryable<WCS_TaskInfo>()
                            .Where(x => x.BarCode == bcrCode)
                            .First();
                        if (task.Status >= TaskStatus.码垛抓取扫码)
                        {
                            var error = new BaseErrorinfoWcs()
                            {
                                ContBarCode = bcrCode,
                                Message = $"码垛入缓存扫码口|5251,扫码器{obj.Entity.Code},根据条码{bcrCode}查询出的任务状态大于或等于码垛抓取扫码,自动异常排出,{DateTime.UtcNow.ToString("yyyyMMddHHmmfff")}",
                                Count = 1,
                                Memo = "WCS"
                            };
                            error.UpdataErrorinfo();
                            Circling(obj, 5251, 5180, bcrCode);
                            return;
                        }

                        var palletizing = db.Default.Queryable<Palletizing>().First(x => x.ID == task.PalletizingID);//当前任务的层配规则
                        isCP = palletizing.BoxRule == "CP" ? 1.ToShort() : 0.ToShort();//获取当前任务是否层配

                        var cacheList = new List<string>();

                        if (task.Robot is "Robot1" or "")
                        {
                            cacheList = new List<string>() { /*"5100",*/ "5086", "5070", "5056" };
                        }
                        else if (task.Robot is "Robot2" or "")
                        {
                            cacheList = new List<string>() { "5310", "5295", "5280", "5265" };
                        }
                        //当前任务是否正在码垛
                        var isPallet = db.Default.Queryable<Palletizing>().Any(v => v.PalletizState == 0 && v.ID == task.PalletizingID);

                        if ((task.Status == Entity.TaskStatus.码垛缓存扫码 || (task.Status == TaskStatus.码垛缓存放行 && isPallet)) && task.AddrNext != null) //已分配地址，状态为码垛缓存扫码或者码垛缓存放行并且是当前正在码垛
                        {
                            if (isPallet) //正在码垛
                            {
                                var addrTo = task.AddrTo;
                                var addrScan = Device.All.First(v => v.HasProtocol<IStation521>() && v.HasFlag("装箱码垛") && v.HasFlag("码垛工位", addrTo) && v.HasFlag("位置", "扫码"));
                                next = addrScan.Code;
                            }
                            else next = task.AddrNext;
                        }
                        else
                        {
                            if (isCP == 0) // fei ceng pei
                            {
                                //当前任务同箱同层的是否有已经分地址了 哪一个多就往哪一个道分配
                                var addNext = db.Default.Queryable<WCS_TaskInfo>()
                                    .Where(x => x.PalletizingID == task.PalletizingID && cacheList.Contains(x.AddrNext) && x.Status < TaskStatus.码垛缓存放行)
                                    .ToList()
                                    .GroupBy(x => x.AddrNext)
                                    .Where(x => x.Count() < 13).MaxBy(x => x.Count());

                                if (addNext == null || addNext.Count() >= 13)
                                {
                                    //找到所有未复核成功的任务信息的下一个地址
                                    var addrNextList = db.Default.Queryable<WCS_TaskInfo>().Where(x => x.Type == TaskType.OutDepot && x.BusType == "装箱码垛" && x.Status == TaskStatus.码垛缓存扫码)
                                            .ToList().Select(x => x.AddrNext).Distinct().ToList();
                                    //找到没有被使用过的下一个地址
                                    var caches = cacheList.Where(x => !addrNextList.Contains(x)).OrderBy(x => x.ToShort()).ToList();
                                    if (caches == null || caches.Count < 1) //没有可以使用的缓存位了，绕圈去
                                    {
                                        //是正在码垛的箱
                                        if (db.Default.Queryable<Palletizing>().Any(v => v.PalletizState == 0 && v.ID == task.PalletizingID))
                                        {
                                            var addrTo = task.AddrTo;
                                            var addrScan = Device.All.First(v => v.HasProtocol<IStation521>() && v.HasFlag("装箱码垛") && v.HasFlag("码垛工位", addrTo) && v.HasFlag("位置", "扫码"));
                                            next = addrScan.Code;
                                            task.AddrNext = next;
                                            task.EditTime = DateTime.Now;
                                            task.Status = Entity.TaskStatus.码垛缓存放行;
                                            db.Default.Updateable(task).ExecuteCommand();
                                            task.AddWCS_TASK_DTL(db.Default, obj.Entity.Code, "码垛缓存放行");

                                            var error1 = new BaseErrorinfoWcs()
                                            {
                                                ContBarCode = bcrCode,
                                                Message = $"入缓存扫码|5251,当前正在码垛工字轮条码{bcrCode}已无可用缓存道,直接去往码垛位,{DateTime.Now:yyyyMMddHH}",
                                                Count = 1,
                                                Memo = "WCS"
                                            };
                                            error1.UpdataErrorinfo();
                                            return;
                                        }

                                        var error = new BaseErrorinfoWcs()
                                        {
                                            ContBarCode = bcrCode,
                                            Message = $"入缓存扫码|5251,条码{bcrCode}已无可用缓存道,{DateTime.Now:yyyyMMddHH}",
                                            Count = 1,
                                            Memo = "WCS"
                                        };
                                        error.UpdataErrorinfo();
                                        Circling(obj, task.ID, 5173, bcrCode);
                                        return;
                                    }

                                    if (caches.Count == 1) //可以使用的缓存位只有一个
                                    {
                                        if (db.Default.Queryable<WCS_TaskInfo>().Count(x => x.PalletizingID == task.PalletizingID && x.Status < Entity.TaskStatus.码垛缓存扫码) > 10)
                                        {
                                            //获取同机械臂正在码垛的另一箱任务，同一时间同一机械臂只能有一箱在码垛
                                            var pallet = db.Default.Queryable<Palletizing>().Where(v => v.PalletizState == 0 && v.Robot == task.Robot && v.ID != task.PalletizingID).First();

                                            //判断获取到的码垛箱是否有未进入码垛缓存放行的任务
                                            if (pallet != null && db.Default.Queryable<WCS_TaskInfo>().Any(x => x.PalletizingID == pallet.ID && x.Status < Entity.TaskStatus.码垛缓存扫码))
                                            {
                                                //没有已经分配缓存道的任务
                                                if (!db.Default.Queryable<WCS_TaskInfo>().Any(x => x.PalletizingID == pallet.ID && x.Status == Entity.TaskStatus.码垛缓存扫码))
                                                {
                                                    var error = new BaseErrorinfoWcs()
                                                    {
                                                        ContBarCode = bcrCode,
                                                        Message = $"入缓存扫码|5251,,{task.PalletizingID}的同机械臂的另外一箱任务还没有占用任何一个缓存道，需要留出缓存行走另一箱的产品，因此此产品绕圈去,{DateTime.Now:yyyyMMddHH}",
                                                        Count = 1,
                                                        Memo = "WCS"
                                                    };
                                                    error.UpdataErrorinfo();
                                                    Circling(obj, task.ID, 5173, bcrCode);
                                                    return;
                                                }
                                            }
                                        }

                                        //if (pallet.ID != task.PalletizingID) //不是当前机械臂的第一箱(最早一箱)
                                        //{
                                        //    if (!db.Default.Queryable<WCS_TaskInfo>().Any(x => x.PalletizingID == pallet.ID && x.Status < Entity.TaskStatus.码垛抓取扫码 && addrNextList.Contains(x.AddrNext)))
                                        //    {
                                        //        //获取当前任务对应码垛信息
                                        //        var curPallet = db.Default.Queryable<Palletizing>().With(SqlWith.NoLock).First(x => x.ID == task.PalletizingID);
                                        //        //当前机械臂中在当前任务码垛信息前未结束的码垛信息
                                        //        var palletIds = db.Default.Queryable<Palletizing>().With(SqlWith.NoLock)
                                        //            .Where(x => x.PalletizState != 1 && x.Robot == task.Robot && x.AddTime < curPallet.AddTime)
                                        //            .Select(x => x.ID).ToList();

                                        //        //判断正在码垛的箱是否全部大于等于码垛扫码的，如果不是，就需要留下一条线用来走上一箱的最后几个轮子
                                        //        var isOut = db.Default.Queryable<WCS_TaskInfo>().With(SqlWith.NoLock).Any(x => palletIds.Contains(x.PalletizingID) && x.Status < Entity.TaskStatus.码垛抓取扫码);

                                        //        if (isOut)
                                        //        {
                                        //            var error = new BaseErrorinfoWcs()
                                        //            {
                                        //                ContBarCode = bcrCode,
                                        //                Message = $"入缓存扫码|5251,,{task.PalletizingID}的上一箱未全部经过抓取扫码，需要流出缓存行走上一箱的产品，因此此产品绕圈去,{DateTime.Now:yyyyMMddHH}",
                                        //                Count = 1,
                                        //                Memo = "WCS"
                                        //            };
                                        //            error.UpdataErrorinfo();
                                        //            Circling(obj, task.ID, 5173, bcrCode);
                                        //            return;
                                        //        }
                                        //    }
                                        //}
                                    }
                                    //判断当前箱的
                                    var cache = caches.FirstOrDefault();
                                    next = cache;
                                    task.AddrNext = next;
                                    task.EditTime = DateTime.Now;
                                    task.Status = Entity.TaskStatus.码垛缓存扫码;
                                    db.Default.Updateable(task).ExecuteCommand();
                                    task.AddWCS_TASK_DTL(db.Default, obj.Entity.Code, "码垛缓存");
                                }
                                else
                                {
                                    next = addNext.Key;
                                    task.AddrNext = next;
                                    task.EditTime = DateTime.Now;
                                    task.Status = Entity.TaskStatus.码垛缓存扫码;
                                    db.Default.Updateable(task).ExecuteCommand();
                                    task.AddWCS_TASK_DTL(db.Default, obj.Entity.Code, "码垛缓存");
                                }
                            }
                            else
                            {
                                //当前任务同箱同层的是否有已经分地址了
                                var addNext = db.Default.Queryable<WCS_TaskInfo>().First(x => x.PalletizingID == task.PalletizingID && x.AgvTaskID == task.AgvTaskID && cacheList.Contains(x.AddrNext));
                                if (addNext == null) //同层没有已分配的
                                {
                                    //找到所有未复核成功的任务信息的下一个地址
                                    var addrNextList = db.Default.Queryable<WCS_TaskInfo>().Where(x => x.Type == TaskType.OutDepot && x.BusType == "装箱码垛" && x.Status < TaskStatus.码垛抓取扫码)
                                            .ToList().Select(x => x.AddrNext).Distinct().ToList();
                                    //找到没有被使用过的下一个地址
                                    var cache = cacheList.Where(x => !addrNextList.Contains(x)).OrderBy(x => x.ToShort()).ToList().First();

                                    task.AddrNext = cache;
                                    task.EditTime = DateTime.Now;
                                    task.Status = Entity.TaskStatus.码垛缓存扫码;
                                    db.Default.Updateable(task).ExecuteCommand();
                                    task.AddWCS_TASK_DTL(db.Default, obj.Entity.Code, "码垛缓存");
                                }
                                else
                                {
                                    next = addNext.AddrNext;
                                    task.AddrNext = next;
                                    task.EditTime = DateTime.Now;
                                    task.Status = Entity.TaskStatus.码垛缓存扫码;
                                    db.Default.Updateable(task).ExecuteCommand();
                                    task.AddWCS_TASK_DTL(db.Default, obj.Entity.Code, "码垛缓存");
                                }
                            }
                        }

                        taskInfo = task;
                    });
                }
                catch (Exception e)
                {
                    World.Log($"{bcrCode}:----{e.Message}", LogLevelEnum.High);
                    continue;
                }

                if (taskInfo == null) continue;
                if (string.IsNullOrEmpty(next))
                    continue;
                //开始赋值
                obj.Data2.GetType().GetProperty($"TaskNumber{obj.Data2.NextIndex}").SetValue(obj.Data2, taskInfo.ID);
                obj.Data2.GetType().GetProperty($"TaskNumber{obj.Data2.NextIndex}").SetValue(obj.Data2, taskInfo.ID);
                //此处起始点表示是否为层配盘，0为层配 1为非控制盘
                obj.Data2.GetType().GetProperty($"GoodsStart{obj.Data2.NextIndex}").SetValue(obj.Data2, isCP);
                obj.Data2.GetType().GetProperty($"GoodsStart{obj.Data2.NextIndex}").SetValue(obj.Data2, isCP);
                obj.Data2.GetType().GetProperty($"GoodsEnd{obj.Data2.NextIndex}").SetValue(obj.Data2, next.ToShort());
                obj.Data2.GetType().GetProperty($"GoodsEnd{obj.Data2.NextIndex}").SetValue(obj.Data2, next.ToShort());
                obj.Data2.GetType().GetProperty($"BcrCode{obj.Data2.NextIndex}").SetValue(obj.Data2, bcrCode);
                if (obj.Data2.NextIndex >= 9)
                {
                    obj.Data2.NextIndex = 0;
                }
                else
                {
                    obj.Data2.NextIndex++;
                }

                a = true;
            }
        }

        public override bool Select(Device dev)
        {
            return dev.Code == "5251";
        }

        public void Circling(Device<IBCR83, IStation525> obj, int taskNumber, short next, string bcrCode)
        {
            obj.Data2.GetType().GetProperty($"TaskNumber{obj.Data2.NextIndex}").SetValue(obj.Data2, taskNumber);
            obj.Data2.GetType().GetProperty($"TaskNumber{obj.Data2.NextIndex}").SetValue(obj.Data2, taskNumber);
            obj.Data2.GetType().GetProperty($"GoodsEnd{obj.Data2.NextIndex}").SetValue(obj.Data2, next);
            obj.Data2.GetType().GetProperty($"GoodsEnd{obj.Data2.NextIndex}").SetValue(obj.Data2, next);
            obj.Data2.GetType().GetProperty($"BcrCode{obj.Data2.NextIndex}").SetValue(obj.Data2, bcrCode);
            if (obj.Data2.NextIndex >= 9)
            {
                obj.Data2.NextIndex = 0;
            }
            else
            {
                obj.Data2.NextIndex++;
            }
        }
    }
}