FurnaceELK/Furnace/FurnaceUI/Views/Scheduled/ScheduledMaitViewModel.cs

using Caliburn.Micro;
using Caliburn.Micro.Core;
using FurnaceUI.Models;
using FurnaceUI.Views.Scheduled;
using MECF.Framework.Common.CommonData;
using MECF.Framework.Common.DataCenter;
using MECF.Framework.Common.OperationCenter;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Data;
using System.Globalization;
using System.Linq;
using System.Windows.Controls;
using System.Windows.Data;

namespace FurnaceUI.Views.Editors
{
    /// <summary>
    /// 预定场景数据上下文
    /// </summary>
    public class ScheduledMaitViewModel : FurnaceUIViewModelBase
    {
        #region 构造函数
        /// <summary>
        /// 构造函数
        /// </summary>
        public ScheduledMaitViewModel()
        {
        }
        #endregion

        #region 属性 ScheduleMaintenanceDataItemList
        /// <summary>
        /// ScheduleMaintenanceDataItemList
        /// </summary>
        public ObservableCollection<ScheduleMaintenanceDataItem> ScheduleMaintenanceDataItemList
        {
            get { return _scheduleMaintenanceDataItemList; }
            set
            {
                _scheduleMaintenanceDataItemList = value;
            }
        }
        private ObservableCollection<ScheduleMaintenanceDataItem> _scheduleMaintenanceDataItemList = new ObservableCollection<ScheduleMaintenanceDataItem>();
        #endregion

        #region 属性 显示视图
        /// <summary>
        /// 显示视图
        /// </summary>
        public ListCollectionView ScheduleMaintenanceDataItemListSource
        {
            get { return _scheduleMaintenanceDataItemListSource; }
            set
            {
                _scheduleMaintenanceDataItemListSource = value;
                NotifyOfPropertyChange("ScheduleMaintenanceDataItemListSource");
            }
        }

        private ListCollectionView _scheduleMaintenanceDataItemListSource;
        #endregion

        #region 属性 是否保存
        /// <summary>
        /// 是否保存
        /// </summary>
        public bool IsSave { get; set; }
        #endregion

        #region 属性 选择数据类型
        /// <summary>
        /// 
        /// </summary>
        public DataItemEnum DataItemType
        {
            get { return _dataItemType; }
            set
            {
                _dataItemType = value;
                NotifyOfPropertyChange("DataItemType");
                if (ScheduleMaintenanceDataItemListSource != null)
                {
                    ScheduleMaintenanceDataItemListSource.Filter = Filter;
                }
            }
        }
        private DataItemEnum _dataItemType = DataItemEnum.CarrierWafer;
        #endregion

        #region 属性 选择DummyType
        /// <summary>
        /// 选择Dummy
        /// </summary>
        public DummyEnum DummyType
        {
            get { return _dummyType; }
            set
            {
                _dummyType = value;
                NotifyOfPropertyChange("DummyType");
                if (ScheduleMaintenanceDataItemListSource != null)
                {
                    ScheduleMaintenanceDataItemListSource.Filter = Filter;
                }
            }
        }
        private DummyEnum _dummyType = DummyEnum.SideDummy;
        #endregion

        #region 属性  选择ReactorsType
        /// <summary>
        /// 选择ReactorsType
        /// </summary>
        public ReactorsEnum ReactorsType
        {
            get { return _reactorsType; }
            set
            {
                _reactorsType = value;
                NotifyOfPropertyChange("ReactorsType");
                if (ScheduleMaintenanceDataItemListSource != null)
                {
                    ScheduleMaintenanceDataItemListSource.Filter = Filter;
                }
            }
        }
        private ReactorsEnum _reactorsType = ReactorsEnum.Recipe;
        #endregion

        #region 事件处理 选择项改变
        /// <summary>
        /// 选择项改变
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        public void SelectionChangedHandle(object obj, object selectedValue)
        {
            if (obj != null && selectedValue != null && obj is ScheduleMaintenanceDataItem node && selectedValue is ScheduleMaintenanceDataItem selectedItem)
            {
                if (obj == selectedItem)
                {
                    IWindowManager wm = IoC.Get<IWindowManager>();
                    ScheduledMaintenanceMonitorViewModel scheduledMaintenanceMonitorViewModel = new ScheduledMaintenanceMonitorViewModel(selectedItem);
                    var rtn = (wm as WindowManager)?.ShowDialogWithTitle(scheduledMaintenanceMonitorViewModel, null, "Maintenance Setting");
                    if (rtn == true)
                    {
                     
                        if (!string.IsNullOrEmpty(scheduledMaintenanceMonitorViewModel.EditModel.AdditionInformationDisplay) && selectedItem.AdditionInformationDisplay != scheduledMaintenanceMonitorViewModel.EditModel.AdditionInformationDisplay)
                        {
                            selectedItem.AdditionInformationDisplay = scheduledMaintenanceMonitorViewModel.EditModel.AdditionInformationDisplay;
                            InvokeClient.Instance.Service.DoOperation("System.ScheduleMaintenance.SetAdditionInformationDisplayName", selectedItem.Item, selectedItem.AdditionInformationDisplay);
                        }

                        if (selectedItem.CurrentValue != scheduledMaintenanceMonitorViewModel.EditModel.CurrentValue)
                        {
                            selectedItem.CurrentValue = scheduledMaintenanceMonitorViewModel.EditModel.CurrentValue;
                            InvokeClient.Instance.Service.DoOperation("System.ScheduleMaintenance.SetCurrentValue", selectedItem.Item, selectedItem.CurrentValue);
                        }

                        if (!string.IsNullOrEmpty(scheduledMaintenanceMonitorViewModel.EditModel.Display) && selectedItem.Display != scheduledMaintenanceMonitorViewModel.EditModel.Display)
                        {
                            selectedItem.Display = scheduledMaintenanceMonitorViewModel.EditModel.Display;
                            InvokeClient.Instance.Service.DoOperation("System.ScheduleMaintenance.SetMaintenanceName", selectedItem.Item, selectedItem.Display);
                        }

                        if (selectedItem.LimitValue != scheduledMaintenanceMonitorViewModel.EditModel.LimitValue)
                        {
                            selectedItem.LimitValue = scheduledMaintenanceMonitorViewModel.EditModel.LimitValue;
                            InvokeClient.Instance.Service.DoOperation("System.ScheduleMaintenance.SetLimitValue", selectedItem.Item, selectedItem.LimitValue);
                        }

                        if (!string.IsNullOrEmpty(scheduledMaintenanceMonitorViewModel.EditModel.MaintenanceProcessing) && selectedItem.MaintenanceProcessing != scheduledMaintenanceMonitorViewModel.EditModel.MaintenanceProcessing)
                        {
                            InvokeClient.Instance.Service.DoOperation("System.ScheduleMaintenance.SetMaintenanceProcessing", selectedItem.Item, selectedItem.LimitValue);
                        }
                     
                        if (selectedItem.StartValue != scheduledMaintenanceMonitorViewModel.EditModel.StartValue)
                        {
                            selectedItem.StartValue = scheduledMaintenanceMonitorViewModel.EditModel.StartValue;
                            InvokeClient.Instance.Service.DoOperation("System.ScheduleMaintenance.SetStartValue", selectedItem.Item, selectedItem.StartValue);
                        }
                    }
                }
            }
        }
        #endregion

        #region 重新方法 窗体加载完成
        /// <summary>
        /// 窗体加载完成
        /// </summary>
        /// <param name="view"></param>
        protected override void OnViewLoaded(object view)
        {
            base.OnViewLoaded(view);
            LoadData();
        }
        #endregion

        #region 私有方法 加载数据
        /// <summary>
        /// 加载数据
        /// </summary>
        private void LoadData()
        {
            string sql = $"select * from \"schedule_maintenance\"";

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

            List<ScheduleMaintenanceDataItem> tempList = new List<ScheduleMaintenanceDataItem>();
            for (int i = 0; i < dt.Rows.Count; i++)
            {
                ScheduleMaintenanceDataItem item = new ScheduleMaintenanceDataItem();
                item.Item = dt.Rows[i]["maintenance_item"].ToString();
                item.Display = dt.Rows[i]["maintenance_display"].ToString();
                item.Unit = dt.Rows[i]["unit"].ToString();
                item.MaintenanceProcessing = dt.Rows[i]["maintenance_processing"].ToString();
                item.Path = dt.Rows[i]["path"].ToString();
                item.AdditionInformationName = dt.Rows[i]["addition_information_name"].ToString();
                item.AdditionInformationDisplay = dt.Rows[i]["addition_information_display"].ToString();
                if (float.TryParse(dt.Rows[i]["current_value"].ToString(), out float value))
                    item.CurrentValue = value;
                if (float.TryParse(dt.Rows[i]["scheduling_start_value"].ToString(), out value))
                    item.StartValue = value;
                if (float.TryParse(dt.Rows[i]["maintenance_limit_value"].ToString(), out value))
                    item.LimitValue = value;

                //根据Path 分类
                if (!string.IsNullOrEmpty(item.Path))
                {
                    switch (item.Path)
                    {
                        case "CarrierWafer.SieDummy":
                            item.DataItemType = DataItemEnum.CarrierWafer;
                            item.DummyType = DummyEnum.SideDummy;
                            break;
                        case "CarrierWafer.FillDummy":
                            item.DataItemType = DataItemEnum.CarrierWafer;
                            item.DummyType = DummyEnum.FillDummy;
                            break;
                        case "Boat":
                            item.DataItemType = DataItemEnum.Boat;
                            break;
                        case "Conditioning":
                            item.DataItemType = DataItemEnum.Conditioning;
                            break;
                        case "Reactor.Recipe":
                            item.DataItemType = DataItemEnum.Reactor;
                            item.ReactorsType = ReactorsEnum.Recipe;
                            break;
                        case "Reactor.StepRunFreq":
                            item.DataItemType = DataItemEnum.Reactor;
                            item.ReactorsType = ReactorsEnum.StepRunFreq;
                            break;
                        case "Reactor.StepRunTime":
                            item.DataItemType = DataItemEnum.Reactor;
                            item.ReactorsType = ReactorsEnum.StepRunTime;
                            break;
                        case "Reactor.StepThickness":
                            item.DataItemType = DataItemEnum.Reactor;
                            item.ReactorsType = ReactorsEnum.StepThickness;
                            break;
                        default:
                            break;
                    }
                    tempList.Add(item);
                }
            }
            ScheduleMaintenanceDataItemList = new ObservableCollection<ScheduleMaintenanceDataItem>(tempList);
            var groups = ScheduleMaintenanceDataItemList.GroupBy(p => p.DataItemType);

            foreach (var item in groups)
            {
                switch (item.Key)
                {
                    case DataItemEnum.CarrierWafer:
                        var subGroup = item.GroupBy(p => p.DummyType);
                        foreach (var sunItemGroup in subGroup)
                        {
                            for (int i = 0; i < sunItemGroup.Count(); i++)
                            {
                                sunItemGroup.ElementAt(i).Number = i + 1;
                            }
                        }

                        break;
                    case DataItemEnum.Boat:
                        for (int i = 0; i < item.Count(); i++)
                        {
                            item.ElementAt(i).Number = i + 1;
                        }
                        break;
                    case DataItemEnum.Conditioning:
                        for (int i = 0; i < item.Count(); i++)
                        {
                            item.ElementAt(i).Number = i + 1;
                        }
                        break;
                    case DataItemEnum.Reactor:
                        var subReactorsTypeGroup = item.GroupBy(p => p.ReactorsType);
                        foreach (var sunItemGroup in subReactorsTypeGroup)
                        {
                            for (int i = 0; i < sunItemGroup.Count(); i++)
                            {
                                sunItemGroup.ElementAt(i).Number = i + 1;
                            }
                        }
                        break;
                    default:
                        break;
                }
            }

            ScheduleMaintenanceDataItemListSource = new ListCollectionView(tempList);
            ScheduleMaintenanceDataItemListSource.Filter = Filter;
            //ScheduledSC scheduledSC = new ScheduledSC();
            //scheduledSC.SetKeys();
            // var scValue = CONFIG.IsEnable ? CONFIG.PollConfig(SCBlock.GetKeys()) : QueryDataClient.Instance.Service.PollConfig(SCBlock.GetKeys());
            // scheduledSC.Update(scValue);
        }
        #endregion

        #region 私有方法 筛选数据
        /// <summary>
        /// 筛选数据
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        private bool Filter(object obj)
        {
            bool isFilter = false;//筛选不通过
            if (obj != null && obj is ScheduleMaintenanceDataItem model)
            {
                if (model.DataItemType == DataItemType)
                {
                    switch (DataItemType)
                    {
                        case DataItemEnum.CarrierWafer:
                            isFilter = model.DummyType == DummyType;
                            break;
                        case DataItemEnum.Boat:
                            isFilter = true;
                            break;
                        case DataItemEnum.Conditioning:
                            isFilter = true;
                            break;
                        case DataItemEnum.Reactor:
                            isFilter = model.ReactorsType == ReactorsType;
                            break;
                        default:
                            break;
                    }
                }
            }
            return isFilter;
        }
        #endregion

        #region 方法 保存
        /// <summary>
        /// 保存
        /// </summary>
        public void SetSave()
        {
            IsSave = true;
        }
        #endregion

        #region 方法 取消
        /// <summary>
        /// 取消
        /// </summary>
        public void SetCancel()
        {
            IsSave = false;
        }
        #endregion
    }


    public enum DummyEnum : byte
    {
        None = 0,
        SideDummy = 1,
        FillDummy = 2
    }

    public enum ReactorsEnum : byte
    {
        None = 0,
        Recipe = 1,
        StepRunFreq = 2,
        StepRunTime = 3,
        StepThickness = 4
    }

    public enum DataItemEnum
    {
        CarrierWafer,
        Boat,
        Conditioning,
        Reactor
    }

    public class ScheduleMaintenanceDataItem : NotifiableItem
    {
        public int Number { get; set; }
        public string Unit { get; set; }
        public string Item { get; set; }


        public float CurrentValue
        {
            get { return _currentValue; }
            set
            {
                _currentValue = value;
                InvokePropertyChanged("CurrentValue");
            }
        }
        private float _currentValue;



        public float StartValue
        {
            get { return _startValue; }
            set
            {
                _startValue = value;
                InvokePropertyChanged("StartValue");
            }
        }
        private float _startValue;


        public float LimitValue
        {
            get { return _limitValue; }
            set
            {
                _limitValue = value;
                InvokePropertyChanged("LimitValue");
            }
        }
        private float _limitValue;



        public string MaintenanceProcessing
        {
            get { return _maintenanceProcessing; }
            set
            {
                _maintenanceProcessing = value;
                InvokePropertyChanged("MaintenanceProcessing");
            }
        }
        private string _maintenanceProcessing;


        public string Display
        {
            get { return _display; }
            set
            {
                _display = value;
                InvokePropertyChanged("Display");
            }
        }
        private string _display;


        public string Path { get; set; }
        public string AdditionInformationName { get; set; }


        public string AdditionInformationDisplay
        {
            get { return _additionInformationDisplay; }
            set
            {
                _additionInformationDisplay = value;
                InvokePropertyChanged("AdditionInformationDisplay");
            }
        }
        private string _additionInformationDisplay;


        public DataItemEnum DataItemType { get; set; }

        public ReactorsEnum ReactorsType { get; set; }

        public DummyEnum DummyType { get; set; }
    }

    public class EnumToBoolConverter : IValueConverter
    {
        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
        {
            return value == null ? false : value.Equals(parameter);
        }

        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
        {
            var res = value != null && value.Equals(true) ? parameter : Binding.DoNothing;
            return res;
        }
    }
}