YG-MW-WCS/Projects/永冠/WCS.Service/Works/Stations/拆母盘位.cs

using DBHelper;
using Microsoft.EntityFrameworkCore;
using System;
using System.Linq;
using WCS.Core;
using WCS.Entity;
using WCS.Entity.Protocol;
using WCS.Service.Extensions;

namespace WCS.Service.Works.Stations
{
    [WorkTitle(typeof(ProductHandler), "拆母盘位")]
    internal class 拆母盘位 : DeviceWork<Device<IStation521, IStation520, IStation523>>
    {
        private Device<IRGV521> Rgv;

        public 拆母盘位()
        {
            Rgv = Device.Find("RGV3").Device<IRGV521>();
        }

        protected override bool SelectDevice(WCS_DEVICE obj)
        {
            return obj.Is(DF.拆盘) && obj.PalletType() == 4;
        }

        protected override void Do(Device<IStation521, IStation520, IStation523> dev)
        {
            if (!dev.Data3.Status.HasFlag(StationStatus.自动)) return;
            if (Ltc.Do(dev, v => v.Data2.RES == true))
            {
                return;
            }
            if (Ltc.Do(dev, v => v.Data.RES == true))
            {
                //DB.Do(db =>
                //{
                //    var taskid = dev.Data.TASKNUM;
                //    var task = db.Default.Set<WCS_TASK>().Find(taskid);
                //    if (task != null)
                //    {
                //        if (task.STATUS < WCS.Entity.TaskStatus.已完成)
                //        {
                //            task.STATUS = WCS.Entity.TaskStatus.已完成;
                //            task.ENDTIME = DateTime.Now;
                //            //task.ADDRCURRENT = dev.Entity.CODE;
                //            db.Default.SaveChanges();
                //        }
                //    }
                //    dev.Data2.RES = true;
                //});
                dev.Data2.RES = true;
                return;
            }

            if (Ltc.Do(dev, v => v.Data.PH_STATUS == false && v.Data.PH_STATUS2 == false && v.Data.REQUEST == false && v.Data.TASKNUM == 0))
            {//需要呼叫空托盘
                return;
                Ltc.Log("待呼叫托盘");
                if (Ltc.Do(Rgv, Rgv => Rgv.Data.WorkMode != RGVMode.自动))
                    return;
                //if (Ltc.Do(dev, v => !v.Entity.WakeupOn(5000,"拆盘")))
                //    return;

                var palletType = dev.Entity.PalletType();
                DB.Do(db =>
                {
                    var task = db.Default.Set<WCS_TASK>().Where(v => v.STATUS < WCS.Entity.TaskStatus.已完成 && v.TYPE == TaskType.出库)
                    .Where(v => v.ADDRTO == dev.Entity.CODE)
                    .FirstOrDefault();
                    if (task != null)
                        return;

                    var res = WMS.GetPalletOutTask(palletType, dev.Entity.CODE);
                    var sc = Device.Find(res.TunnelNum).ROUTES.Where(v => v.NEXT.IsSC()).Select(v => v.NEXT).FirstOrDefault();

                    var loc = string.Format("{0}-{1}-{2}", res.Row, res.Colomn, res.Layer);
                    task = new WCS_TASK
                    {
                        TYPE = TaskType.出库,
                        STATUS = WCS.Entity.TaskStatus.新建,
                        ADDRFROM = loc,
                        ADDRTO = dev.Entity.CODE,
                        BARCODE = res.ContainerBarCode,
                        TUNNEL = res.TunnelNum,
                        PALLETTYPE = palletType,
                        WMSTASK = int.Parse(res.WMSTaskNum),
                        FLOOR = 2,
                        UPDATEUSER = "WCS",
                        SCSTATION = res.Memo1,
                        DEVICE = sc.CODE,
                        //ADDRCURRENT = loc,
                        ADDRNEXT = dev.Entity.CODE
                    };
                    db.Default.Set<WCS_TASK>().Add(task);
                    db.Default.SaveChanges();

                    dev.Data2.GOODSCODE = task.ID;//锁定
                });
            }
            else
            {
                Ltc.Log("已有托盘");

                if (Ltc.Do(dev, v => v.Data2.CONFIRM == true))
                {
                    return;
                }

                if (Ltc.Do(dev, v => v.Data.REQUEST == true))
                {
                    Ltc.Log("拆盘就绪");
                    var arr = Device.Where(v => (v.Is(DF.拆盘) && v.PalletType() != 4))
                        .Select(v => v.Device<IStation521, IStation520>()).ToArray();
                    arr = Ltc.Do(arr, arr => arr.Where(v => v.Data.PH_STATUS == false && v.Data.PH_STATUS2 == true && v.Data.TASKNUM == 0).ToArray());

                    var target = arr.OrderBy(v => v.UpdateTime).FirstOrDefault();
                    short maxqty = 0;
                    int docId = 0;
                    if (target == null)
                    {
                        arr = Device.Where(v => v.Is(DF.组盘)).Select(v => v.Device<IStation521, IStation520>()).ToArray();
                        arr = Ltc.Do(arr, arr => arr.Where(v => v.Data.PH_STATUS == false && v.Data.TASKNUM == 0).ToArray());
                        if (arr.Length == 0)
                            return;

                        var palletType = dev.Entity.PalletType();
                        target = Ltc.Do(arr, arr => arr.Where(v => v.Entity.Device<IRobotStation>().Data.PalletType == palletType).FirstOrDefault());
                        if (target == null)
                            return;
                        var rs = target.Entity.Device<IRobotStation>();
                        if (rs.Data.DocId == 0)
                            return;
                        maxqty = rs.Data.MaxQty;
                        docId = rs.Data.DocId;
                    }
                    var bcr = dev.Entity.BCR();
                    var barcode = bcr.CONTENT.Trim('\r');
                    if (string.IsNullOrEmpty(barcode) || !barcode.StartsWith("TPB") || barcode.Length != 8)
                        throw new Exception($"托盘条码读取异常【{barcode}】");
                    DB.Do(db =>
                    {
                        #region 检查是否有相同的正在使用的托盘

                        var dd = DateTime.Now;
                        //找出所有组盘站台信息
                        var 组盘站台 = Device.Where(v => v.Is(DF.组盘) && v.PalletType() != 4)
                            .Select(v => v.Device<IStation521, IStation520>()).ToList();
                        //找出所有有光电信号站台中的任务号
                        var taskNumbers = 组盘站台.Where(p => p.Data.TASKNUM != 0 && p.Data.PH_STATUS).Select(p => p.Data.TASKNUM);
                        //找到taskNumbers对应任务，和所有未结束的输送任务，并获取对应的托盘号
                        var barCodes = db.Default.Set<WCS_TASK>().AsNoTracking()
                                                .Where(p => taskNumbers.Any(x => p.ID == x) || (p.TYPE == TaskType.输送 && p.STATUS < WCS.Entity.TaskStatus.已完成))
                                                .Select(p => p.BARCODE);
                        if (barCodes.Any(p => p == barcode))
                        {
                            Ltc.Log($"【{barcode}】对应托盘已在工位或输送中");
                            throw new Exception($"【{barcode}】对应托盘已在工位或输送中");
                        }
                        var dbTimes = (DateTime.Now - dd).TotalMilliseconds;
                        Console.ForegroundColor = ConsoleColor.Blue;
                        Console.WriteLine("------托盘检查耗时:" + ((int)dbTimes).ToString().PadRight(4, ' ') + "");
                        Console.ResetColor();

                        #endregion 检查是否有相同的正在使用的托盘

                        var task = db.Default.Set<WCS_TASK>().Where(v => v.STATUS < WCS.Entity.TaskStatus.已完成 && v.ADDRTO == target.Entity.CODE).FirstOrDefault();
                        if (task != null)
                        {
                            Ltc.Log("已存在目的地为" + target.Entity.CODE + "的输送任务");
                            return;
                        }
                        task = new WCS_TASK
                        {
                            TYPE = TaskType.输送,
                            STATUS = WCS.Entity.TaskStatus.执行中,
                            BARCODE = barcode,
                            FLOOR = 2,
                            PALLETTYPE = target.Entity.Is(DF.拆盘) ? target.Entity.PalletType() : (short)4,
                            FULLQTY = maxqty,
                            ADDRFROM = dev.Entity.CODE,
                            ADDRTO = target.Entity.CODE,
                            UPDATETIME = DateTime.Now,
                            UPDATEUSER = "WCS",
                            DOCID = docId,
                            //ADDRCURRENT = dev.Entity.CODE
                        };
                        db.Default.Set<WCS_TASK>().Add(task);
                        db.Default.SaveChanges();

                        dev.Data2.TASKNUM = task.ID;
                        dev.Data2.GOODSEND = target.Entity.Code();
                        dev.Data2.CONFIRM = true;
                        task.CreateStatusLog(db, $"任务下发输送机[{dev.Entity.CODE}]执行,起始地址[{dev.Entity.CODE}],目标地址[{target.Entity.CODE}]");
                    });
                }
            }
        }
    }

    [WorkTitle(typeof(ProductHandler), "母盘缓存")]
    internal class 母盘缓存 : DeviceWork<Device<IStation521, IStation520, IStation523>>
    {
        public 母盘缓存()
        {
        }

        protected override bool SelectDevice(WCS_DEVICE obj)
        {
            return obj.CODE == "2198";
        }

        protected override void Do(Device<IStation521, IStation520, IStation523> dev)
        {
            if (!dev.Data3.Status.HasFlag(StationStatus.自动)) return;
            if (dev.Data.TASKNUM == 0)
            {//呼叫空托盘
                DB.Do(db =>
                {
                    var flag = db.Default.Set<WCS_TASK>().Where(v => v.ADDRTO == "2198" && v.STATUS < WCS.Entity.TaskStatus.已完成).Any();
                    if (flag)
                    {
                        Ltc.Log("已有呼叫空托盘任务");
                        return;
                    }
                    var res = WMS.GetPalletOutTask(4, dev.Entity.CODE);
                    var sc = Device.Find(res.TunnelNum).ROUTES.Where(v => v.NEXT.IsSC()).Select(v => v.NEXT).FirstOrDefault();

                    var loc = string.Format("{0}-{1}-{2}", res.Row, res.Colomn, res.Layer);
                    var task = new WCS_TASK
                    {
                        TYPE = TaskType.出库,
                        STATUS = WCS.Entity.TaskStatus.新建,
                        ADDRFROM = loc,
                        ADDRTO = dev.Entity.CODE,
                        BARCODE = res.ContainerBarCode,
                        TUNNEL = res.TunnelNum,
                        PALLETTYPE = 4,
                        WMSTASK = int.Parse(res.WMSTaskNum),
                        FLOOR = 2,
                        UPDATEUSER = "WCS",
                        SCSTATION = res.Memo1,
                        DEVICE = sc.CODE,
                        //ADDRCURRENT = loc,
                        ADDRNEXT = dev.Entity.CODE
                    };
                    db.Default.Set<WCS_TASK>().Add(task);
                    db.Default.SaveChanges();
                });
            }
            else if (dev.Data.REQUEST)
            {
                if (dev.Data2.CONFIRM)
                    return;

                DB.Do(db =>
                {
                    var task = db.Default.Set<WCS_TASK>().Find(dev.Data.TASKNUM);
                    if (task.STATUS < WCS.Entity.TaskStatus.已完成)
                    {
                        task.STATUS = WCS.Entity.TaskStatus.已完成;
                        task.UPDATETIME = DateTime.Now;

                        task.CreateStatusLog(db, "任务完成");
                        db.Default.SaveChanges();
                    }
                });
                var obj = Device.Find("2192").Device<IStation521>();
                if (obj.Data.TASKNUM == 0 && obj.Data.PH_STATUS == false && obj.Data.PH_STATUS2 == false)
                {
                    dev.Data2.TASKNUM = dev.Data.TASKNUM;
                    dev.Data2.GOODSEND = 2192;
                    dev.Data2.CONFIRM = true;
                }
            }
        }
    }
}