FurnaceELK/Furnace/FurnaceRT/Equipments/PMs/PMScheduleMaintenance.cs

using Aitex.Core.Common;
using Aitex.Core.Common.DeviceData;
using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.Event;
using Aitex.Core.RT.IOCore;
using Aitex.Core.RT.Log;
using Aitex.Core.RT.OperationCenter;
using Aitex.Core.RT.Routine;
using Aitex.Core.RT.SCCore;
using Aitex.Core.UI.Control;
using Aitex.Core.Util;
using DocumentFormat.OpenXml.VariantTypes;
using FurnaceRT.Equipments.Systems;
using HslCommunication;
using MECF.Framework.Common.CommonData.EnumData;
using MECF.Framework.Common.DataCenter;
using MECF.Framework.Common.DBCore;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.Event;
using MECF.Framework.Common.OperationCenter;
using MECF.Framework.Common.Utilities;
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.PMs;
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.Robot;
using Newtonsoft.Json;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Data;
using System.Diagnostics;
using System.Linq;
using System.Runtime.Remoting.Metadata.W3cXsd2001;

namespace FurnaceRT.Equipments.PMs
{
    public partial class PMModule
    {

        private List<ScheduleMaintenanceDataItem> _dbRecords { get; set; } = new List<ScheduleMaintenanceDataItem>();
        public void MonitorScheduleMaintenance()
        {

            if (!Singleton<ScheduleMaintenanceDataManager>.Instance.IsUpdateDbRecord)
                return;
            Singleton<ScheduleMaintenanceDataManager>.Instance.IsUpdateDbRecord = false;


            GetAllDBRecord();
        }

        public void InitScheduleData()
        {
            if (_dbRecords == null || _dbRecords.Count == 0)
            {
                GetAllDBRecord();
            }

            InitBoatCurrentFilmThicknes();
            InitDryClearCount();
        }
        private void InitBoatCurrentFilmThicknes()
        {
            float value = 0;
            var item = _dbRecords.FirstOrDefault(a => a.Item == MaintenanceItemEnum.BoatRecipeThickness1.ToString() && a.Path == $"{DataItemEnum.Boat}");
            if (item == null)
            {
                value = 0;
            }
            else
            {
                if (item != null && item.Item == MaintenanceItemEnum.BoatRecipeThickness1.ToString())
                    value = item.CurrentValue;
            }
            SetCurrentFilmThickness(value);
        }
        private void InitDryClearCount()
        {
            float value = 0;
            var item = _dbRecords.FirstOrDefault(a => a.Item == MaintenanceItemEnum.RecipeStepExecuteFreq2.ToString() && a.Path.StartsWith($"{DataItemEnum.Reactor}"));
            if (item == null)
            {
                value = 0;
            }
            else
            {
                if (item != null && item.Item == MaintenanceItemEnum.RecipeStepExecuteFreq2.ToString())
                    value = item.CurrentValue;
            }
            SetDryClearCount(value);
        }
        public void GetAllDBRecord()
        {
            _dbRecords.Clear();
            DataTable dt = DataQuery.Query("select * from \"schedule_maintenance\"");

            for (int i = 0; i < dt.Rows.Count; i++)
            {
                ScheduleMaintenanceDataItem item = new ScheduleMaintenanceDataItem();
                item.Item = dt.Rows[i]["maintenance_item"].ToString();
                item.Display = dt.Rows[i]["maintenance_display"].ToString();
                item.Unit = dt.Rows[i]["unit"].ToString();
                item.MaintenanceProcessing = dt.Rows[i]["maintenance_processing"].ToString();
                item.Path = dt.Rows[i]["path"].ToString();
                item.AdditionInformationName = dt.Rows[i]["addition_information_name"].ToString();
                item.AdditionInformationDisplay = dt.Rows[i]["addition_information_display"].ToString();
                item.AdditionInformationDisplaySupplement = dt.Rows[i]["addition_information_display_supplement"].ToString();
                item.AssociationProcessRecipeName = dt.Rows[i]["association_process_recipeName"].ToString();
                if (float.TryParse(dt.Rows[i]["current_value"].ToString(), out float value))
                    item.CurrentValue = value;
                if (float.TryParse(dt.Rows[i]["scheduling_start_value"].ToString(), out value))
                    item.StartValue = value;
                if (float.TryParse(dt.Rows[i]["maintenance_limit_value"].ToString(), out value))
                    item.LimitValue = value;

                _dbRecords.Add(item);

            }
        }
        private void InitScheduleMaintenance()
        {

            new ScheduleMaintenanceData(MaintenanceItemEnum.SDCarrierUseFreq.ToString(), "Times", "CarrierWafer.SieDummy", "Carrier Kind", "Side Dummy");
            new ScheduleMaintenanceData(MaintenanceItemEnum.SDWaferThickness.ToString(), "nm", "CarrierWafer.SieDummy", "Carrier Kind", "Side Dummy");
            new ScheduleMaintenanceData(MaintenanceItemEnum.SDUsableDummyWafer.ToString(), "Sheets", "CarrierWafer.SieDummy", "Carrier Kind", "Side Dummy");
            new ScheduleMaintenanceData(MaintenanceItemEnum.SDBufferRackStayTime.ToString(), "h:m:s", "CarrierWafer.SieDummy", "Carrier Kind", "Side Dummy");
            new ScheduleMaintenanceData(MaintenanceItemEnum.SDWaferUserTime.ToString(), "h:m:s", "CarrierWafer.SieDummy", "Carrier Kind", "Side Dummy");


            new ScheduleMaintenanceData(MaintenanceItemEnum.FDCarrierUseFreq.ToString(), "Times", "CarrierWafer.FillDummy", "Carrier Kind", "Fill Dummy");
            new ScheduleMaintenanceData(MaintenanceItemEnum.FDWaferThickness.ToString(), "nm", "CarrierWafer.FillDummy", "Carrier Kind", "Fill Dummy");
            new ScheduleMaintenanceData(MaintenanceItemEnum.FDUsableDummyWafer.ToString(), "Sheets", "CarrierWafer.FillDummy", "Carrier Kind", "Fill Dummy");
            new ScheduleMaintenanceData(MaintenanceItemEnum.FDBufferRackStayTime.ToString(), "h:m:s", "CarrierWafer.FillDummy", "Carrier Kind", "Fill Dummy");
            new ScheduleMaintenanceData(MaintenanceItemEnum.FDWaferUserTime.ToString(), "h:m:s", "CarrierWafer.FillDummy", "Carrier Kind", "Fill Dummy");


            new ScheduleMaintenanceData(MaintenanceItemEnum.BoatRecipeThickness1.ToString(), "nm", "Boat");
            new ScheduleMaintenanceData(MaintenanceItemEnum.BoatTCUseTime.ToString(), "h:m:s", "Boat");
            new ScheduleMaintenanceData(MaintenanceItemEnum.BoatCKDUseTime.ToString(), "h:m:s", "Boat");
            new ScheduleMaintenanceData(MaintenanceItemEnum.BoatPUMPUseTime.ToString(), "h:m:s", "Boat");



            new ScheduleMaintenanceData(MaintenanceItemEnum.NonOperationTime1.ToString(), "h:m:s", "Conditioning");
            new ScheduleMaintenanceData(MaintenanceItemEnum.NonOperationTime2.ToString(), "h:m:s", "Conditioning");

            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeExecuteFreq.ToString(), "Times", "Reactor.Recipe", "Select Recipe");
            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeThickness.ToString(), "nm", "Reactor.Recipe", "Select Recipe");


            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeStepExecuteFreq1.ToString(), "Times", "Reactor.StepRunFreq", "Step ID");
            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeStepExecuteFreq2.ToString(), "Times", "Reactor.StepRunFreq", "Step ID");
            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeStepExecuteFreq3.ToString(), "Times", "Reactor.StepRunFreq", "Step ID");


            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeStepExecuteTime1.ToString(), "h:m:s", "Reactor.StepRunTime", "Step ID");
            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeStepExecuteTime2.ToString(), "h:m:s", "Reactor.StepRunTime", "Step ID");
            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeStepExecuteTime3.ToString(), "h:m:s", "Reactor.StepRunTime", "Step ID");
            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeStepExecuteTime4.ToString(), "h:m:s", "Reactor.StepRunTime", "Step ID");
            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeStepExecuteTime5.ToString(), "h:m:s", "Reactor.StepRunTime", "Step ID");
            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeStepExecuteTime6.ToString(), "h:m:s", "Reactor.StepRunTime", "Step ID");
            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeStepExecuteTime7.ToString(), "h:m:s", "Reactor.StepRunTime", "Step ID");
            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeStepExecuteTime8.ToString(), "h:m:s", "Reactor.StepRunTime", "Step ID");



            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeThickness1_Step.ToString(), "nm", "Reactor.StepThickness", "Step Group");
            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeThickness2_Step.ToString(), "nm", "Reactor.StepThickness", "Step Group");
            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeThickness3_Step.ToString(), "nm", "Reactor.StepThickness", "Step Group");
            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeThickness4_Step.ToString(), "nm", "Reactor.StepThickness", "Step Group");
            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeThickness5_Step.ToString(), "nm", "Reactor.StepThickness", "Step Group");
            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeThickness6_Step.ToString(), "nm", "Reactor.StepThickness", "Step Group");
            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeThickness7_Step.ToString(), "nm", "Reactor.StepThickness", "Step Group");
            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeThickness8_Step.ToString(), "nm", "Reactor.StepThickness", "Step Group");


        }
        #region Carrier/Wafer


        public void UpdateSEDWafer(List<WaferInfo> waferInfos)
        {
            if (waferInfos == null)
                return;


            if (waferInfos.Any(a => a.WaferType == WaferType.ED))
            {

                var maxEDUseCount = waferInfos.Where(a => a.WaferType == WaferType.ED).Max(a => a.UseCount);
                var maxEDUseThick = waferInfos.Where(a => a.WaferType == WaferType.ED).Max(a => a.UseThick);
                var maxEDUseTime = waferInfos.Where(a => a.WaferType == WaferType.ED).Max(a => a.UseTime);


                if (Singleton<ScheduleMaintenanceDataManager>.Instance.Item.TryGetValue(MaintenanceItemEnum.FDCarrierUseFreq.ToString(), out var FDCarrierUseFreq))
                    Singleton<ScheduleMaintenanceDataManager>.Instance.SetValue(FDCarrierUseFreq.Item, maxEDUseCount);

                if (Singleton<ScheduleMaintenanceDataManager>.Instance.Item.TryGetValue(MaintenanceItemEnum.FDWaferThickness.ToString(), out var FDWaferThickness))
                    Singleton<ScheduleMaintenanceDataManager>.Instance.SetValue(FDWaferThickness.Item, maxEDUseThick);

                if (Singleton<ScheduleMaintenanceDataManager>.Instance.Item.TryGetValue(MaintenanceItemEnum.FDWaferUserTime.ToString(), out var FDWaferUserTime))
                    Singleton<ScheduleMaintenanceDataManager>.Instance.SetValue(FDWaferUserTime.Item, maxEDUseTime);
            }
            if (waferInfos.Any(a => a.WaferType == WaferType.SD))
            {

                var maxSDUseCount = waferInfos.Where(a => a.WaferType == WaferType.SD).Max(a => a.UseCount);
                var maxSDUseThick = waferInfos.Where(a => a.WaferType == WaferType.SD).Max(a => a.UseThick);
                var maxSDUseTime = waferInfos.Where(a => a.WaferType == WaferType.SD).Max(a => a.UseTime);
                if (Singleton<ScheduleMaintenanceDataManager>.Instance.Item.TryGetValue(MaintenanceItemEnum.SDCarrierUseFreq.ToString(), out var SDCarrierUseFreq))
                    Singleton<ScheduleMaintenanceDataManager>.Instance.SetValue(SDCarrierUseFreq.Item, maxSDUseCount);

                if (Singleton<ScheduleMaintenanceDataManager>.Instance.Item.TryGetValue(MaintenanceItemEnum.SDWaferThickness.ToString(), out var SDWaferThickness))
                    Singleton<ScheduleMaintenanceDataManager>.Instance.SetValue(SDWaferThickness.Item, maxSDUseThick);

                if (Singleton<ScheduleMaintenanceDataManager>.Instance.Item.TryGetValue(MaintenanceItemEnum.SDWaferUserTime.ToString(), out var SDWaferUserTime))
                    Singleton<ScheduleMaintenanceDataManager>.Instance.SetValue(SDWaferUserTime.Item, maxSDUseTime);
            }

        }
        #endregion
        #region ScheduleMaintenance

        public void TriggerJobAutoStart(ScheduleMaintenanceDataItem item, RecipeExecEntryEnum recipeExecEntryEnumValue)
        {
            RecipeExecEntryEnumValue = recipeExecEntryEnumValue;
            ScheduleMaintenanceCommandCreateJob(item);
        }
        public string GetAlarmWarningMsg(ScheduleMaintenanceDataItem item, bool isJobAutoStart = false, string currentValue = "", string minValue = "", string maxValue = "")
        {
            string nullMessage = $"{item.Display} No recipe file associated, unable to trigger JobAutoStart";

            if (!string.IsNullOrEmpty(minValue) && !string.IsNullOrEmpty(maxValue) && !string.IsNullOrEmpty(currentValue))
            {
                return $"{item.Item}-{item.Display} {item.AdditionInformationDisplay}  {currentValue} limit is ({minValue}~{maxValue}) {item.Unit}"; ;

            }

            if (isJobAutoStart && string.IsNullOrEmpty(item.AssociationProcessRecipeName))
            {
                return nullMessage;
            }
            return $"{item.Item}-{item.Display} {item.AdditionInformationDisplay}  {item.CurrentValue} limit is ({item.StartValue}~{item.LimitValue}) {item.Unit}"; ;

        }
        #endregion

        public void UpdateBoatTotalThickness(float thickness)
        {
            var item = _dbRecords.FirstOrDefault(a => a.Item == MaintenanceItemEnum.BoatRecipeThickness1.ToString() && a.Path == $"{DataItemEnum.Boat}");

            if (item == null)
                return;

            if (item != null && item.Item == MaintenanceItemEnum.BoatRecipeThickness1.ToString())
            {
                var currentValue = Singleton<ScheduleMaintenanceDataManager>.Instance.GetItem(item.Item).CurrentValue;
                var newData = (currentValue + thickness);
                if (newData <= 0)
                {
                    Singleton<ScheduleMaintenanceDataManager>.Instance.SetValue(item.Item, 0);
                    currentValue = 0;
                }
                else
                {
                    Singleton<ScheduleMaintenanceDataManager>.Instance.SetValue(item.Item, newData);
                }
                SetCurrentFilmThickness(newData);

            }
        }

        /// <summary>
        /// 根据RecipeStep +StepGroup统计  累计膜厚
        /// </summary>
        /// <param name="recipeName"></param>
        public void UpdateRecipeStepGroupThickness(string stepName, float thickness)
        {
            if (string.IsNullOrEmpty(stepName))
                return;
            var stepNo = stepName.Split(':').FirstOrDefault();
            var list = _dbRecords
                .Where(a => !string.IsNullOrEmpty(a.AdditionInformationDisplaySupplement))
                .Where(a => a.Path == $"{DataItemEnum.Reactor}.{ReactorsEnum.StepThickness}")
                .Where(a => a.AdditionInformationDisplaySupplement.Split(',').Contains(stepNo))
                .ToList();
            if (list == null || list.Count == 0)
                return;

            foreach (var item in list)
            {
                if (item == null)
                    continue;

                var currentValue = Singleton<ScheduleMaintenanceDataManager>.Instance.GetItem(item.Item).CurrentValue;
                if ((currentValue + thickness) <= 0)
                {
                    Singleton<ScheduleMaintenanceDataManager>.Instance.SetValue(item.Item, 0);
                }
                else
                {
                    Singleton<ScheduleMaintenanceDataManager>.Instance.Increase(item.Item, thickness);
                }


            }
        }
        /// <summary>
        /// 根据RecipeStep统计 Step执行Time 累计时间
        /// </summary>
        /// <param name="recipeName"></param>
        public void UpdateRecipeStepRunTime(string stepName, double stepTime)
        {
            if (string.IsNullOrEmpty(stepName) || stepTime <= 0)
                return;
            var stepNo = stepName.Split(':').FirstOrDefault();

            var list = _dbRecords.Where(a => a.Path == $"{DataItemEnum.Reactor}.{ReactorsEnum.StepRunTime}" && a.AdditionInformationDisplay == stepNo).ToList();

            if (list == null || list.Count == 0)
                return;

            foreach (var item in list)
            {
                if (item == null)
                    continue;
                var data = Math.Round(stepTime, 1, MidpointRounding.AwayFromZero);
                Singleton<ScheduleMaintenanceDataManager>.Instance.Increase(item.Item, (float)data);



            }

        }
        /// <summary>
        /// 根据RecipeStep统计 Step执行 累计次数
        /// </summary>
        /// <param name="recipeName"></param>
        public void UpdateRecipeStepFre(string stepName)
        {
            if (string.IsNullOrEmpty(stepName))
                return;
            var stepNo = stepName.Split(':').FirstOrDefault();

            var list = _dbRecords.Where(a => a.Path == $"{DataItemEnum.Reactor}.{ReactorsEnum.StepRunFreq}" && a.AdditionInformationDisplay == stepNo).ToList();

            if (list == null || list.Count == 0)
                return;
            foreach (var item in list)
            {
                if (item == null)
                    continue;

                Singleton<ScheduleMaintenanceDataManager>.Instance.Increase(item.Item);
                if (item.Item == MaintenanceItemEnum.RecipeStepExecuteFreq2.ToString())
                {
                    var currentValue = Singleton<ScheduleMaintenanceDataManager>.Instance.GetItem(item.Item).CurrentValue;
                    SetDryClearCount(currentValue);

                }

            }
        }
        /// <summary>
        /// 根据RecipeName统计 Recipe执行 累计次数
        /// </summary>
        /// <param name="processRecipeName"></param>
        public void UpdateRecipeFre(string recipeName)
        {

            if (string.IsNullOrEmpty(recipeName))
                return;
            var item = _dbRecords
                .FirstOrDefault(a => a.Item == MaintenanceItemEnum.RecipeExecuteFreq.ToString()
                && a.Path == $"{DataItemEnum.Reactor}.{ReactorsEnum.Recipe}"
                && a.AdditionInformationDisplay == recipeName);
            if (item == null)
                return;

            if (item != null && item.Item == MaintenanceItemEnum.RecipeExecuteFreq.ToString())
                Singleton<ScheduleMaintenanceDataManager>.Instance.Increase(item.Item);


        }
        /// <summary>
        /// 根据RecipeName统计累计膜厚
        /// </summary>
        /// <param name="recipeName"></param>
        /// <param name="thickness"></param>
        public void UpdateRecipeThickness(string recipeName, float thickness)
        {
            if (string.IsNullOrEmpty(recipeName))
                return;
            var item = _dbRecords
                .FirstOrDefault(a => a.Item == MaintenanceItemEnum.RecipeThickness.ToString()
                && a.Path == $"{DataItemEnum.Reactor}.{ReactorsEnum.Recipe}"
                && a.AdditionInformationDisplay == recipeName);

            if (item == null)
                return;

            if (item != null && item.Item == MaintenanceItemEnum.RecipeThickness.ToString())
            {
                var currentValue = Singleton<ScheduleMaintenanceDataManager>.Instance.GetItem(item.Item).CurrentValue;
                if ((currentValue + thickness) <= 0)
                {
                    Singleton<ScheduleMaintenanceDataManager>.Instance.SetValue(item.Item, 0);
                }
                else
                {
                    Singleton<ScheduleMaintenanceDataManager>.Instance.Increase(item.Item, thickness);
                }

            }

        }
        /// <summary>
        /// 检查
        /// </summary>
        /// <param name="stepName"></param>
        /// <param name="isPause"></param>
        public void CheckRecipeStepGroupThicknessMoreThan(string stepName, out bool isPause, out string jobName, bool isExecJobAutoStart = true)
        {
            isPause = false;
            jobName = "";
            if (string.IsNullOrEmpty(stepName))
                return;

            var stepNo = stepName.Split(':').FirstOrDefault();
            var reactorStepThicknessList = _dbRecords
                .Where(a => a.Path == $"{DataItemEnum.Reactor}.{ReactorsEnum.StepThickness}")
                .Where(a => !string.IsNullOrEmpty(a.AdditionInformationDisplay))
                .Where(a => !string.IsNullOrEmpty(a.AdditionInformationDisplaySupplement))
                .Where(a => a.AdditionInformationDisplaySupplement.Split(',').Contains(stepNo))
                .ToList();


            foreach (var item in reactorStepThicknessList)
            {

                if (!Enum.TryParse<MaintenanceProcessingCommandEnum>(item.MaintenanceProcessing, out var command))
                    continue;

                if (item.StartValue < 0 || item.LimitValue <= item.StartValue || command == MaintenanceProcessingCommandEnum.None)
                    continue;

                string message = $"{item.Item}-{item.Display} {item.AdditionInformationDisplay}  {item.CurrentValue} limit is ({item.StartValue}~{item.LimitValue}) times";
                string nullMessage = $"{item.Display} No recipe file associated, unable to trigger JobAutoStart";


                bool isWarning = item.CurrentValue > item.StartValue && item.CurrentValue < item.LimitValue;
                bool isAlarm = item.CurrentValue >= item.LimitValue;

                if (isWarning)
                {
                    (Singleton<EquipmentManager>.Instance.Modules[ModuleName.PM1] as PMModule).ReatorStepThicknessWarning.Set(message);
                }
                if (isAlarm)
                {
                    if (command == MaintenanceProcessingCommandEnum.AlarmReport)
                        (Singleton<EquipmentManager>.Instance.Modules[ModuleName.PM1] as PMModule).ReatorStepThicknessAlarm.Set(message);

                    if (command == MaintenanceProcessingCommandEnum.JobAutoStart && isExecJobAutoStart)
                    {
                        if (string.IsNullOrEmpty(item.AssociationProcessRecipeName))
                        {
                            (Singleton<EquipmentManager>.Instance.Modules[ModuleName.PM1] as PMModule).ReatorStepThicknessAlarm.Set(nullMessage);
                        }
                        else
                        {
                            jobName = item.AssociationProcessRecipeName;
                            (Singleton<EquipmentManager>.Instance.Modules[ModuleName.PM1] as PMModule).ReatorStepThicknessWarning.Set(message);
                            var logInfo = $"{message} Trigger {item.AssociationProcessRecipeName}";
                            // var logInfo = $"{message} Trigger {item.AssociationProcessRecipeName} ,auto clear CurrentValue {item.LimitValue} to 0";
                            LOG.Info(logInfo);
                            RecipeExecEntryEnumValue = RecipeExecEntryEnum.RecipeStepRangeTrigger;
                            ScheduleMaintenanceCommandCreateJob(item);
                        }

                    }
                    isPause = true;
                    return;
                }

            }


        }


        /// <summary>
        /// 检查 RecipeStep 累计时间是否超限
        /// </summary>
        /// <param name="stepName"></param>
        /// <param name="isPause"></param>
        public void CheckRecipeStepTimeMoreThan(string stepName, out bool isPause, out string jobName, bool isExecJobAutoStart = true)
        {
            isPause = false;
            jobName = "";
            if (string.IsNullOrEmpty(stepName))
                return;

            var stepNo = stepName.Split(':').FirstOrDefault();

            var item = _dbRecords.FirstOrDefault(a => a.Path == $"{DataItemEnum.Reactor}.{ReactorsEnum.StepRunTime}" && a.AdditionInformationDisplay == stepNo);

            if (item == null || !Enum.TryParse<MaintenanceProcessingCommandEnum>(item.MaintenanceProcessing, out var command))
                return;

            if (item.StartValue < 0 || item.LimitValue <= item.StartValue || command == MaintenanceProcessingCommandEnum.None)
                return;

            string message = $"{item.Item}-{item.Display} {item.AdditionInformationDisplay}  {item.CurrentValue} limit is ({item.StartValue}~{item.LimitValue}) times";


            bool isWarning = item.CurrentValue > item.StartValue && item.CurrentValue < item.LimitValue;
            bool isAlarm = item.CurrentValue >= item.LimitValue;

            if (isWarning)
                (Singleton<EquipmentManager>.Instance.Modules[ModuleName.PM1] as PMModule).ReatorStepRunTimeWarning.Set(message);


            if (isAlarm)
            {
                if (command == MaintenanceProcessingCommandEnum.AlarmReport)
                    (Singleton<EquipmentManager>.Instance.Modules[ModuleName.PM1] as PMModule).ReatorStepRunTimeAlarm.Set(message);


                if (command == MaintenanceProcessingCommandEnum.JobAutoStart && isExecJobAutoStart)
                {
                    if (string.IsNullOrEmpty(item.AssociationProcessRecipeName))
                    {
                        (Singleton<EquipmentManager>.Instance.Modules[ModuleName.PM1] as PMModule).ReatorStepRunTimeAlarm.Set(message);
                    }
                    else
                    {
                        jobName = item.AssociationProcessRecipeName;
                        (Singleton<EquipmentManager>.Instance.Modules[ModuleName.PM1] as PMModule).ReatorStepRunTimeWarning.Set(message);
                        var logInfo = $"{message} Trigger {item.AssociationProcessRecipeName}";
                        // var logInfo = $"{message} Trigger {item.AssociationProcessRecipeName} ,auto clear CurrentValue {item.LimitValue} to 0";
                        LOG.Info(logInfo);
                        RecipeExecEntryEnumValue = RecipeExecEntryEnum.RecipeStepRangeTrigger;
                        ScheduleMaintenanceCommandCreateJob(item);
                    }
                }
                isPause = true;
                return;
            }
        }

        /// <summary>
        /// RecipeStep 累计次数是否超限
        /// </summary>
        /// <param name="stepName"></param>
        /// <param name="isPause"></param>
        public void CheckRecipeStepFreqMoreThan(string stepName, out bool isPause, out string jobName, bool isExecJobAutoStart = true)
        {
            isPause = false;
            jobName = "";
            if (string.IsNullOrEmpty(stepName))
                return;
            var stepNo = stepName.Split(':').FirstOrDefault();

            var item = _dbRecords.FirstOrDefault(a => a.Path == $"{DataItemEnum.Reactor}.{ReactorsEnum.StepRunFreq}" && a.AdditionInformationDisplay == stepNo);

            if (item == null || !Enum.TryParse<MaintenanceProcessingCommandEnum>(item.MaintenanceProcessing, out var command))
                return;

            if (item.StartValue < 0 || item.LimitValue <= item.StartValue || command == MaintenanceProcessingCommandEnum.None)
                return;

            string message = $"{item.Item}-{item.Display} {item.AdditionInformationDisplay}  {item.CurrentValue} limit is ({item.StartValue}~{item.LimitValue}) times";
            bool isWarning = item.CurrentValue > item.StartValue && item.CurrentValue < item.LimitValue;
            bool isAlarm = item.CurrentValue >= item.LimitValue;

            if (isWarning)
                (Singleton<EquipmentManager>.Instance.Modules[ModuleName.PM1] as PMModule).ReatorStepRunFreqWarning.Set(message);

            if (isAlarm)
            {
                if (command == MaintenanceProcessingCommandEnum.AlarmReport)
                    (Singleton<EquipmentManager>.Instance.Modules[ModuleName.PM1] as PMModule).ReatorStepRunFreqAlarm.Set(message);

                if (command == MaintenanceProcessingCommandEnum.JobAutoStart && isExecJobAutoStart)
                {
                    if (string.IsNullOrEmpty(item.AssociationProcessRecipeName))
                    {
                        (Singleton<EquipmentManager>.Instance.Modules[ModuleName.PM1] as PMModule).ReatorStepRunFreqAlarm.Set(message);
                    }
                    else
                    {
                        jobName = item.AssociationProcessRecipeName;
                        (Singleton<EquipmentManager>.Instance.Modules[ModuleName.PM1] as PMModule).ReatorStepRunFreqWarning.Set(message);
                        var logInfo = $"{message} Trigger {item.AssociationProcessRecipeName}";
                        LOG.Info(logInfo);
                        RecipeExecEntryEnumValue = RecipeExecEntryEnum.RecipeStepRangeTrigger;
                        ScheduleMaintenanceCommandCreateJob(item);

                    }
                }
                isPause = true;
                return;
            }

        }

        /// <summary>
        ///  检查Recipe执行 累计次数是否超限
        /// </summary>
        /// <param name="recipeName"></param>
        /// <param name="isPause"></param>
        public void CheckRecipeExecuteFreqMoreThan(string recipeName, out bool isPause, out string jobName, bool isExecJobAutoStart = true)
        {

            isPause = false;
            jobName = "";
            if (string.IsNullOrEmpty(recipeName))
                return;

            var item = _dbRecords
                         .FirstOrDefault(a =>
                          a.Item == MaintenanceItemEnum.RecipeExecuteFreq.ToString() &&
                          a.Path == $"{DataItemEnum.Reactor}.{ReactorsEnum.Recipe}" &&
                          a.AdditionInformationDisplay == recipeName);


            if (item == null || !Enum.TryParse<MaintenanceProcessingCommandEnum>(item.MaintenanceProcessing, out var command))
                return;

            if (item.StartValue < 0 || item.LimitValue <= item.StartValue || command == MaintenanceProcessingCommandEnum.None)
                return;

            string message = $"{item.Item}-{item.Display} {item.AdditionInformationDisplay}  {item.CurrentValue} limit is ({item.StartValue}~{item.LimitValue}) times";


            bool isWarning = item.CurrentValue > item.StartValue && item.CurrentValue < item.LimitValue;
            bool isAlarm = item.CurrentValue >= item.LimitValue;
            if (isWarning)
            {
                (Singleton<EquipmentManager>.Instance.Modules[ModuleName.PM1] as PMModule).RecipeExecuteFreqWarning.Set(message);
            }
            if (isAlarm)
            {
                if (command == MaintenanceProcessingCommandEnum.AlarmReport)
                    (Singleton<EquipmentManager>.Instance.Modules[ModuleName.PM1] as PMModule).RecipeExecuteFreqAlarm.Set(message);

                if (command == MaintenanceProcessingCommandEnum.JobAutoStart && isExecJobAutoStart)
                {

                    if (string.IsNullOrEmpty(item.AssociationProcessRecipeName))
                    {
                        (Singleton<EquipmentManager>.Instance.Modules[ModuleName.PM1] as PMModule).RecipeExecuteFreqAlarm.Set(message);
                    }
                    else
                    {
                        jobName = item.AssociationProcessRecipeName;
                        (Singleton<EquipmentManager>.Instance.Modules[ModuleName.PM1] as PMModule).RecipeExecuteFreqWarning.Set(message);
                        var logInfo = $"{message} Trigger {item.AssociationProcessRecipeName}";
                        // var logInfo = $"{message} Trigger {item.AssociationProcessRecipeName} ,auto clear CurrentValue {item.LimitValue} to 0";
                        LOG.Info(logInfo);
                        RecipeExecEntryEnumValue = RecipeExecEntryEnum.RecipeRangeTrigger;
                        ScheduleMaintenanceCommandCreateJob(item);
                    }
                }
                isPause = true;
                return;
            }

        }
        /// <summary>
        ///  检查Recipe执行 累计膜厚是否超限
        /// </summary>
        /// <param name="recipeName"></param>
        /// <param name="isPause"></param>
        public void CheckBoatRecipeThicknessMoreThan(out bool isPause, out string jobName, bool isExecJobAutoStart = true)
        {
            isPause = false;

            jobName = "";

            var item = _dbRecords.FirstOrDefault(a => a.Item == MaintenanceItemEnum.BoatRecipeThickness1.ToString() && a.Path == $"{DataItemEnum.Boat}");


            if (item == null || !Enum.TryParse<MaintenanceProcessingCommandEnum>(item.MaintenanceProcessing, out var command))
                return;

            if (item.StartValue < 0 || item.LimitValue <= item.StartValue || command == MaintenanceProcessingCommandEnum.None)
                return;

            string message = $"{item.Item}-{item.Display} {item.AdditionInformationDisplay}  {item.CurrentValue} limit is ({item.StartValue}~{item.LimitValue}) nm";


            bool isWarning = item.CurrentValue > item.StartValue && item.CurrentValue < item.LimitValue;
            bool isAlarm = item.CurrentValue >= item.LimitValue;
            if (isWarning)
            {
                (Singleton<EquipmentManager>.Instance.Modules[ModuleName.PM1] as PMModule).BoatRecipeThicknessWarning.Set(message);
            }
            if (isAlarm)
            {
                if (command == MaintenanceProcessingCommandEnum.AlarmReport)
                    (Singleton<EquipmentManager>.Instance.Modules[ModuleName.PM1] as PMModule).BoatRecipeThicknessAlarm.Set(message);

                if (command == MaintenanceProcessingCommandEnum.JobAutoStart && isExecJobAutoStart)
                {
                    if (string.IsNullOrEmpty(item.AssociationProcessRecipeName))
                    {
                        (Singleton<EquipmentManager>.Instance.Modules[ModuleName.PM1] as PMModule).BoatRecipeThicknessAlarm.Set(message);
                    }
                    else
                    {
                        (Singleton<EquipmentManager>.Instance.Modules[ModuleName.PM1] as PMModule).BoatRecipeThicknessAlarm.Set(message);
                        jobName = item.AssociationProcessRecipeName;
                        var logInfo = $"{message} Trigger {item.AssociationProcessRecipeName}";
                        // var logInfo = $"{message} Trigger {item.AssociationProcessRecipeName} ,auto clear CurrentValue {item.LimitValue} to 0";
                        LOG.Info(logInfo);
                        RecipeExecEntryEnumValue = RecipeExecEntryEnum.BoatRecipeRangeTrigger;
                        ScheduleMaintenanceCommandCreateJob(item, false);

                    }

                }

                isPause = true;
                return;
            }
        }
        public void CheckRecipeThicknessMoreThan(string recipeName, out bool isPause, out string jobName, bool isExecJobAutoStart = true)
        {
            isPause = false;
            jobName = "";
            if (string.IsNullOrEmpty(recipeName))
                return;

            var item = _dbRecords.FirstOrDefault(a =>
                         a.Item == MaintenanceItemEnum.RecipeThickness.ToString() &&
                         a.Path == $"{DataItemEnum.Reactor}.{ReactorsEnum.Recipe}" &&
                         a.AdditionInformationDisplay == recipeName);


            if (item == null || !Enum.TryParse<MaintenanceProcessingCommandEnum>(item.MaintenanceProcessing, out var command))
                return;

            if (item.StartValue < 0 || item.LimitValue <= item.StartValue || command == MaintenanceProcessingCommandEnum.None)
                return;

            string message = $"{item.Item}-{item.Display} {item.AdditionInformationDisplay}  {item.CurrentValue} limit is ({item.StartValue}~{item.LimitValue}) nm";


            bool isWarning = item.CurrentValue > item.StartValue && item.CurrentValue < item.LimitValue;
            bool isAlarm = item.CurrentValue >= item.LimitValue;
            if (isWarning)
            {
                (Singleton<EquipmentManager>.Instance.Modules[ModuleName.PM1] as PMModule).RecipeThicknessWarning.Set(message);
            }
            if (isAlarm)
            {
                if (command == MaintenanceProcessingCommandEnum.AlarmReport)
                    (Singleton<EquipmentManager>.Instance.Modules[ModuleName.PM1] as PMModule).RecipeThicknessAlarm.Set(message);


                if (command == MaintenanceProcessingCommandEnum.JobAutoStart && isExecJobAutoStart)
                {
                    if (string.IsNullOrEmpty(item.AssociationProcessRecipeName))
                    {
                        (Singleton<EquipmentManager>.Instance.Modules[ModuleName.PM1] as PMModule).RecipeThicknessAlarm.Set(message);
                    }
                    else
                    {
                        jobName = item.AssociationProcessRecipeName;
                        (Singleton<EquipmentManager>.Instance.Modules[ModuleName.PM1] as PMModule).RecipeThicknessWarning.Set(message);
                        var logInfo = $"{message} Trigger {item.AssociationProcessRecipeName}";
                        // var logInfo = $"{message} Trigger {item.AssociationProcessRecipeName} ,auto clear CurrentValue {item.LimitValue} to 0";
                        LOG.Info(logInfo);
                        RecipeExecEntryEnumValue = RecipeExecEntryEnum.RecipeRangeTrigger;
                        ScheduleMaintenanceCommandCreateJob(item);
                    }

                }

                isPause = true;
                return;
            }

        }


        public void ScheduleMaintenanceCommandCreateJob(ScheduleMaintenanceDataItem scheduleMaintenanceDataItem, bool isCheck = true)
        {
            if (string.IsNullOrEmpty(scheduleMaintenanceDataItem.AssociationProcessRecipeName))
                return;
            var time = DateTime.Now.ToString("yyyyMMddHHmmssfff");
            Dictionary<string, object> param = new Dictionary<string, object>()
                        {
                            {"PJID", $"PJ_{time}"},
                            {"CJID", $"CJ_{time}"},
                            {"JobRecipe", scheduleMaintenanceDataItem.AssociationProcessRecipeName},
                            {"CarrierPara", ""},
                            {"m1CarrierPara", ""},
                            {"m2CarrierPara", ""},
                            {"PJVariable", ""},
                            {"Charge", false},
                            {"IsNeedCheck", isCheck},
                            {"IsJobAutoStart", true},
                            {"ScheduleMaintenanceDataItem",JsonConvert.SerializeObject(scheduleMaintenanceDataItem)},
                        };
            Singleton<EquipmentManager>.Instance.ScheduleMaintenanceCommandCreateJob(param, 1);

        }
    }
}