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

using DBHelper;
using Microsoft.EntityFrameworkCore;
using Newtonsoft.Json;
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 TaskStatus = WCS.Entity.TaskStatus;

namespace WCS.Service.Works.Station
{
    /// <summary>
    /// BOPP扫码入库
    /// </summary>
    [WorkTitle(typeof(BOPPHandler), "BOPP扫码入库")]
    public class Bopp扫码入库 : 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($"设备运行中");

                //成功创建的任务
                var finishTaskList = new List<FinishTaskList<int>>();

                //创建对应的任务
                DB.Do(db =>
                {
                    var devise = stationDeviceGroup.GetBcrValid();
                    devise.Valid();
                    var infos = devise.GetWMSInTask();

                    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,
                            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 = finishTaskList.Count.ToShort();
                        finishTask.Station.Data.CmdType = IstationCmdType.扫码入库;
                        finishTask.Station.Data.VoucherNo++;
                    }
                });
            });
        }

        protected override bool SelectDevice(WCS_DEVICE dev)
        {
            return dev.CODE == "G1157";
        }
    }

    /// <summary>
    /// BOPP巷道分配
    /// </summary>
    [WorkTitle(typeof(BOPPHandler), "BOPP巷道分配")]
    public class Bopp巷道分配 : 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 WarnException($"设备运行中");

                //成功分配巷道的任务的任务
                var finishTaskList = new List<FinishTaskList<int>>();

                //变更数据库信息
                DB.Do(db =>
                {
                    var devise = stationDeviceGroup.GetAddressValid();
                    if (!devise.Any()) return; //无可执行任务
                    var taskList = devise.ValidTaskCheck(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.SRMBOPP取货)) //一楼所有取货点
                                          .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的交货点
                        StationDevice rgvDeliveryPoint = null;
                        if (item.CODE == "TY1")
                        {
                            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.自动))//筛选出空闲的路径点，此处因输送机都是一个动力，因此可以先找路径点再找设备组
                                      .Distinct()
                                      .FirstOrDefault();//去一次重
                        }
                        else
                        {
                            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.BOPPRGV)).Select(v => v.Create<RGVDevice>());

                        var rgvTaskCount = ProtocolProxy.YGWMS150Redis.Get("BoppRgvTaskCount").ToInt();
                        if (rgvList.Count(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()) > rgvTaskCount) 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.远程) || v.SRM.Entity.CODE == "SRM1"; } 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 devise)
                    {
                        var dev = Device.Find(item.Station.Entity.CODE).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;
                        var msg = $"下达从G23移动至{dev.Data.Goodsend}的PLC指令。同时将任务分配至[{task.TUNNEL}]-[{task.DEVICE}]";
                        msg += $"[{dev.Data.Tasknum}][G23][{dev.Data.Goodsend}][{tunnelInfo.SRM.Entity.CODE}][{dev.Data.VoucherNo}[{dev.Data2.VoucherNo}]";
                        task.CreateStatusLog(db, msg, this.GetType());
                        finishTaskList.Add(new FinishTaskList<int>(task.ID, item.Station));
                    }
                    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++;
                    }
                });
            });
        }

        protected override bool SelectDevice(WCS_DEVICE dev)
        {
            return dev.CODE == "G23";
        }
    }

    /// <summary>
    /// 涂布入库旋转台二次分配巷道
    /// </summary>
    [WorkTitle(typeof(BOPPHandler), "BOPP入库旋转台二次分配巷道")]
    public class Bopp入库旋转台二次分配巷道 : 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 WarnException($"设备运行中");
                //成功分配巷道的任务的任务
                var finishTaskList = new List<FinishTaskList<int>>();

                //变更数据库信息
                DB.Do(db =>
                {
                    var devise = stationDeviceGroup.GetAddressValid();
                    if (!devise.Any()) return; //无可执行任务
                    var taskList = devise.ValidTaskCheck(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>();
                    var setting = new JsonSerializerSettings();
                    setting.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
                    setting.PreserveReferencesHandling = PreserveReferencesHandling.Objects;
                    foreach (var item in tunnels)
                    {
                        //当前巷道的取货点
                        var allIn = Device.Where(v => v.Is(DF.SRMBOPP取货))
                                          .Where(v => v.ROUTES.Any(p => p.NEXT.CODE == item.CODE)) //下一个点为当前巷道的取货点
                                          .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 => allIn.Contains(d.MEMBER.CODE))).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.空闲) || v.SRM.Entity.CODE == "SRM1" || v.SRM.Entity.CODE == "SRM2";
                        }
                        catch { return false; }
                    }).MinBy(v => tunnelNo.IndexOf(v.Tunnel.CODE));
                    if (tunnelInfo == null) throw new WarnException("无可用巷道");

                    //开始变更任务信息
                    foreach (var item in devise)
                    {
                        var dev = Device.Find(item.Station.Entity.CODE).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;
                        var msg = $"下达从{stationDeviceGroup.Entity.CODE}移动至{dev.Data.Goodsend}的PLC指令。同时将任务分配至[{task.TUNNEL}]-[{task.DEVICE}]";
                        msg += $"[{dev.Data.Tasknum}][{stationDeviceGroup.Entity.CODE}][{dev.Data.Goodsend}][{tunnelInfo.SRM.Entity.CODE}][{dev.Data.VoucherNo}[{dev.Data2.VoucherNo}]";
                        task.CreateStatusLog(db, msg, GetType());
                        finishTaskList.Add(new FinishTaskList<int>(task.ID, item.Station));
                    }
                    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 = 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() { "G1190", "G1199", "G1208", "G1217", "G1225" };
    }
}