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 System.Windows;
using System.Windows.Data;
using Aitex.Core.RT.Log;
using Aitex.Core.Util;
using Prism.Commands;
using Prism.Mvvm;
using MECF.Framework.Common.CommonData;
using MECF.Framework.Common.DataCenter;
using MECF.Framework.Common.OperationCenter;
using OpenSEMI.ClientBase;
using Venus_Core;
using System.Windows.Threading;
//using SciChart.Core.Extensions;
//using VirgoUI.Client.Models.Sys;

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 
    {
        public string Name { get; set; }
        public string Description { get; set; }
        public string LastPMTime { get; set; }
        public string fromLastPM { get; set; }
        public string Total { get; set; }
        public string PMInterval { get; set; }
        public string PMIntervalSetPoint { get; set; }
        public bool AlarmEnable { get; set; }

        public bool PMIntervalTextSaved { get; set; }
    }

    public class StatisticsViewModel : BindableBase
    {
        public ObservableCollection<StatsDataListItem> _StatData;
        public ObservableCollection<StatsDataListItemRFAndPump> _StatDataRFAndPump;
        public StatisticsViewModel()
        {
            
            StatData = new ObservableCollection<StatsDataListItem>();
            StatDataRFAndPump = new ObservableCollection<StatsDataListItemRFAndPump>();
            DispatcherTimer timer = new DispatcherTimer();
            timer.Interval = TimeSpan.FromSeconds(6);
            timer.Tick += timer_Tick;
            timer.Start();
            
            //_timer = new PeriodicJob(200, this.OnTimer, "Database cleaner", true);
            //_timer.Start();
         }
        void timer_Tick(object sender, EventArgs e)
        {
            return;
            try
            {
                PollData();
            }
            catch (Exception ex) { }
        }
        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<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 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); }
        }
        private PeriodicJob _timer;
        //protected override void OnInitialize()
        //{
        //    StatData = new ObservableCollection<StatsDataListItem>();
        //    StatDataRFAndPump = new ObservableCollection<StatsDataListItemRFAndPump>();

        //    base.OnInitialize();
        //}

        //protected override void OnActivate()
        //{
        //    base.OnActivate();

        //}

        //protected override void OnDeactivate(bool close)
        //{
        //    base.OnDeactivate(close);
        //}

        public void PollData()
        {
           
            try
            {

                Application.Current.Dispatcher.BeginInvoke(new Action(() =>
                {
                    StatData.Clear();
                    StatDataRFAndPump.Clear();
                }));
                string sql = $"SELECT * FROM \"stats_data\" order by \"name\" ASC;";

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

                Application.Current.Dispatcher.BeginInvoke(new Action(() =>
                {
                    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");

                        //item.InvokePropertyChanged(nameof(item.AlarmValue));
                        //item.InvokePropertyChanged(nameof(item.WarningValue));
                        //item.InvokePropertyChanged(nameof(item.Value));
                        //item.InvokePropertyChanged(nameof(item.Total));
                        //item.InvokePropertyChanged(nameof(item.LastUpdateTime));
                        //item.InvokePropertyChanged(nameof(item.LastResetTime));
                        //item.InvokePropertyChanged(nameof(item.LastResetTotalTime));
                    }

                    //foreach (var name in removableList)
                    //{
                    //    StatsDataListItem item = StatData.FirstOrDefault(x => x.Name == name);
                    //    if (item != null)
                    //        StatData.Remove(item); 
                    //}

                }));

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

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

                Application.Current.Dispatcher.BeginInvoke(new Action(() =>
                {
                    if (dbDataRFPump == null || dbDataRFPump.Rows.Count == 0)
                        return;
                    //string[] clearedNameList = Array.ConvertAll<StatsDataListItemRFAndPump, string>(StatDataRFAndPump.ToArray(), x => x.Name);

                    //List<string> removableList = new List<string>();
                    //if (clearedNameList.Length > 0)
                    //    removableList = clearedNameList.ToList();

                    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");

                        //item.InvokePropertyChanged(nameof(item.Name));
                        //item.InvokePropertyChanged(nameof(item.AlarmEnable));
                        //item.InvokePropertyChanged(nameof(item.Description));
                        //item.InvokePropertyChanged(nameof(item.Total));
                        //item.InvokePropertyChanged(nameof(item.fromLastPM));
                        //item.InvokePropertyChanged(nameof(item.PMInterval));
                        //item.InvokePropertyChanged(nameof(item.LastPMTime));
                    }

                    //foreach (var name in removableList)
                    //{
                    //    StatsDataListItemRFAndPump item = StatDataRFAndPump.FirstOrDefault(x => x.Name == name);
                    //    if (item != null)
                    //        StatDataRFAndPump.Remove(item);
                    //}

                }));
            }
            catch (Exception e)
            {
            }
        }

        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;
            //item.InvokePropertyChanged(nameof(item.AlarmTextSaved));
        }

        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.WarningTextSaved = true;
            //item.InvokePropertyChanged(nameof(item.WarningTextSaved));
        }
        
        public void ResetTotalValue(StatsDataListItem item)
        {
            //InvokeClient.Instance.Service.DoOperation("System.Stats.ResetTotalValue", item.Name);
        }

        public void ResetTimeValue(StatsDataListItemRFAndPump item)
        {
            //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;
            }

            //InvokeClient.Instance.Service.DoOperation("System.StatsRFAndPump.SetPMIntervalValue", item.Name, setValue);

            item.PMIntervalTextSaved = true;
            //item.InvokePropertyChanged(nameof(item.PMIntervalTextSaved));
        }
    }
}