SHJX_GM/SHJX.Service.Control/Extends/TaskExtend.cs

using SHJX.Service.Control.MoveTime;

namespace SHJX.Service.Control.Extends
{
    public class TaskExtend
    {
        private static readonly ILogger logger = LogFactory.BuildLogger(typeof(TaskExtend));
        private static IDataManager _dataManager;
        private static ReadConfigUtil _readConfig;
        public TaskExtend(IDataManager dataManager, ReadConfigUtil readConfig)
        {
            _readConfig = readConfig;
            _dataManager = dataManager;
        }

        /// <summary>
        /// 计算消解时间的差值
        /// </summary>
        /// <param name="move"></param>
        /// <returns></returns>
        public bool GetDissolveDateDifference(RouteCache cache)
        {
            return GetDissolveDateDifference(cache.RouteStep, cache.Source);
        }

        /// <summary>
        /// 计算消解时间的差值
        /// </summary>
        /// <param name="step"></param>
        /// <param name="movePoint"></param>
        /// <returns></returns>
        /// 判断是否有已到时间的任务
        public bool GetDissolveDateDifference(string step, string movePoint = null)
        {
            if (movePoint is null)
            {
                return true;
            }
            DissolveDate dissolveDates = _dataManager.Query<DissolveDate>().Where(it => it.Start.Equals(true)).OrderBy(it => it.LastTryTime).First();
            if (dissolveDates is null)
            {
                return true;
            }
            ExecuteTime dissolveExecuteTime = _dataManager.Query<ExecuteTime>().Where(it => it.TypeName.Equals(ExecuteTimeName.DISSOLVE_TIME)).First();
            double taskMinDate = dissolveDates.LastTryTime.GetMinDifferenceValue();
            return (dissolveExecuteTime.Value - taskMinDate) * 60 > CalculatorContent.Instance.Factory(step).Calculate(movePoint);
        }

        public bool SearchMoveCheckAheadFinishDissolveTask()
        {
            return AheadFinishDissolveTask();
        }

        public bool ChangeMoveStateCheckAheadFinishDissolveTask()
        {
            return AheadFinishDissolveTask((dissolveDates) =>
            {
                DataCache.Instance.Set(CacheState.Early, dissolveDates.SampleSource);
                logger.LogInformation($"找到需提前结束的消解任务，任务地址 --> {dissolveDates.SampleSource},{dissolveDates.PositionName}");
            });
        }

        public bool AheadFinishDissolveTask(Action<DissolveDate> action = null)
        {
            DissolveDate dissolveDates = _dataManager.Query<DissolveDate>().Where(it => it.Start.Equals(true)).OrderBy(it => it.LastTryTime).First();
            if (dissolveDates is null)
            {
                return true;
            }
            ExecuteTime dissolveExecuteTime = _dataManager.Query<ExecuteTime>().Where(it => it.TypeName.Equals(ExecuteTimeName.DISSOLVE_TIME)).First();
            #region 判断优先级
            int taskSecondDate = dissolveDates.LastTryTime.GetSecondDifferenceValue();
            TaskRuntime.Calculate(dissolveDates.PositionName, out double xNeedTime, out double yNeedTime, out double zNeedTime, out double zfNeedTime);
            double needTime = Math.Abs(xNeedTime) + Math.Abs(yNeedTime) + Math.Abs(zNeedTime) + Math.Abs(zfNeedTime);
            if (dissolveExecuteTime.Value * 60 - taskSecondDate <= needTime)
            {
                if (CheckRegionPositionIsEnable(AreaName.TITRATION_POSITION) && CheckRegionPositionIsEnable(AreaName.TITRATION_POSITION2))
                {
                    return false;
                }
                action?.Invoke(dissolveDates);
                return false;
            }
            return true;
            #endregion
        }
        private bool CheckRegionPositionIsEnable(string name)
        {
            EquipmentArea area = _dataManager.Query<EquipmentArea>().Where(it => it.AreaName.Equals(name) && it.Enable.Equals(true)).First();
            if (area is null)
            {
                return false;
            }
            return true;
        }
        /// <summary>
        /// 判断消解间隔
        /// </summary>
        /// <returns></returns>
        public bool EstimatedDissolveInterval()
        {
            double currentIntervalValue = _dataManager.Query<DissolveInterval>().First().LastTryTime.GetMinDifferenceValue();
            ExecuteTime executeTime = _dataManager.Query<ExecuteTime>().Where(it => it.TypeName.Equals(ExecuteTimeName.DISSOLVE_INYERVAL)).First();
            return currentIntervalValue >= (executeTime?.Value);//查找间隔时间是否已经达到两分钟
        }

        /// <summary>
        /// 路由更新
        /// </summary>
        /// <param name="task"></param>
        public async void UpdateRoute(EquipmentTask task)
        {
            List<Route> routes = _dataManager.Query<Route>().Where(it => it.TaskType.Equals(task.RouteType)).ToList();
            Route currentRoute = routes.FirstOrDefault(it => it.RouteID.Equals(task.RouteID));
            int nextId = currentRoute.RouteID + 1;
            //if (currentRoute.RouteID == 2)
            //{
            //    CheckRegionPositionIsEnable(AreaName.TITRATION_POSITION, out EquipmentArea area);
            //    CheckRegionPositionIsEnable(AreaName.ADD_LIQUID_POSITION, out EquipmentArea area2);
            //    if (area?.PointName == null && area2==null)
            //    {
            //        nextId = currentRoute.RouteID + 2;
            //    }
            //}
            Route nextRoute = routes.FirstOrDefault(it => it.RouteID.Equals(nextId));
           if ((currentRoute.RouteID == 4 ) || (currentRoute.RouteID == 3))
            { 
                task.Status = TaskState.Finished;
                _dataManager.Update(task);
                SampleDetail sampleDetail = _dataManager.Query<SampleDetail>().Where(it => it.NodeName.Equals(task.Source)).First();
                if (sampleDetail is not null)
                {
                    sampleDetail.TaskStatus = DetailState.Init;
                    _dataManager.Update(sampleDetail);
                }
                Messager<string>.Send("TaskFinish", task.Source);
                List<EquipmentTask> residueTask = _dataManager.Query<EquipmentTask>().Where(it => it.Status.In
                (
                    TaskState.New, TaskState.Waiting, TaskState.Doing, TaskState.Hit,
                    TaskState.AddLiquid, TaskState.Dissolve, TaskState.Titration, TaskState.Titration2, TaskState.Execute
                )).ToList();
                if (!residueTask.Any())
                {
                    var temp = _readConfig.TaskFinishTemperatureSetting;
                    bool tempRes = EquipmentNames.DissolveHeating.WriteTemperature(temp);
                    tempRes = tempRes && EquipmentNames.TitrationHeating.WriteTemperature(temp);
                    logger.LogDebug($"任务结束，自动设置降温{(tempRes ? "成功" : "失败")}");
                    bool res = true;
                    foreach (string item in new string[] { EquipmentNames.AxisZ, EquipmentNames.AxisX, EquipmentNames.AxisY, EquipmentNames.AxisD})
                    {
                        res = res && await Task.Run(() => ExecuteCommand.MotorGoBackExecute(item));
                    }
                    logger.LogDebug($"任务结束，没有后续任务，自动返回原点{(res ? "成功" : "失败")}");
                    Messager<TaskResultArgs>.Send("AllTaskFinish");
                }
                return;
            }
            RouteStep executeStep = _dataManager.Query<RouteStep>().Where(it => it.RouteID.Equals(nextRoute.RouteID)).OrderBy(it => it.Order).First();
            task.RouteID = nextRoute.RouteID;
            task.Status = TaskState.New;
            task.RouteStep = executeStep.Step;
            _dataManager.Update(task);
        }

        /// <summary>
        /// 步骤更新
        /// </summary>
        /// <param name="task"></param>
        public void UpdateStep(EquipmentTask task)
        {
            try
            {
                List<RouteStep> steps = _dataManager.Query<RouteStep>().Where(it => it.RouteID.Equals(task.RouteID)).ToList();
                RouteStep currentStep = steps.FirstOrDefault(it => it.Step.Equals(task.RouteStep));
                int nextOrder = currentStep.Order + 1;
                RouteStep nextStep = steps.FirstOrDefault(it => it.Order.Equals(nextOrder));
                if (nextStep is null)
                {
                    UpdateRoute(task);
                    return;
                }
                task.Status = TaskState.New;
                task.RouteStep = nextStep.Step;
                _dataManager.Update(task);
            }
            catch (Exception ex)
            {
                logger.LogError(ex.ToString());
            }
        }
       
    }
}