YG-OPP-WCS/Projects/永冠OPP/WCS.Service/Extensions/TaskExtension.cs

using DBHelper;
using System;
using System.Collections.Generic;
using System.Linq;
using WCS.Core;
using WCS.Entity;
using WCS.Entity.Protocol;
using WCS.Service.Helpers;
using WCS.Service.Log;

namespace WCS.Service.Extensions
{
    /// <summary>
    /// 任务扩展
    /// </summary>
    public static class TaskExtension
    {
        public static T Create<T>(this WCS_TASK source)
        {
            return (T)Activator.CreateInstance(typeof(T), source);
        }

        /// <summary>
        /// 获取可用的出库任务
        /// </summary>
        /// <param name="tasks"></param>
        /// <returns></returns>
        public static Task[] GetOutTask(this List<WCS_TASK> tasks)
        {
            var tasklist = tasks.Select(v => v.Create<Task>());
            var task = tasklist.FirstOrDefault() ?? throw new WarnException("无可用出库任务--GetOutTask");
            //AGV任务ID不为零表示为车间叫料任务
            if (task.AgvTask != 0)
            {
                //按照AGV任务ID分一次组
                tasklist = tasklist.OrderByDescending(v => v.Priority)
                                   .ThenBy(v => v.CREATETIME)
                                   .GroupBy(v => v.AgvTask)
                                   .FirstOrDefault() ?? throw new WarnException("无可用叫料任务--GetOutTask");
                //无论这个AGV任务绑定的货物相隔多远都必须要一起出出去
                return tasklist.OrderBy(v => v.Col).ToArray();
            }
            return tasklist.OrderByDescending(v => v.Priority)
                           .GroupBy(v => v.MaterialCode)
                           .OrderBy(v => v.Key).FirstOrDefault()
                           .OrderByDescending(v => v.Priority)
                           .ThenBy(v => v.Line)
                           .ThenBy(v => v.Layer)
                           .ThenBy(v => v.Col)
                           .Take(2)
                           .DistinctBy(v => v.Col)
                           .OrderBy(v => v.Col)
                           .ToArray();
        }

        /// <summary>
        /// 获取出库任务的站台号及下一个地址
        /// </summary>
        /// <param name="task">任务</param>
        /// <param name="srmFork">货叉</param>
        public static void GetSrmStationAndaddNext(this WCS_TASK task, SrmFork srmFork)
        {
            List<Device<IStation520, IStation521, IStation523>> stations = new List<Device<IStation520, IStation521, IStation523>>();
            //取任务巷道到达目标地址的下一个地址，即任务堆垛机的站台对应的设备组
            if (task.TYPE == TaskType.倒库)
            {
                stations = Device.Where(v => v.DEVICEGROUP.Any(p => p.MEMBER == Device.Find(task.TUNNEL).GetPath(task.DEVICEDL)))
                                    .Select(v => v.Create<StationDeviceGroup>())
                                    .FirstOrDefault()?.Items
                                    .OrderByDescending(v => v.Entity.CODE)
                                    .ToList();
            }
            else
            {
                stations = Device.Where(v => v.DEVICEGROUP.Any(p => p.MEMBER == Device.Find(task.TUNNEL).GetPath(task.ADDRTO.Replace("G", ""))))
                                    .Select(v => v.Create<StationDeviceGroup>())
                                    .FirstOrDefault()?.Items
                                    .OrderByDescending(v => v.Entity.CODE)
                                    .ToList();
            }
            var ts = stations.ToArray();

            var addNext = task.TYPE == TaskType.倒库 ? task.DEVICEDL : task.ADDRTO;
            //一工位放较大的站台号
            switch (srmFork)
            {
                case SrmFork.货叉1:
                    task.SRMSTATION = ts?[0].Entity.CODE;
                    task.ADDRNEXT = ts?[0].Entity.GetPath(addNext).CODE;
                    break;

                case SrmFork.货叉2:
                    task.SRMSTATION = ts?[1].Entity.CODE;
                    task.ADDRNEXT = ts?[1].Entity.GetPath(addNext).CODE;
                    break;
            }
        }

        /// <summary>
        /// 有效任务数是否符合任务组任务数
        /// </summary>
        /// <param name="tasks"></param>
        /// <param name="executable"></param>
        /// <param name="db"></param>
        public static void ValidTaskCheck(this List<WCS_TASK> tasks, int executable, DB db)
        {
            var task = tasks.FirstOrDefault();
            var taskCount = db.Default.Set<WCS_TASK>().Count(v => v.TaskGroupKey == task.TaskGroupKey && (v.TYPE == TaskType.入库 || v.TYPE == TaskType.倒库));
            //开始检查任务数是否匹配
            if (executable != taskCount) throw new WarnException($"可执行数{executable},任务组任务数{taskCount},数量不匹配,{task.ID}-{task.TaskGroupKey}");
        }

        /// <summary>
        /// 有效任务数是否符合任务组任务数  临时
        /// </summary>
        /// <param name="tasks"></param>
        /// <param name="executable"></param>
        /// <param name="db"></param>
        public static List<WCS_TASK> ValidTaskCheck(this List<FinishTaskList<string>> devs, DB db)
        {
            var taskIds = devs.Select(v => v.Station.Data2.Tasknum).ToList();
            var taskList = db.Default.Set<WCS_TASK>().Where(v => taskIds.Contains(v.ID)).ToList();
            var task = taskList.FirstOrDefault() ?? throw new WarnException($"ValidTaskCheck 无任务"); ;
            var taskCount = db.Default.Set<WCS_TASK>().Count(v => v.TaskGroupKey == task.TaskGroupKey && v.TYPE == TaskType.入库);
            //开始检查任务数是否匹配
            if (devs.Count != taskCount) throw new WarnException($"可执行数{devs.Count},任务组任务数{taskCount},数量不匹配,{task.ID}-{task.TaskGroupKey}");
            return taskList;
        }

        /// <summary>
        /// 用于任务创建时获取放货站台
        /// </summary>
        /// <param name="task"></param>
        public static void TaskGetSrmStation(this WCS_TASK task)
        {
            task.GetSrmStationAndaddNext(SrmFork.货叉1);
            task.SRMSTATION = Device.Where(v => v.IsDevGroup()).FirstOrDefault(v => v.DEVICEGROUP.Any(b => b.MEMBER.CODE == task.SRMSTATION))?.CODE;
            task.ADDRNEXT = string.Empty;
        }

        public static void AGVStatusChange(this WCS_AGVTask task, AGVTaskStatus status, string type = "同步")
        {
            var time = task.AGVUpdateTime - task.UpdateTime;
            InfoLog.INFO_AGV($"WCS更新Status:{task.Status},AGVStatus:{status},{type};耗时:{time.Value.TotalMilliseconds}");
        }
    }

    public enum SrmIndex
    {
        工位一 = 0,
        工位二 = 1,
    }

    public class Task : WCS_TASK
    {
        /// <summary>
        /// 行
        /// </summary>
        public short Line { get; set; }

        /// <summary>
        /// 列
        /// </summary>
        public short Col { get; set; }

        /// <summary>
        /// 层
        /// </summary>
        public short Layer { get; set; }

        /// <summary>
        /// 行
        /// </summary>
        public short EndLine { get; set; }

        /// <summary>
        /// 列
        /// </summary>
        public short EndCol { get; set; }

        /// <summary>
        /// 层
        /// </summary>
        public short EndLayer { get; set; }

        public Task(WCS_TASK task)
        {

            var addrFrom = task.ADDRFROM.Split("-");

            ADDRTO = task.ADDRTO;
            TUNNEL = task.TUNNEL;
            DEVICE = task.DEVICE;
            Priority = task.Priority;
            AgvTask = task.AgvTask;
            CREATETIME = task.CREATETIME;
            MaterialCode = task.MaterialCode;
            SRMSTATION = task.SRMSTATION;
            ID = task.ID;
            Line = addrFrom[0].ToShort();
            Col = addrFrom[1].ToShort();
            Layer = addrFrom[2].ToShort();
            TYPE = task.TYPE;
            if (task.TYPE == TaskType.移库)
            {
                var addrto = task.ADDRTO.Split("-");
                EndLine = addrto[0].ToShort();
                EndCol = addrto[1].ToShort();
                EndLayer = addrto[2].ToShort();
            }
        }
    }
}