ELK/Furnace/FurnaceUI/Views/Editors/RecipeFlowSettingViewModel.cs

using Caliburn.Micro;
using MECF.Framework.Common.DataCenter;
using MECF.Framework.Common.OperationCenter;
using MECF.Framework.UI.Client.CenterViews.Configs.SystemConfig;
using MECF.Framework.UI.Client.CenterViews.Dialogs;
using OpenSEMI.ClientBase;
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Media;
using FurnaceUI.Models;

namespace FurnaceUI.Views.Editors
{
    public class RecipeFlowSettingViewModel : FurnaceUIViewModelBase
    {
        public bool IsSave { get; set; } = false;
        public string SelectMfcFlow { get; set; }

        public double MaxValue { get; set; }

        private ConfigNode _levelOneNode;
        public ConfigNode levelOneNode
        {
            get { return _levelOneNode; }
            set { _levelOneNode = value; this.NotifyOfPropertyChange(nameof(levelOneNode)); }
        }

        public string SelectFlow { get; set; }

        private ConfigNode _rootNode;

        private bool isFlowEnable;
        public bool IsFlowEnable
        {
            get { return isFlowEnable; }
            set { isFlowEnable = value; NotifyOfPropertyChange(nameof(IsFlowEnable)); }
        }

        private string selectFlowValue;
        public string SelectFlowValue
        {
            get
            {
                return selectFlowValue;
            }
            set
            {
                selectFlowValue = value;
                NotifyOfPropertyChange(SelectFlowValue);
            }
        }
        private string _CurrentNodeName = string.Empty;

        private List<ConfigItem> currenItems;

        public List<ConfigItem> CurrenItems
        {
            get { return currenItems; }
            set { currenItems = value; this.NotifyOfPropertyChange(nameof(CurrenItems)); }
        }

        private string _FlowModel;
        public string FlowModel { get { return _FlowModel; } set { _FlowModel = value; NotifyOfPropertyChange(nameof(FlowModel)); } }

        public string RecipeType { get; set; }
        public Visibility IsVisibilityContinue { get; set; } = Visibility.Visible;

        protected override void OnInitialize()
        {
            base.OnInitialize();
            //if (RecipeType == "Sub" || RecipeType == "Abort Sub" || RecipeType == "Abort")
            //    IsVisibilityContinue = Visibility.Visible;
            IsFlowEnable = false;
            _rootNode = SystemConfigProvider.Instance.GetConfig(true);
            var MfcItems = QueryDataClient.Instance.Service.GetConfigItemList();
            var items = MfcItems.Where(x => x.Name == "GasName").ToList();
            var flowItem = items.Where(s => s.Default == SelectMfcFlow.ToUpper()).ToList();
            levelOneNode = new ConfigNode();
            levelOneNode = FindNodeByName(_rootNode, $"PM1.RecipeEditParameter.FlowSetting.{flowItem[0].Default}");
            foreach (var item in levelOneNode.Items)
            {
                item.Unit = SystemConfigProvider.Instance.GetValueByName($"PM1.MFC.{levelOneNode.Display}.FlowUnit");
            }
            InitItemsCurrentValue(levelOneNode, false);
        }

        private void InitItemsCurrentValue(ConfigNode node, bool initSubItems = true)
        {
            if (node == null) return;
            CurrenItems = node.Items;
            _CurrentNodeName = string.IsNullOrEmpty(node.Path) ? node.Name : $"{node.Path}.{node.Name}";
            if (CurrenItems == null || CurrenItems.Count <= 0)
            {
                if (!initSubItems) return;
                foreach (var item in node.SubNodes)
                {
                    InitItemsCurrentValue(item);
                }
            }
            else
            {
                GetDataOfConfigItems();
            }
        }
        private void GetDataOfConfigItems()
        {
            if (CurrenItems == null)
                return;

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

                var isInstalled = QueryDataClient.Instance.Service.GetConfig($"PM1.MFC.{CurrenItems[i].Name}.IsMFCInstalled");
                if (isInstalled != null && !(bool)isInstalled)
                    CurrenItems[i].Visible = false;
                else
                    CurrenItems[i].Visible = true;
                string key = String.Format("{0}{1}{2}", _CurrentNodeName, ".", CurrenItems[i].Name);
                CurrenItems[i].CurrentValue = SystemConfigProvider.Instance.GetValueByName(key);
                CurrenItems[i].Path = key;
                CurrenItems[i].StringValue = CurrenItems[i].CurrentValue;
            }
        }


        private ConfigNode FindNodeByName(ConfigNode parentNode, string strName)
        {
            string strCates = strName.Split('.')[0];
            ConfigNode node = parentNode.SubNodes.Find((x) => x.Name == strCates);
            if (node == null)
                return parentNode;
            else
                return FindNodeByName(node, strName.Replace(strCates + ".", ""));
        }

        public void SetFlowValue(string nameCmd, string valueCmd)
        {
            FlowModel = nameCmd;
            if (FlowModel == "Value")
            {
                SelectFlow = nameCmd;
                IsFlowEnable = true;
            }
            else if (FlowModel == "Force")
            {
                SelectFlow = valueCmd;
                IsFlowEnable = false;
            }
            else
            {
                SelectFlow = nameCmd + ":" + valueCmd;
                IsFlowEnable = false;
            }
        }

        public void SetFlowCmd(string nameCmd)
        {
            switch (nameCmd)
            {
                case "Save":
                    IsSave = true;
                    if (FlowModel == "Value")
                    {
                        SelectFlow = SelectFlowValue;
                    }
                    if (string.IsNullOrEmpty(SelectFlow))
                    {
                        DialogBox.ShowWarning("flow value is empty");
                        return;
                    }
                    ((Window)GetView()).DialogResult = true;
                    break;
                case "Close":
                    IsSave = false;
                    ((Window)GetView()).DialogResult = false;
                    break;
                default:
                    break;
            }
        }


    }
}