Kepler-Release/Venus/Venus_MainPages/ViewModels/StatisticsViewModel.cs

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Data;
using System.Linq;
using Aitex.Core.RT.Log;
using Prism.Commands;
using Prism.Mvvm;
using MECF.Framework.Common.DataCenter;
using MECF.Framework.Common.OperationCenter;
using OpenSEMI.ClientBase;
using System.Windows.Threading;


namespace Venus_MainPages.ViewModels
{

    public class StatsDataListItem : BindableBase
    {
        public string Name { get; set; }
        public string Value { get; set; }
        public string Description { get; set; }
        public string Total { get; set; }
        public string LastUpdateTime { get; set; }
        public string LastResetTime { get; set; }
        public string LastResetTotalTime { get; set; }
        public string WarningValue { get; set; }
        public string WarningValueSetPoint { get; set; }
        public bool WarningEnable { get; set; }
        public string AlarmValue { get; set; }
        public string AlarmValueSetPoint { get; set; }
        public bool AlarmEnable { get; set; }

        public bool AlarmTextSaved { get; set; }
        public bool WarningTextSaved { get; set; }
        public bool IsVisible { get; set; }
    }

    public class StatsDataListItemRFAndPump : BindableBase
    {
        private string _Name;
        private string _Description;
        private string _LastPMTime;
        private string _fromLastPM;
        private string _Total;
        private string _PMInterval;
        private string _PMIntervalSetPoint;
        private bool _AlarmEnable;
        private bool _PMIntervalTextSaved;
        public string Name { get { return _Name; } set { SetProperty(ref _Name, value); } }
        public string Description { get { return _Description; } set { SetProperty(ref _Description, value); } }
        public string LastPMTime { get { return _LastPMTime; } set { SetProperty(ref _LastPMTime, value); } }
        public string fromLastPM { get { return _fromLastPM; } set { SetProperty(ref _fromLastPM, value); } }
        public string Total { get { return _Total; } set { SetProperty(ref _Total, value); } }
        public string PMInterval { get { return _PMInterval; } set { SetProperty(ref _PMInterval, value); } }
        public string PMIntervalSetPoint { get { return _PMIntervalSetPoint; } set { SetProperty(ref _PMIntervalSetPoint, value); } }
        public bool AlarmEnable { get { return _AlarmEnable; } set { SetProperty(ref _AlarmEnable, value); } }

        public bool PMIntervalTextSaved { get { return _PMIntervalTextSaved; } set { SetProperty(ref _PMIntervalTextSaved, value); } }
    }

    public class StatisticsViewModel : BindableBase
    {
        private string _AddItemName;
        private string _AddItemModule;
        private string _AddItemFollowRF;
        public ObservableCollection<StatsDataListItem> _StatData;
        public ObservableCollection<StatsDataListItemRFAndPump> _StatDataRFAndPump;
        public ObservableCollection<string> _ModuleList = new ObservableCollection<string>();
        public ObservableCollection<string> _FollowRFList = new ObservableCollection<string>();
        DispatcherTimer timer;
        public ObservableCollection<string> ModuleList
        {
            get { return _ModuleList; }
            set { SetProperty(ref _ModuleList, value); }
        }

        public ObservableCollection<string> FollowRFList
        {
            get { return _FollowRFList; }
            set { SetProperty(ref _FollowRFList, value); }
        }

        public string AddItemName
        {
            get { return _AddItemName; }
            set { SetProperty(ref _AddItemName, value); }
        }
        public string AddItemModule
        {
            get { return _AddItemModule; }
            set { SetProperty(ref _AddItemModule, value); }
        }
        public string AddItemFollowRF
        {
            get { return _AddItemFollowRF; }
            set { SetProperty(ref _AddItemFollowRF, value); }
        }
        public StatisticsViewModel()
        {

            StatData = new ObservableCollection<StatsDataListItem>();
            StatDataRFAndPump = new ObservableCollection<StatsDataListItemRFAndPump>();
            timer = new DispatcherTimer();
            timer.Interval = TimeSpan.FromSeconds(1);
            timer.Tick += timer_Tick;
            //timer.Start();

            string[] allModules = QueryDataClient.Instance.Service.GetConfig($"System.InstalledModules").ToString().Split(',');
            AddItemName = "";
            if (allModules.Contains("PMA"))
            {
                FollowRFList.Add("PMA.RfOnTime");
                FollowRFList.Add("PMA.BiasRfOnTime");
                ModuleList.Add("PMA");
            }
            if (allModules.Contains("PMB"))
            {
                FollowRFList.Add("PMB.RfOnTime");
                FollowRFList.Add("PMB.BiasRfOnTime");
                ModuleList.Add("PMB");
            }
            if (allModules.Contains("PMC"))
            {
                FollowRFList.Add("PMC.RfOnTime");
                FollowRFList.Add("PMC.BiasRfOnTime");
                ModuleList.Add("PMC");
            }
            if (allModules.Contains("PMD"))
            {
                FollowRFList.Add("PMD.RfOnTime");
                FollowRFList.Add("PMD.BiasRfOnTime");
                ModuleList.Add("PMD");
            }
            if (ModuleList.Count > 0)
            {
                AddItemModule = ModuleList[0];
                AddItemFollowRF = FollowRFList[0];
            }
            //_timer = new PeriodicJob(200, this.OnTimer, "Database cleaner", true);
            //_timer.Start();
        }
        void timer_Tick(object sender, EventArgs e)
        {
            //return;
            try
            {
                PollData();
            }
            catch
            {

            }
        }
        private DelegateCommand _ResetCommnad;
        public DelegateCommand ResetCommnad =>
            _ResetCommnad ?? (_ResetCommnad = new DelegateCommand(Resets));
        private DelegateCommand<StatsDataListItem> _ResetTotalCommnad;
        public DelegateCommand<StatsDataListItem> ResetTotalCommnad =>
            _ResetTotalCommnad ?? (_ResetTotalCommnad = new DelegateCommand<StatsDataListItem>(ResetTotalValue));
        private DelegateCommand<StatsDataListItemRFAndPump> _ResetRFTotalCommnad;
        public DelegateCommand<StatsDataListItemRFAndPump> ResetRFTotalCommnad =>
            _ResetRFTotalCommnad ?? (_ResetRFTotalCommnad = new DelegateCommand<StatsDataListItemRFAndPump>(ResetRFTotal));
        private DelegateCommand<StatsDataListItem> _ResetValueCommnad;
        public DelegateCommand<StatsDataListItem> ResetValueCommnad =>
            _ResetValueCommnad ?? (_ResetValueCommnad = new DelegateCommand<StatsDataListItem>(ResetValue));

        private DelegateCommand<StatsDataListItem> _ResetEnableValueCommnad;
        public DelegateCommand<StatsDataListItem> ResetEnableValueCommnad =>
            _ResetEnableValueCommnad ?? (_ResetEnableValueCommnad = new DelegateCommand<StatsDataListItem>(ResetEnableWarning));
        private DelegateCommand<StatsDataListItem> _SetWarningValueCommnad;
        public DelegateCommand<StatsDataListItem> SetWarningValueCommnad =>
            _SetWarningValueCommnad ?? (_SetWarningValueCommnad = new DelegateCommand<StatsDataListItem>(SetWarningValue));

        private DelegateCommand<StatsDataListItem> _ResetEnableAlarmCommnad;
        public DelegateCommand<StatsDataListItem> ResetEnableAlarmCommnad =>
    _ResetEnableAlarmCommnad ?? (_ResetEnableAlarmCommnad = new DelegateCommand<StatsDataListItem>(ResetEnableAlarm));
        private DelegateCommand<StatsDataListItem> _SetAlarmValueCommnad;
        public DelegateCommand<StatsDataListItem> SetAlarmValueCommnad =>
    _SetAlarmValueCommnad ?? (_SetAlarmValueCommnad = new DelegateCommand<StatsDataListItem>(SetAlarmValue));

        private DelegateCommand<StatsDataListItemRFAndPump> _ResetTimeValueCommnad;
        public DelegateCommand<StatsDataListItemRFAndPump> ResetTimeValueCommnad =>
    _ResetTimeValueCommnad ?? (_ResetTimeValueCommnad = new DelegateCommand<StatsDataListItemRFAndPump>(ResetTimeValue));


        private DelegateCommand<StatsDataListItemRFAndPump> _SetPMIntervalValueCommnad;
        public DelegateCommand<StatsDataListItemRFAndPump> SetPMIntervalValueCommnad =>
    _SetPMIntervalValueCommnad ?? (_SetPMIntervalValueCommnad = new DelegateCommand<StatsDataListItemRFAndPump>(SetPMIntervalValue));


        private DelegateCommand<StatsDataListItemRFAndPump> _ResetRFEnableAlarmCommnad;
        public DelegateCommand<StatsDataListItemRFAndPump> ResetRFEnableAlarmCommnad =>
    _ResetRFEnableAlarmCommnad ?? (_ResetRFEnableAlarmCommnad = new DelegateCommand<StatsDataListItemRFAndPump>(ResetRFEnableAlarm));

        private DelegateCommand _SubscribeItem;
        public DelegateCommand SubscribeItem => _SubscribeItem ?? (_SubscribeItem = new DelegateCommand(OnSubscribeItem));

        private int MenuPermission
        {
            //get
            //{
            //    return ClientApp.Instance.GetPermission("Statistics");
            //}
            get; set;
        }
        //protected bool OnTimer()
        //{
        //    try
        //    {
        //        PollData();
        //    }
        //    catch (Exception ex)
        //    {
        //        LOG.Error(ex.Message);
        //    }

        //    return true;
        //}
        public ObservableCollection<StatsDataListItem> StatData
        {
            get { return _StatData; }
            set { SetProperty(ref _StatData, value); }
        }

        public ObservableCollection<StatsDataListItemRFAndPump> StatDataRFAndPump
        {
            get { return _StatDataRFAndPump; }
            set { SetProperty(ref _StatDataRFAndPump, value); }
        }


        public void PollData()
        {

            try
            {

                string sql = $"SELECT * FROM \"stats_data\" order by \"name\" ASC;";

                DataTable dbData = QueryDataClient.Instance.Service.QueryData(sql);


                if (dbData == null || dbData.Rows.Count == 0)
                    return;

                // string[] clearedNameList = Array.ConvertAll<StatsDataListItem, string>(StatData.ToArray(), x => x.Name);

                List<string> removableList = new List<string>();

                //if (clearedNameList.Length > 0)
                //    removableList = clearedNameList.ToList();

                for (int i = 0; i < dbData.Rows.Count; i++)
                {
                    if (!dbData.Rows[i]["is_visible"].Equals(DBNull.Value) && !Convert.ToBoolean(dbData.Rows[i]["is_visible"].ToString()))
                        continue;

                    string name = dbData.Rows[i]["name"].ToString();
                    //removableList.RemoveIfContains(name);

                    StatsDataListItem item = StatData.FirstOrDefault(x => x.Name == name);
                    if (item == null)
                    {
                        item = new StatsDataListItem();
                        item.Name = dbData.Rows[i]["name"].ToString();
                        item.AlarmEnable = false;
                        item.WarningEnable = false;
                        item.IsVisible = true;
                        item.AlarmTextSaved = true;
                        item.WarningTextSaved = true;
                        item.AlarmValueSetPoint = dbData.Rows[i]["alarm_value"].ToString();
                        item.WarningValueSetPoint = dbData.Rows[i]["warning_value"].ToString();
                        StatData.Add(item);
                    }

                    item.Description = dbData.Rows[i]["description"].ToString();
                    item.Value = dbData.Rows[i]["value"].ToString();
                    item.Total = dbData.Rows[i]["total"].ToString();

                    if (!dbData.Rows[i]["enable_warning"].Equals(DBNull.Value))
                        item.WarningEnable = Convert.ToBoolean(dbData.Rows[i]["enable_warning"].ToString());

                    item.WarningValue = dbData.Rows[i]["warning_value"].ToString();

                    if (!dbData.Rows[i]["enable_alarm"].Equals(DBNull.Value))
                        item.AlarmEnable = Convert.ToBoolean(dbData.Rows[i]["enable_alarm"].ToString());

                    item.AlarmValue = dbData.Rows[i]["alarm_value"].ToString();

                    if (!dbData.Rows[i]["last_update_time"].Equals(DBNull.Value))
                        item.LastUpdateTime = ((DateTime)dbData.Rows[i]["last_update_time"]).ToString("yyyy-MM-dd HH:mm:ss.fff");

                    if (!dbData.Rows[i]["last_reset_time"].Equals(DBNull.Value))
                        item.LastResetTime = ((DateTime)dbData.Rows[i]["last_reset_time"]).ToString("yyyy-MM-dd HH:mm:ss.fff");

                    if (!dbData.Rows[i]["last_total_reset_time"].Equals(DBNull.Value))
                        item.LastResetTotalTime = ((DateTime)dbData.Rows[i]["last_total_reset_time"]).ToString("yyyy-MM-dd HH:mm:ss.fff");

                }




                string sqlrfpump = $"SELECT * FROM \"stats_data_rf_pump\" order by \"name\" ASC;";

                DataTable dbDataRFPump = QueryDataClient.Instance.Service.QueryData(sqlrfpump);

                if (dbDataRFPump == null || dbDataRFPump.Rows.Count == 0)
                    return;

                for (int i = 0; i < dbDataRFPump.Rows.Count; i++)
                {

                    string name = dbDataRFPump.Rows[i]["name"].ToString();
                    //removableList.RemoveIfContains(name);

                    StatsDataListItemRFAndPump item = StatDataRFAndPump.FirstOrDefault(x => x.Name == name);
                    if (item == null)
                    {
                        item = new StatsDataListItemRFAndPump();
                        item.Name = dbDataRFPump.Rows[i]["name"].ToString();
                        item.AlarmEnable = false;
                        item.PMIntervalTextSaved = true;
                        //item.PMIntervalSetPoint = dbDataRFPump.Rows[i]["pm_interval"].ToString();
                        StatDataRFAndPump.Add(item);
                    }

                    item.Description = dbDataRFPump.Rows[i]["description"].ToString();

                    if (!dbDataRFPump.Rows[i]["enable_alarm"].Equals(DBNull.Value))
                        item.AlarmEnable = Convert.ToBoolean(dbDataRFPump.Rows[i]["enable_alarm"].ToString());

                    item.fromLastPM = dbDataRFPump.Rows[i]["from_last_pm"].ToString();
                    item.PMInterval = dbDataRFPump.Rows[i]["pm_interval"].ToString();
                    item.Total = dbDataRFPump.Rows[i]["total"].ToString();

                    if (!dbDataRFPump.Rows[i]["last_pm_time"].Equals(DBNull.Value))
                        item.LastPMTime = ((DateTime)dbDataRFPump.Rows[i]["last_pm_time"]).ToString("yyyy-MM-dd HH:mm:ss.fff");

                }


            }
            catch
            {
            }
        }

        public void OnSubscribeItem()
        {
            if (!string.IsNullOrWhiteSpace(AddItemName))
                InvokeClient.Instance.Service.DoOperation($"{AddItemModule}.SubscribeStatsData", $"{AddItemModule}.{AddItemName}", $"Follow => {AddItemFollowRF}");
        }

        public void ResetValue(StatsDataListItem item)
        {
            InvokeClient.Instance.Service.DoOperation("System.Stats.ResetValue", item.Name);
        }
        public void Resets()
        {
            //InvokeClient.Instance.Service.DoOperation("System.Stats.ResetValue", item.Name);
        }
        public void ResetEnableAlarm(StatsDataListItem item)
        {
            InvokeClient.Instance.Service.DoOperation("System.Stats.EnableAlarm", item.Name, item.AlarmEnable);
        }

        public void ResetEnableWarning(StatsDataListItem item)
        {
            InvokeClient.Instance.Service.DoOperation("System.Stats.EnableWarning", item.Name, item.WarningEnable);
        }

        public void SetAlarmValue(StatsDataListItem item)
        {
            if (string.IsNullOrEmpty(item.AlarmValueSetPoint) ||
                !int.TryParse(item.AlarmValueSetPoint, out int setValue))
            {
                DialogBox.ShowWarning("Alarm value not valid");
                return;
            }

            InvokeClient.Instance.Service.DoOperation("System.Stats.SetAlarmValue", item.Name, setValue);

            item.AlarmTextSaved = true;
        }

        public void SetWarningValue(StatsDataListItem item)
        {
            if (string.IsNullOrEmpty(item.WarningValueSetPoint) ||
                !int.TryParse(item.WarningValueSetPoint, out int setValue))
            {
                DialogBox.ShowWarning("Warning value not valid");
                return;
            }

            InvokeClient.Instance.Service.DoOperation("System.Stats.SetWarningValue", item.Name, setValue,item.WarningEnable);

            item.WarningTextSaved = true;
        }
        public void ResetTotalValue(StatsDataListItem item)
        {
            InvokeClient.Instance.Service.DoOperation($"System.Stats.ResetTotalValue", item.Name);
        }
        public void ResetRFTotal(StatsDataListItemRFAndPump item)
        {

            //foreach (var rfpumpitem in StatDataRFAndPump.ToList().FindAll(x => x.Description == "Follow => " + item.Name))
            //{
            //    InvokeClient.Instance.Service.DoOperation("System.Stats.IncreaseValue",
            //        rfpumpitem.Name, rfpumpitem.Description, item.fromLastPM, item.Total);
            //}

            InvokeClient.Instance.Service.DoOperation("System.Stats.RFResetTotal", item.Name);
            if (item.Name.Contains(".BiasRfOnTime"))
            {
                //InvokeClient.Instance.Service.DoOperation($"{item.Name.Split('.')[0]}.BiasRf.ResetRFStats", item.Name);
                //ResetPumpStats
            }

            if (item.Name.Contains(".RfOnTime"))
            {
                //InvokeClient.Instance.Service.DoOperation($"{item.Name.Split('.')[0]}.Rf.ResetRFStats", item.Name);
            }

            if (item.Name.Contains(".PumpOnTime"))
            {
                //InvokeClient.Instance.Service.DoOperation($"{item.Name.Split('.')[0]}.MainPump.ResetPumpStats", item.Name);
            }
        }

        public void ResetTimeValue(StatsDataListItemRFAndPump item)
        {
            //foreach (var rfpumpitem in StatDataRFAndPump.ToList().FindAll(x => x.Description == "Follow => " + item.Name))
            //{
            //    InvokeClient.Instance.Service.DoOperation("System.Stats.IncreaseValue",
            //        rfpumpitem.Name, rfpumpitem.Description, rfpumpitem.fromLastPM, rfpumpitem.Total);
            //}
            InvokeClient.Instance.Service.DoOperation("System.StatsRFAndPump.ResetValue", item.Name);
            if (item.Name.Contains(".BiasRfOnTime"))
            {
                //InvokeClient.Instance.Service.DoOperation($"{item.Name.Split('.')[0]}.BiasRf.ResetRFStats", item.Name);
                //ResetPumpStats
            }

            if (item.Name.Contains(".RfOnTime"))
            {
                //InvokeClient.Instance.Service.DoOperation($"{item.Name.Split('.')[0]}.Rf.ResetRFStats", item.Name);
            }

            if (item.Name.Contains(".PumpOnTime"))
            {
                //InvokeClient.Instance.Service.DoOperation($"{item.Name.Split('.')[0]}.MainPump.ResetPumpStats", item.Name);
            }

            //InvokeClient.Instance.Service.DoOperation("System.StatsRFAndPump.ResetValue", item.Name);
        }

        public void ResetRFEnableAlarm(StatsDataListItemRFAndPump item)
        {
            InvokeClient.Instance.Service.DoOperation("System.StatsRFAndPump.EnableAlarm", item.Name, item.AlarmEnable);
        }

        public void SetPMIntervalValue(StatsDataListItemRFAndPump item)
        {

            if (string.IsNullOrEmpty(item.PMIntervalSetPoint) ||
                !int.TryParse(item.PMIntervalSetPoint, out int setValue))
            {
                DialogBox.ShowWarning("PM Interval value not valid");
                return;
            }

            if (item.Name.Contains(".PumpOnTime"))
            {
                InvokeClient.Instance.Service.DoOperation("System.StatsRFAndPump.SetPMIntervalValue", item.Name, setValue);
                //InvokeClient.Instance.Service.DoOperation($"{item.Name.Split('.')[0]}.MainPump.ResetPumpStats", item.Name);
            }

            if (item.Name.Contains(".BiasRfOnTime"))
            {
                InvokeClient.Instance.Service.DoOperation("System.StatsRFAndPump.SetPMIntervalValue", item.Name, setValue);
                //InvokeClient.Instance.Service.DoOperation($"{item.Name.Split('.')[0]}.BiasRf.ResetRFStats", item.Name);
                //ResetPumpStats
            }

            if (item.Name.Contains(".RfOnTime"))
            {
                InvokeClient.Instance.Service.DoOperation("System.StatsRFAndPump.SetPMIntervalValue", item.Name, setValue);
                //InvokeClient.Instance.Service.DoOperation($"{item.Name.Split('.')[0]}.Rf.ResetRFStats", item.Name);
            }

            item.PMIntervalTextSaved = true;
        }

        public void EnterExitView(bool isEnter)
        {
            if (isEnter)
            {
                timer_Tick(null, null);
                timer.Start();
            }
            else
            {
                timer.Stop();
                _StatData.Clear();
                _StatDataRFAndPump.Clear();
            }
        }
    }
}