CyberX8/Framework/Common/Alarm/AlarmListManager.cs

using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.Log;
using Aitex.Core.RT.OperationCenter;
using Aitex.Core.Util;
using CyberX8_Core;
using DocumentFormat.OpenXml.Packaging;
using MECF.Framework.Common.CommonData;
using MECF.Framework.Common.DBCore;
using MECF.Framework.Common.Equipment;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;

namespace MECF.Framework.Common.Alarm
{
    public class AlarmListManager : Singleton<AlarmListManager>
    {
        #region 内部变量
        /// <summary>
        /// 模块报警字典
        /// </summary>
        private ConcurrentDictionary<string, AlarmList> _moduleAlarmDictionary = new ConcurrentDictionary<string, AlarmList>();
        /// <summary>
        /// 模块数据告警字典(key-模块数据项,value-warn对象)
        /// </summary>
        private ConcurrentDictionary<string, AlarmList> _moduleDataItemWarnDictionary = new ConcurrentDictionary<string, AlarmList>();
        /// <summary>
        /// 模块报警数据
        /// </summary>
        List<AlarmList> _alarmLists = new List<AlarmList>();
        #endregion

        /// <summary>
        /// 初始化
        /// </summary>
        public void Initialize()
        {
            _alarmLists = AlarmListRecorder.GetAllAlarmListDatas();
            DATA.Subscribe("System.AlarmList", () => _alarmLists, SubscriptionAttribute.FLAG.IgnoreSaveDB);

            OP.Subscribe($"Alarm.Acknowledge", AcknowledgeAction);
            foreach (AlarmList item in _alarmLists)
            {
                if (item.AlarmType == (int)AlarmType.Error)
                {
                    _moduleAlarmDictionary[item.ModuleName] = item;
                }
                else if (item.AlarmType == (int)AlarmType.Warning || item.AlarmType == (int)AlarmType.DataError)
                {
                    _moduleDataItemWarnDictionary[$"{item.ModuleName}.{item.DataItem}"] = item;
                }
            }
        }

        public bool AcknowledgeAction(string cmd, object[] args)
        {
            string moduleName = args[0].ToString();
            string dataItem = args[1].ToString();
            Acknowledge(moduleName, dataItem);
            return true;
        }

        /// <summary>
        /// 是否包含
        /// </summary>
        /// <param name="moduleName"></param>
        /// <returns></returns>
        public bool IsContained(string moduleName)
        {
            return _moduleAlarmDictionary.ContainsKey(moduleName);
        }
        /// <summary>
        /// 增加报警
        /// </summary>
        /// <param name="alarm"></param>
        public void AddAlarm(AlarmList alarm)
        {
            if (!_moduleAlarmDictionary.ContainsKey(alarm.ModuleName))
            {
                _moduleAlarmDictionary[alarm.ModuleName] = alarm;
                AlarmListRecorder.AddAlarmList(alarm);
                _alarmLists.Add(alarm);
            }
            else
            {
                _moduleAlarmDictionary[alarm.ModuleName] = alarm;
                AlarmListRecorder.UpdateAlarmList(alarm);
                AlarmList alarmList = _alarmLists.Find(O => O.ModuleName == alarm.ModuleName && O.AlarmType == (int)AlarmType.Error);
                if (alarmList != null)
                {
                    alarmList.Clone(alarm);
                }
            }
        }
        /// <summary>
        /// 增加Warn
        /// </summary>
        /// <param name="moduleName"></param>
        /// <param name="dataItem"></param>
        /// <param name="warnMsg"></param>
        public bool AddWarn(string moduleName, string dataItem, string warnMsg)
        {
            string str = $"{moduleName}.{dataItem}";
            if (!_moduleDataItemWarnDictionary.ContainsKey(str))
            {
                AlarmList alarm = new AlarmList();
                alarm.ModuleName = moduleName;
                alarm.DataItem = dataItem;
                alarm.AlarmMsg = warnMsg;
                alarm.AlarmType = (int)AlarmType.Warning;
                alarm.CreateTime = DateTime.Now;
                _moduleDataItemWarnDictionary[str] = alarm;
                AlarmListRecorder.AddAlarmList(alarm);
                _alarmLists.Add(alarm);
                return true;
            }
            return false;
        }
        /// <summary>
        /// 增加DataError
        /// </summary>
        /// <param name="moduleName"></param>
        /// <param name="dataItem"></param>
        /// <param name="warnMsg"></param>
        public bool AddDataError(string moduleName, string dataItem, string warnMsg)
        {
            string str = $"{moduleName}.{dataItem}";
            if (!_moduleDataItemWarnDictionary.ContainsKey(str))
            {
                AlarmList alarm = new AlarmList();
                alarm.ModuleName = moduleName;
                alarm.DataItem = dataItem;
                alarm.AlarmMsg = warnMsg;
                alarm.AlarmType = (int)AlarmType.DataError;
                alarm.CreateTime = DateTime.Now;
                _moduleDataItemWarnDictionary[str] = alarm;
                AlarmListRecorder.AddAlarmList(alarm);
                _alarmLists.Add(alarm);
                return true;
            }
            return false;
        }
        /// <summary>
        /// 确认
        /// </summary>
        /// <param name="moduleName"></param>
        /// <param name="dataItem"></param>
        public void Acknowledge(string moduleName, string dataItem)
        {
            string str = $"{moduleName}.{dataItem}";
            if (_moduleDataItemWarnDictionary.ContainsKey(str))
            {
                _moduleDataItemWarnDictionary.TryRemove(str, out AlarmList alarmList);
                if (alarmList != null)
                {
                    AlarmListRecorder.RemoveAlarmList(alarmList);
                    AlarmList alarm = _alarmLists.Find(O => O.ModuleName == moduleName && (O.AlarmType == (int)AlarmType.Warning || O.AlarmType == (int)AlarmType.DataError) && O.DataItem == alarmList.DataItem);
                    if (alarm != null)
                    {
                        _alarmLists.Remove(alarm);
                    }
                }
            }
        }
        /// <summary>
        /// 获取模块报警信息
        /// </summary>
        /// <param name="moduleName"></param>
        /// <returns></returns>
        public AlarmList GetAlarmListByModule(string moduleName)
        {
            return _moduleAlarmDictionary.ContainsKey(moduleName) ? _moduleAlarmDictionary[moduleName] : null;
        }
        /// <summary>
        /// 检验模块Alarm确认后移除
        /// </summary>
        /// <param name="moduleName"></param>
        /// <param name="state"></param>
        public void CheckModuleAlamAndRemove(string moduleName, string state)
        {
            if (IsContained(moduleName))
            {
                AlarmList alarmList = GetAlarmListByModule(moduleName);

                if (alarmList != null)
                {
                    if (alarmList.ModuleState == state || string.IsNullOrEmpty(state))
                    {
                        RemoveAlarm(moduleName);
                        AlarmList alarm = _alarmLists.Find(O => O.ModuleName == moduleName);
                        if (alarm != null)
                        {
                            _alarmLists.Remove(alarm);
                        }
                    }
                }
            }
        }
        /// <summary>
        /// 移除报警
        /// </summary>
        /// <param name="moduleName"></param>
        private void RemoveAlarm(string moduleName)
        {
            if (_moduleAlarmDictionary.ContainsKey(moduleName))
            {
                _moduleAlarmDictionary.TryRemove(moduleName, out AlarmList alarmList);
                if (alarmList != null)
                {
                    AlarmListRecorder.RemoveAlarmList(alarmList);
                    int index = _alarmLists.FindIndex(O => O.ModuleName == moduleName && O.AlarmType == (int)AlarmType.Error);
                    if (index != -1)
                    {
                        _alarmLists.RemoveAt(index);
                    }
                }
            }
        }
        /// <summary>
        /// 初始化成功时移除相关的DataError
        /// </summary>
        /// <param name="moduleName"></param>
        public void RemoveDataError(string moduleName)
        {
            foreach (var item in _moduleDataItemWarnDictionary.Keys)
            {
                if (item.Contains(moduleName) && _moduleDataItemWarnDictionary[item].AlarmType == (int)AlarmType.DataError)
                {
                    _moduleDataItemWarnDictionary.TryRemove(item, out AlarmList alarmList);
                    if (alarmList != null)
                    {
                        AlarmListRecorder.RemoveAlarmList(alarmList);
                        AlarmList alarm = _alarmLists.Find(O => O.ModuleName == moduleName && O.DataItem == alarmList.DataItem);
                        if (alarm != null)
                        {
                            _alarmLists.Remove(alarm);
                        }
                    }
                }
            }
        }
        /// <summary>
        /// 判断是否存在dataerror
        /// </summary>
        /// <param name="module"></param>
        /// <param name="dataItem"></param>
        /// <returns></returns>
        public bool IsContainDataError(string module, string dataItem)
        {
            bool result = false;
            result = _moduleDataItemWarnDictionary.ContainsKey($"{module}.{dataItem}");
            return result;
        }
        /// <summary>
        /// 清除所有报警
        /// </summary>
        public void ClearAllAlarm()
        {
            _alarmLists.Clear();
            _moduleAlarmDictionary.Clear();
            AlarmListRecorder.RemoveAllAlarmList();
        }

    }
}