Kepler-Release/Venus/Venus_MainPages/ViewModels/KeplerStatisticsViewModel.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;
using WPF.Themes.UserControls;
using System.Windows;

namespace Venus_MainPages.ViewModels
{

    public class KeplerStatisticsViewModel : 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;
        private string m_ModuleName;
        private StatsDataListItemRFAndPump m_StatDataRFAndPumpSelectedValue;

        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 string ModuleName
        {
            get { return m_ModuleName; }
            set
            {
                SetProperty(ref m_ModuleName, value);
            }
        }
        public StatsDataListItemRFAndPump StatDataRFAndPumpSelectedValue
        {
            get { return m_StatDataRFAndPumpSelectedValue; }
            set
            {
                SetProperty(ref m_StatDataRFAndPumpSelectedValue, value);
            }
        }
        
        public KeplerStatisticsViewModel()
        {

            StatData = new ObservableCollection<StatsDataListItem>();
            StatDataRFAndPump = new ObservableCollection<StatsDataListItemRFAndPump>();
            timer = new DispatcherTimer();
            timer.Interval = TimeSpan.FromSeconds(1);
            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
            {

            }
        }
        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 DelegateCommand _DeleteItemCommand;
        public DelegateCommand DeleteItemCommand => _DeleteItemCommand ?? (_DeleteItemCommand = new DelegateCommand(OnDeleteItem));

        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();
                        if (item.Name.Contains(ModuleName))
                        {
                            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();
                        if (item.Name.Contains(ModuleName))
                        { 
                            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 OnDeleteItem()
        {
            if (StatDataRFAndPumpSelectedValue == null)
            {
                return;
            }
            if (FollowRFList.Contains(StatDataRFAndPumpSelectedValue.Name))
            {
                WPFMessageBox.ShowError($"默认{StatDataRFAndPumpSelectedValue.Name} 无法删除");
                return;
            }
            //string sqlrfpump = $"DELETE * FROM \"stats_data_rf_pump\" WHERE \"name\"={StatDataRFAndPumpSelectedValue.Name};";
            if (WPFMessageBox.ShowQuestion($"Do you want to delete  {StatDataRFAndPumpSelectedValue.Name}?", "删除后无法恢复!!!") == MessageBoxResult.Yes)
            {
                QueryDataClient.Instance.Service.DeleteCounterItem(StatDataRFAndPumpSelectedValue.Name);
                _StatDataRFAndPump.Clear();
            }
                
        }
        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 Init()
        {
            //string[] allModules = QueryDataClient.Instance.Service.GetConfig($"System.InstalledModules").ToString().Split(',');
            AddItemName = "";
            FollowRFList.Add($"{ModuleName}.RfOnTime");
            FollowRFList.Add($"{ModuleName}.PumpOnTime");
            ModuleList.Add(ModuleName);

            if (ModuleList.Count > 0)
            {
                AddItemModule = ModuleList[0];
                AddItemFollowRF = FollowRFList[0];
            }
        }

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