Kepler-Release/Venus/Framework/Common/DataCenter/StatsDataManager.cs

using System;
using System.Collections.Generic;
using System.Data;
using Aitex.Core.RT.DBCore;
using Aitex.Core.RT.Event;
using Aitex.Core.RT.Log;
using Aitex.Core.RT.OperationCenter;
using Aitex.Core.Util;
using MECF.Framework.Common.DBCore;

namespace MECF.Framework.Common.DataCenter
{
    public class StatsDataItem
    {
        public string Name { get; set; }
        public int Value { get; set; }
        public string Description { get; set; }
        public int Total { get; set; }
        public DateTime LastUpdateTime { get; set; }
        public DateTime LastResetTime { get; set; }
        public DateTime LastResetTotalTime { get; set; }
        public int WarningValue { get; set; }
        public bool WarningEnable { get; set; }
        public int AlarmValue { get; set; }
        public bool AlarmEnable { get; set; }
        public bool IsVisible { get; set; }
    }

    public class StatsDataItemRFAndPump
    {
        public string Name { get; set; }
        public string Description { get; set; }
        public DateTime LastPMTime { get; set; }
        public double fromLastPM { get; set; }
        public double Total { get; set; }
        public double PMInterval { get; set; }
        public bool AlarmEnable { get; set; }
    }


    public class StatsDataManager:Singleton<StatsDataManager>
    {
        private Dictionary<string, StatsDataItem> _items = new Dictionary<string, StatsDataItem>();
        private Dictionary<string, StatsDataItemRFAndPump> _itemsRFAndPump = new Dictionary<string, StatsDataItemRFAndPump>();

        private object _locker = new object();

        public StatsDataManager()
        {

        }

        public void Initialize()
        {
            try
            {

                OP.Subscribe("System.Stats.ResetValue", (method, args) => 
                {
                    Reset((string)args[0]);
                    return true;
                });

                OP.Subscribe("System.Stats.EnableAlarm", (method, args) =>
                {
                    EnableAlarm((string)args[0], (bool)args[1]);
                    return true;
                });

                OP.Subscribe("System.Stats.Alarm", (method, args) =>
                {
                    Alarm((string)args[0]);
                    return true;
                });

                OP.Subscribe("System.Stats.SetAlarmValue", (method, args) =>
                {
                    SetAlarmValue((string)args[0], (int)args[1]);
                    return true;
                });

                OP.Subscribe("System.Stats.EnableWarning", (method, args) =>
                {
                    EnableWarning((string)args[0], (bool)args[1]);
                    return true;
                });

                OP.Subscribe("System.Stats.Warning", (method, args) =>
                {
                    Warning((string)args[0]);
                    return true;
                });

                OP.Subscribe("System.Stats.SetWarningValue", (method, args) =>
                {
                    SetWarningValue((string)args[0], (int)args[1]);
                    return true;
                });

                OP.Subscribe("System.Stats.ResetTotalValue", (method, args) =>
                {
                    ResetTotal((string)args[0]);
                    return true;
                });

                OP.Subscribe("System.StatsRFAndPump.EnableAlarm", (method, args) =>
                {
                    RFEnableAlarm((string)args[0], (bool)args[1]);
                    return true;
                });

                OP.Subscribe("System.StatsRFAndPump.ResetValue", (method, args) =>
                {
                    RFReset((string)args[0]);
                    return true;
                });

                OP.Subscribe("System.StatsRFAndPump.SetPMIntervalValue", (method, args) =>
                {
                    SetPMIntervalValue((string)args[0], (int)args[1]);
                    return true;
                });

                DataTable dt = DataQuery.Query("select * from \"stats_data\"");

                for (int i = 0; i < dt.Rows.Count; i++)
                {
                    StatsDataItem item  = new StatsDataItem();
                    item.Name = dt.Rows[i]["name"].ToString();
                    item.Description = dt.Rows[i]["description"].ToString();
                    if (int.TryParse(dt.Rows[i]["value"].ToString(), out int value))
                        item.Value = value;
                    if (int.TryParse(dt.Rows[i]["total"].ToString(), out int total))
                        item.Total = total;
                    if (int.TryParse(dt.Rows[i]["alarm_value"].ToString(), out int alarmValue))
                        item.AlarmValue = alarmValue;
                    if (!dt.Rows[i]["enable_alarm"].Equals(DBNull.Value))
                        item.AlarmEnable = Convert.ToBoolean(dt.Rows[i]["enable_alarm"].ToString());
                    if (int.TryParse(dt.Rows[i]["warning_value"].ToString(), out int WarningValue))
                        item.WarningValue = WarningValue;
                    if (!dt.Rows[i]["enable_warning"].Equals(DBNull.Value))
                        item.WarningEnable = Convert.ToBoolean(dt.Rows[i]["enable_warning"].ToString());
                    if (!dt.Rows[i]["is_visible"].Equals(DBNull.Value))
                        item.IsVisible = Convert.ToBoolean(dt.Rows[i]["is_visible"].ToString());
                    if (!dt.Rows[i]["last_update_time"].Equals(DBNull.Value))
                        item.LastUpdateTime = (DateTime)dt.Rows[i]["last_update_time"] ;
                    if (!dt.Rows[i]["last_reset_time"].Equals(DBNull.Value))
                        item.LastResetTime = (DateTime)dt.Rows[i]["last_reset_time"];
                    if (!dt.Rows[i]["last_total_reset_time"].Equals(DBNull.Value))
                        item.LastResetTotalTime = (DateTime)dt.Rows[i]["last_total_reset_time"];
 
                    _items[item.Name] = item;
                }

                DataTable dtRf = DataQuery.Query("select * from \"stats_data_rf_pump\"");

                for (int i = 0; i < dtRf.Rows.Count; i++)
                {
                    StatsDataItemRFAndPump itemRf = new StatsDataItemRFAndPump();
                    itemRf.Name = dtRf.Rows[i]["name"].ToString();
                    itemRf.Description = dtRf.Rows[i]["description"].ToString();
                    if (double.TryParse(dtRf.Rows[i]["total"].ToString(), out double total))
                        itemRf.Total = total;
                    if (double.TryParse(dtRf.Rows[i]["pm_interval"].ToString(), out double pmInterval))
                        itemRf.PMInterval = pmInterval;
                    if (double.TryParse(dtRf.Rows[i]["from_last_pm"].ToString(), out double fromLastPM))
                        itemRf.fromLastPM = fromLastPM;
                    if (!dtRf.Rows[i]["enable_alarm"].Equals(DBNull.Value))
                        itemRf.AlarmEnable = Convert.ToBoolean(dtRf.Rows[i]["enable_alarm"].ToString());
                    if (!dtRf.Rows[i]["last_pm_time"].Equals(DBNull.Value))
                        itemRf.LastPMTime = (DateTime)dtRf.Rows[i]["last_pm_time"];

                    _itemsRFAndPump[itemRf.Name] = itemRf;
                }

            }
            catch (Exception ex)
            {
                LOG.WriteExeption("init stats data manager failed", ex);
            }
 
        }

        private int SetAlarmValue(string name, int value)
        {
            lock (_locker)
            {
                if (!_items.ContainsKey(name))
                {
                    //LOG.Error($"Can not set {name} alarm value, not defined item");
                    return -1;
                }

                int preValue = _items[name].AlarmValue;
                _items[name].AlarmValue = value;
 
                string sql = string.Format(
                    "UPDATE \"stats_data\" SET \"alarm_value\"='{0}'WHERE \"name\"='{1}';",_items[name].AlarmValue,
                    name);
                DB.Insert(sql);

                EV.PostInfoLog("System", $"{name} stats alarm value changed from {preValue} to {value}");

                return preValue;
            }
        }
        
        private double SetPMIntervalValue(string name, int value)
        {
            lock (_locker)
            {
                if (!_itemsRFAndPump.ContainsKey(name))
                {
                    //LOG.Error($"Can not set {name} alarm value, not defined item");
                    return -1;
                }

                double preValue = _itemsRFAndPump[name].PMInterval;
                _itemsRFAndPump[name].PMInterval = value;

                string sql = string.Format(
                    "UPDATE \"stats_data_rf_pump\" SET \"pm_interval\"='{0}'WHERE \"name\"='{1}';", _itemsRFAndPump[name].PMInterval,
                    name);
                DB.Insert(sql);

                EV.PostInfoLog("System", $"{name} stats rf pump pm interval value changed from {preValue} to {value}");

                return preValue;
            }
        }

        private int SetWarningValue(string name, int value)
        {
            lock (_locker)
            {
                if (!_items.ContainsKey(name))
                {
                    //LOG.Error($"Can not set {name} warning value, not defined item");
                    return -1;
                }

                int preValue = _items[name].WarningValue;
                _items[name].WarningValue = value;

                string sql = string.Format(
                    "UPDATE \"stats_data\" SET \"warning_value\"='{0}'WHERE \"name\"='{1}';", _items[name].WarningValue,
                    name);
                DB.Insert(sql);

                EV.PostInfoLog("System", $"{name} stats warning value changed from {preValue} to {value}");

                return preValue;
            }
        }

        private void EnableAlarm(string name, bool enable)
        {
            lock (_locker)
            {
                if (!_items.ContainsKey(name))
                {
                    //LOG.Error($"Can not set {name} alarm enable, not defined item");
                    return;
                }

                bool preValue = _items[name].AlarmEnable;
                _items[name].AlarmEnable = enable;

                string sql = string.Format(
                    "UPDATE \"stats_data\" SET \"enable_alarm\"='{0}'WHERE \"name\"='{1}';", _items[name].AlarmEnable,
                    name);
                DB.Insert(sql);

                EV.PostInfoLog("System", $"{name} stats alarm enable changed from {preValue} to {enable}");

                return;
            }
        }

        private void RFEnableAlarm(string name, bool enable)
        {
            lock (_locker)
            {
                if (!_itemsRFAndPump.ContainsKey(name))
                {
                    //LOG.Error($"Can not set {name} alarm enable, not defined item");
                    return;
                }

                bool preValue = _itemsRFAndPump[name].AlarmEnable;
                _itemsRFAndPump[name].AlarmEnable = enable;

                string sql = string.Format(
                    "UPDATE \"stats_data_rf_pump\" SET \"enable_alarm\"='{0}'WHERE \"name\"='{1}';", _itemsRFAndPump[name].AlarmEnable,
                    name);
                DB.Insert(sql);

                EV.PostInfoLog("System", $"{name} stats data rf and pump alarm enable changed from {preValue} to {enable}");

                return;
            }
        }

        private void Alarm(string name)
        {
            lock (_locker)
            {
                if (!_items.ContainsKey(name))
                {
                    //LOG.Error($"Can not set {name} alarm enable, not defined item");
                    return;
                }
                
                EV.PostAlarmLog("System", $"{name} stats wafer value larger than wafer setting alarm value");

                return;
            }
        }
        
        private void EnableWarning(string name, bool enable)
        {
            lock (_locker)
            {
                if (!_items.ContainsKey(name))
                {
                    //LOG.Error($"Can not set {name} warning enable, not defined item");
                    return;
                }

                bool preValue = _items[name].WarningEnable;
                _items[name].WarningEnable = enable;

                string sql = string.Format(
                    "UPDATE \"stats_data\" SET \"enable_warning\"='{0}'WHERE \"name\"='{1}';", _items[name].WarningEnable,
                    name);
                DB.Insert(sql);

                EV.PostInfoLog("System", $"{name} stats warning enable changed from {preValue} to {enable}");

                return;
            }
        }

        private void Warning(string name)
        {
            lock (_locker)
            {
                if (!_items.ContainsKey(name))
                {
                    //LOG.Error($"Can not set {name} warning enable, not defined item");
                    return;
                }

                EV.PostWarningLog("System", $"{name} stats wafer value larger than wafer setting warning value");

                return;
            }
        }

        public void EnableVisible(string name, bool visible)
        {
            lock (_locker)
            {
                if (!_items.ContainsKey(name))
                {
                    //LOG.Error($"Can not set {name} alarm enable, not defined item");
                    return;
                }

                bool preValue = _items[name].IsVisible;
                _items[name].IsVisible = visible;

                string sql = string.Format(
                    "UPDATE \"stats_data\" SET \"is_visible\"='{0}'WHERE \"name\"='{1}';", _items[name].IsVisible,
                    name);
                DB.Insert(sql);

                EV.PostInfoLog("System", $"{name} stats visible changed from {preValue} to {visible}");

                return;
            }
        }

        public void Terminate()
        {
 
        }

        public void Subscribe(string name, string description, int initialValue, int warningValue = 0, bool warningEnable = false, int alarmValue = 0, bool alarmEnable = false, bool isVisible=true)
        {
            lock (_locker)
            {
                if (!_items.ContainsKey(name))
                {
                    _items[name] = new StatsDataItem()
                        {Description = description, Value = initialValue, Name = name, Total = 0};
                    string executeInsert = string.Format(
                        @"Insert into ""stats_data""(""name"",
                                                    ""value"",
                                                    ""total"",
                                                    ""description"",
                                                    ""last_update_time"",
                                                    ""last_reset_time"",
                                                    ""last_total_reset_time"",
                                                    ""is_visible"",
                                                    ""enable_warning"",
                                                    ""warning_value"",
                                                    ""enable_alarm"",
                                                    ""alarm_value""
                                                    ) values('{0}','{1}','{2}','{3}','{4}','{5}','{6}','{7}','{8}','{9}','{10}','{11}')",
                        name, initialValue, initialValue, description, DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")
                        , DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff"), DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff"), isVisible, warningEnable, warningValue, alarmEnable, alarmValue);
                    DB.Insert(executeInsert);
                }
            }
        }

        public void Subscribe(string name, string description, double fromLastPM = 0, double Total = 0, double PMInterval = 0, bool alarmEnable = false)
        {
            lock (_locker)
            {
                if (!_itemsRFAndPump.ContainsKey(name))
                {
                    _itemsRFAndPump[name] = new StatsDataItemRFAndPump()
                    { Description = description, Name = name, fromLastPM = 0, Total = 0, PMInterval = 0, AlarmEnable = false };
                    string executeInsert = string.Format(
                        @"Insert into ""stats_data_rf_pump""(""name"",
                                                    ""description"",
                                                    ""last_pm_time"",
                                                    ""from_last_pm"",
                                                    ""total"",
                                                    ""pm_interval"",
                                                    ""enable_alarm""
                                                    ) values('{0}','{1}','{2}','{3}','{4}','{5}','{6}')",
                        name, description, DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff"), fromLastPM, Total, PMInterval, alarmEnable);
                    DB.Insert(executeInsert);
                }
            }
        }

        public void SetValue(string name, int value)
        {
            lock (_locker)
            {
                if (!_items.ContainsKey(name))
                {
                    //LOG.Error($"Can not set {name} value, not defined item");
                    return;
                }

                _items[name].Value = value;
                _items[name].LastUpdateTime = DateTime.Now;

                string sql = string.Format(
                    "UPDATE \"stats_data\" SET \"last_update_time\"='{0}',\"value\"='{1}' WHERE \"name\"='{2}';",
                    _items[name].LastUpdateTime.ToString("yyyy/MM/dd HH:mm:ss.fff"),
                    value,
                    name);
                DB.Insert(sql);
            }
        }

        public int GetValue(string name)
        {
            lock (_locker)
            {
                if (_items.ContainsKey(name))
                {
                    return _items[name].Value;
                }
            }

            //LOG.Error($"Can not get {name} value, not defined item");

            return 0;
        }

        public StatsDataItem GetItem(string name)
        {
            lock (_locker)
            {
                if (_items.ContainsKey(name))
                {
                    return _items[name];
                }
            }

            //LOG.Error($"Can not get {name} value, not defined item");

            return null;
        }

        public StatsDataItemRFAndPump GetItemRFAndPump(string name)
        {
            lock (_locker)
            {
                if (_itemsRFAndPump.ContainsKey(name))
                {
                    return _itemsRFAndPump[name];
                }
            }

            //LOG.Error($"Can not get {name} value, not defined item");

            return null;
        }

        public int Increase(string name, int additionValue=1)
        {
            lock (_locker)
            {
                if (!_items.ContainsKey(name))
                {
                    //LOG.Error($"Can not increase {name} value, not defined item");
                    return -1;
                }

                _items[name].Value += additionValue; 
                _items[name].Total += additionValue;
                _items[name].LastUpdateTime = DateTime.Now;

                string sql = string.Format(
                    "UPDATE \"stats_data\" SET \"last_update_time\"='{0}',\"value\"='{1}',\"total\"='{2}' WHERE \"name\"='{3}';",
                    _items[name].LastUpdateTime.ToString("yyyy/MM/dd HH:mm:ss.fff"),
                    _items[name].Value,
                    _items[name].Total,
                    name);
                DB.Insert(sql);

                return _items[name].Value;
            }
        }

        public int Increase(string name, string description, double fromLastPM = 0, double Total = 0, double PMInterval = 0, bool alarmEnable = false)
        {
            lock (_locker)
            {
                if (!_itemsRFAndPump.ContainsKey(name))
                {
                    //LOG.Error($"Can not increase {name} value, not defined item");
                    return -1;
                }
                
                _itemsRFAndPump[name].fromLastPM = fromLastPM;
                _itemsRFAndPump[name].Total = Total;

                string sql = string.Format(
                    "UPDATE \"stats_data_rf_pump\" SET \"from_last_pm\"='{0}',\"total\"='{1}' WHERE \"name\"='{2}';",
                    _itemsRFAndPump[name].fromLastPM, _itemsRFAndPump[name].Total, name);
                DB.Insert(sql);

                return 0;
            }
        }

        public int Reset(string name)
        {
            lock (_locker)
            {
                if (!_items.ContainsKey(name))
                {
                    //LOG.Error($"Can not reset {name} value, not defined item");
                    return -1;
                }

                int preValue = _items[name].Value;
                _items[name].Value = 0;
                _items[name].LastUpdateTime = DateTime.Now;
                _items[name].LastResetTime = DateTime.Now;

                string sql = string.Format(
                    "UPDATE \"stats_data\" SET \"last_update_time\"='{0}',\"last_reset_time\"='{1}',\"value\"='{2}' WHERE \"name\"='{3}';",
                    _items[name].LastUpdateTime.ToString("yyyy/MM/dd HH:mm:ss.fff"),
                    _items[name].LastResetTime.ToString("yyyy/MM/dd HH:mm:ss.fff"),
                    _items[name].Value,
                    name);
                DB.Insert(sql);

                EV.PostInfoLog("System", $"{name} stats value reset to 0");

                return preValue;
            }

            
        }

        public int RFReset(string name)
        {
            lock (_locker)
            {
                if (!_itemsRFAndPump.ContainsKey(name))
                {
                    //LOG.Error($"Can not reset {name} value, not defined item");
                    return -1;
                }
                
                _itemsRFAndPump[name].fromLastPM = 0;
                _itemsRFAndPump[name].LastPMTime = DateTime.Now;

                string sql = string.Format(
                    "UPDATE \"stats_data_rf_pump\" SET \"last_pm_time\"='{0}',\"from_last_pm\"='{1}' WHERE \"name\"='{2}';",
                    _itemsRFAndPump[name].LastPMTime.ToString("yyyy/MM/dd HH:mm:ss.fff"),
                    _itemsRFAndPump[name].fromLastPM,
                    name);
                DB.Insert(sql);

                EV.PostInfoLog("System", $"{name} stats rf pump value reset to 0");

                return 0;
            }


        }

        public void ResetTotal(string name)
        {
            lock (_locker)
            {
                if (!_items.ContainsKey(name))
                {
                    //LOG.Error($"Can not reset {name} value, not defined item");
                    return;
                }

                //_items[name].Value = 0;
                _items[name].Total = 0;

                //_items[name].LastResetTime = DateTime.Now;
                _items[name].LastUpdateTime = DateTime.Now;
                _items[name].LastResetTotalTime = DateTime.Now;

                string sql = string.Format(
                    "UPDATE \"stats_data\" SET \"last_update_time\"='{0}',\"last_total_reset_time\"='{1}',\"total\"='{2}' WHERE \"name\"='{3}';",
                    _items[name].LastUpdateTime.ToString("yyyy/MM/dd HH:mm:ss.fff"),
                    //_items[name].LastResetTime.ToString("yyyy/MM/dd HH:mm:ss.fff"),
                    _items[name].LastResetTotalTime.ToString("yyyy/MM/dd HH:mm:ss.fff"),
                    //_items[name].Value,
                    _items[name].Total,
                    name);

                EV.PostInfoLog("System", $"{name} stats total value reset to 0");

                DB.Insert(sql);
            }
        }
    }
}