FurnaceELK/Furnace/FurnaceUI/Views/Maintenances/WaferRobotParameterViewModel.cs

using Aitex.Core.Common.DeviceData;
using Caliburn.Micro.Core;
using Caliburn.Micro;
using FurnaceUI.Models;
using FurnaceUI.Views.Parameter;
using MECF.Framework.UI.Client.CenterViews.Configs.SystemConfig;
using SciChart.Core.Extensions;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Xml.Linq;
using MECF.Framework.Common.DataCenter;
using MECF.Framework.Common.OperationCenter;
using Microsoft.DwayneNeed.Win32.User32;
using Aitex.Core.Util;
using MECF.Framework.UI.Client.ClientBase;
using OpenSEMI.ClientBase;
using System.Windows;
using System.Threading;
using FurnaceUI.DataModule;
using System.Text.RegularExpressions;
using System.Security.Policy;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Controls;

namespace FurnaceUI.Views.Maintenances
{
    public class WaferRobotParameterViewModel : FurnaceUIViewModelBase, ISupportMultipleSystem
    {
        public bool IsManagerPermission { get => this.Permission == 3; }
        private const string WaferRobotParameter_PATH = "PM1.RecipeEditParameter";
        public string SystemName { get; set; }
        private string _checkTypeParameter = "Speed";
        private string _checkAxis = "ZAxis";
        public Dictionary<string, string> SetValues { get; set; } = new Dictionary<string, string>();
        public Dictionary<string, string> ConfigDict { get; set; } = new Dictionary<string, string>();



        public Dictionary<string, string> ReadRobotParameterResultDict { get; set; }
        [Subscription("WaferRobot.Status")]
        public string WaferRobotStaus { get; set; }

        private bool _isShowRobotDownBtn = false;
        public bool IsShowRobotDownBtn
        {
            get { return _isShowRobotDownBtn; }
            set { _isShowRobotDownBtn = value; this.NotifyOfPropertyChange(nameof(IsShowRobotDownBtn)); }
        }
        public bool IsClickButton { get; set; }
        private ConfigNode _waferRobotParameterNode { get; set; }
        private ConfigNode _allRootNode { get; set; }

        private List<ConfigNode> _tableDataSource = new List<ConfigNode>();
        public List<ConfigNode> TableDataSource
        {
            get { return _tableDataSource; }
            set { _tableDataSource = value; this.NotifyOfPropertyChange(nameof(TableDataSource)); }
        }
        private List<DisplayByWaferType> _topBtnGroupDatas = new List<DisplayByWaferType>();
        public List<DisplayByWaferType> TopBtnGroupDatas
        {
            get { return _topBtnGroupDatas; }
            set { _topBtnGroupDatas = value; this.NotifyOfPropertyChange(nameof(TopBtnGroupDatas)); }
        }

        private Visibility _parameterTableVisibility = Visibility.Visible;
        public Visibility ParameterTableVisibility
        {
            get { return _parameterTableVisibility; }
            set { _parameterTableVisibility = value; this.NotifyOfPropertyChange(nameof(ParameterTableVisibility)); }
        }
        private Visibility _positionAxisTableVisibility = Visibility.Collapsed;
        public Visibility PositionAxisTableVisibility
        {
            get { return _positionAxisTableVisibility; }
            set { _positionAxisTableVisibility = value; this.NotifyOfPropertyChange(nameof(PositionAxisTableVisibility)); }
        }
        private Visibility _positionConfigTableVisibility = Visibility.Collapsed;
        public Visibility PositionConfigTableVisibility
        {
            get { return _positionConfigTableVisibility; }
            set { _positionConfigTableVisibility = value; this.NotifyOfPropertyChange(nameof(PositionConfigTableVisibility)); }
        }
        private Visibility _downloadUploadVisibility = Visibility.Collapsed;
        public Visibility DownloadUploadVisibility
        {
            get { return _downloadUploadVisibility; }
            set { _downloadUploadVisibility = value; this.NotifyOfPropertyChange(nameof(DownloadUploadVisibility)); }
        }
        private Visibility _axisBtnVisibility = Visibility.Collapsed;
        public Visibility AxisBtnVisibility
        {
            get { return _axisBtnVisibility; }
            set { _axisBtnVisibility = value; this.NotifyOfPropertyChange(nameof(AxisBtnVisibility)); }
        }
        private bool _busyIndicatorVisibility = false;
        public bool BusyIndicatorVisibility
        {
            get { return _busyIndicatorVisibility; }
            set { _busyIndicatorVisibility = value; this.NotifyOfPropertyChange(nameof(BusyIndicatorVisibility)); }
        }
        private bool _allBtnIsEnable = true;
        public bool AllBtnIsEnable
        {
            get { return _allBtnIsEnable; }
            set { _allBtnIsEnable = value; this.NotifyOfPropertyChange(nameof(AllBtnIsEnable)); }
        }
        private Visibility _slotBtnVisibility = Visibility.Collapsed;
        public Visibility SlotBtnVisibility
        {
            get { return _slotBtnVisibility; }
            set { _slotBtnVisibility = value; this.NotifyOfPropertyChange(nameof(SlotBtnVisibility)); }
        }
        public void SwitchListView(object obj)
        {
            _checkTypeParameter = obj.ToString();
            TableDataSource.Clear();
            _waferRobotParameterNode = FindNodeByName(_allRootNode, $"{SystemName}.{SystemName}Parameter.{_checkTypeParameter}");
            _checkAxis = "";
            TopBtnGroupDatas = new List<DisplayByWaferType>();
            switch (_checkTypeParameter)
            {
                case "PositionConfig":
                    PositionConfigTableVisibility = Visibility.Visible;
                    PositionAxisTableVisibility = Visibility.Collapsed;
                    ParameterTableVisibility = Visibility.Collapsed;
                    DownloadUploadVisibility = Visibility.Visible;
                    AxisBtnVisibility = Visibility.Visible;
                    SlotBtnVisibility = Visibility.Visible;
                    TopBtnGroupDatas = new List<DisplayByWaferType>() {
                    new DisplayByWaferType(){ GroupName="PositionConfigBtn", Name="StationNumber",Value="workstationNumber",IsSelected=true},
                    new DisplayByWaferType(){ GroupName="PositionConfigBtn",Name="LayerSpacing",Value="LayerSpacing",IsSelected=false},
                    new DisplayByWaferType(){ GroupName="PositionConfigBtn",Name="UpperOffset",Value="UpperOffset",IsSelected=false},
                    new DisplayByWaferType(){ GroupName="PositionConfigBtn",Name="DownOffset",Value="DownOffset",IsSelected=false},
                    };
                    _checkAxis = TopBtnGroupDatas.FirstOrDefault().Value;
                    break;
                case "PositionAxis":
                    PositionAxisTableVisibility = Visibility.Visible;
                    PositionConfigTableVisibility = Visibility.Collapsed;
                    ParameterTableVisibility = Visibility.Collapsed;
                    DownloadUploadVisibility = Visibility.Visible;
                    AxisBtnVisibility = Visibility.Collapsed;
                    SlotBtnVisibility = Visibility.Collapsed;
                    break;
                case "Speed":
                case "Time":
                    ParameterTableVisibility = Visibility.Visible;
                    PositionAxisTableVisibility = Visibility.Collapsed;
                    PositionConfigTableVisibility = Visibility.Collapsed;
                    DownloadUploadVisibility = Visibility.Visible;
                    AxisBtnVisibility = Visibility.Visible;
                    SlotBtnVisibility = Visibility.Collapsed;
                    TopBtnGroupDatas = new List<DisplayByWaferType>() {
                    new DisplayByWaferType(){GroupName="SpeedAxisBtn", Name="Z Axis",Value="ZAxis",IsSelected=true},
                    new DisplayByWaferType(){GroupName="SpeedAxisBtn", Name="TH Axis",Value="THAxis",IsSelected=false},
                    new DisplayByWaferType(){GroupName="SpeedAxisBtn", Name="EX1 Axis",Value="EX1Axis",IsSelected=false},
                    new DisplayByWaferType(){GroupName="SpeedAxisBtn", Name="EX2 Axis",Value="EX2Axis",IsSelected=false},
                    new DisplayByWaferType(){GroupName="SpeedAxisBtn", Name="P Axis",Value="PAxis",IsSelected=false},
                    }; _checkAxis = TopBtnGroupDatas.FirstOrDefault().Value;
                    break;
                case "Other":
                    ParameterTableVisibility = Visibility.Visible;
                    PositionAxisTableVisibility = Visibility.Collapsed;
                    PositionConfigTableVisibility = Visibility.Collapsed;
                    DownloadUploadVisibility = Visibility.Visible;
                    AxisBtnVisibility = Visibility.Visible;
                    SlotBtnVisibility = Visibility.Collapsed;
                    TopBtnGroupDatas = new List<DisplayByWaferType>() {
                    new DisplayByWaferType(){GroupName="SpeedAxisBtn", Name="Z Axis",Value="ZAxis",IsSelected=true},
                    new DisplayByWaferType(){GroupName="SpeedAxisBtn", Name="TH Axis",Value="THAxis",IsSelected=false},
                    new DisplayByWaferType(){GroupName="SpeedAxisBtn", Name="EX1 Axis",Value="EX1Axis",IsSelected=false},
                    new DisplayByWaferType(){GroupName="SpeedAxisBtn", Name="EX2 Axis",Value="EX2Axis",IsSelected=false},
                    new DisplayByWaferType(){GroupName="SpeedAxisBtn", Name="P Axis",Value="PAxis",IsSelected=false},
                    new DisplayByWaferType(){GroupName="SpeedAxisBtn", Name="Other",Value="Other",IsSelected=false},
                    }; _checkAxis = TopBtnGroupDatas.FirstOrDefault().Value;
                    break;
                case "Slot":
                    ParameterTableVisibility = Visibility.Visible;
                    PositionAxisTableVisibility = Visibility.Collapsed;
                    PositionConfigTableVisibility = Visibility.Collapsed;
                    DownloadUploadVisibility = Visibility.Visible;
                    AxisBtnVisibility = Visibility.Collapsed;
                    SlotBtnVisibility = Visibility.Collapsed;
                    break;
            }

            SwitchAxis(_checkAxis);
        }
        public void SwitchAxis(object obj)
        {
            _checkAxis = obj.ToString();
            TableDataSource.Clear();
            var data = new List<ConfigNode>();
            if (!string.IsNullOrEmpty(_checkAxis))
            {
                TopBtnGroupDatas.Where(a => a.Value == _checkAxis).FirstOrDefault().IsSelected = true;
            }
            if (_checkTypeParameter == "PositionAxis")
            {
                PositionAxisNodeToTableDataSource(data);
            }
            else
            {

                foreach (var itemType in _waferRobotParameterNode.SubNodes)
                {


                    foreach (var item in itemType.SubNodes)
                    {
                        var ptypeConfig = item.Items.Where(a => a.Name.Equals("Type")).FirstOrDefault();
                        if (ptypeConfig != null)
                        {
                            if (_checkTypeParameter.Equals(ptypeConfig.DefaultValue))
                            {
                                if (_checkTypeParameter == "PositionConfig")
                                {
                                    if (_checkAxis == itemType.Name)
                                    {
                                        item.ParentNode = itemType;
                                        data.Add(item);
                                        continue;
                                    }
                                }
                                else
                                {

                                    var axisItem = item.Items.Where(a => a.Name.Equals("Axis")).FirstOrDefault();

                                    if (axisItem != null && _checkAxis.Contains(axisItem.DefaultValue))
                                    {
                                        data.Add(item);
                                    }
                                    if (axisItem == null && !_checkAxis.Contains("Axis"))
                                    {
                                        data.Add(item);
                                    }
                                }
                            }
                        }

                    }


                }
            }

            TableDataSource = data;
            GetDataOfConfigItems();
            ClearReadDicData();

        }
        private void PositionAxisNodeToTableDataSource(List<ConfigNode> data)
        {
            foreach (var itemType in _waferRobotParameterNode.SubNodes)
            {


                data.Add(itemType);




            }

        }

        private void GetDataOfConfigItems()
        {
            if (TableDataSource == null)
            {
                return;
            }
            new Task(() =>
            {
                Dictionary<string, ConfigItem> keyValuePairs = new Dictionary<string, ConfigItem>();
                List<string> getConfigs = new List<string>();
                foreach (var item in TableDataSource)
                {

                    foreach (var tableItem in item.Items)
                    {
                        var key = $"{tableItem.Path}.{tableItem.Name}";
                        getConfigs.Add(key);
                        keyValuePairs.Add(key, tableItem);
                    }
                }
                var configs = QueryDataClient.Instance.Service.PollConfig(getConfigs);
                foreach (var key in configs.Keys)
                {
                    keyValuePairs[key].CurrentValue = configs[key].ToString();
                }
            }).Start();
        }

        public async void Upload(object obj)
        {

            var selection = DialogBox.ShowDialog(DialogButton.Yes | DialogButton.No, DialogType.CONFIRM,
              $"Are you sure you want to Upload?");
            if (selection == DialogButton.No)
                return;

            if (!IsClickButton)
            {
                return;
            }
            AllBtnIsEnable = false;
            BusyIndicatorVisibility = true;
            if (obj.ToString().Equals("PositionConfig"))
            {
                SetPositionConfigUpload();
            }
            else if (obj.ToString().Equals("PositionAxis"))
            {
                SetPositionAxisUpload();
            }
            else if (obj.ToString().Equals("Parameter"))
            {
                SetParameterUpload();
            }


            async void SetPositionAxisUpload()
            {
                var allNames = TableDataSource.Select(a => a.Name).ToList();
                string parameter = string.Join(";", TableDataSource.Select(a => a.Name).ToArray());
                if (!string.IsNullOrEmpty(parameter))
                {
                    InvokeClient.Instance.Service.DoOperation($"{SystemName}.ReadRobotParameters", "CurrentRobotPositionAxis", parameter);
                }
                await WaitForResultsAsync();
                if (ReadRobotParameterResultDict != null && ReadRobotParameterResultDict.Count > 0)
                {
                    foreach (var item in ReadRobotParameterResultDict)
                    {
                        if (!allNames.Contains(item.Key))
                        {
                            continue;
                        }
                        if (!allNames.Contains(item.Key))
                        {
                            continue;
                        }
                        var dataConfig = TableDataSource.Where(a => a.Name == item.Key).FirstOrDefault();
                        var itemValues = item.Value.Split(',').ToList();
                        InvokeClient.Instance.Service.DoOperation("System.SetConfig", $"{SystemName}.{SystemName}Parameter.PositionAxis.{item.Key}.ToDownAxis", CheckUnitData(dataConfig.Items[1].Unit, itemValues[0]));
                        InvokeClient.Instance.Service.DoOperation("System.SetConfig", $"{SystemName}.{SystemName}Parameter.PositionAxis.{item.Key}.RotateAxis", CheckUnitData(dataConfig.Items[2].Unit, itemValues[1]));
                        InvokeClient.Instance.Service.DoOperation("System.SetConfig", $"{SystemName}.{SystemName}Parameter.PositionAxis.{item.Key}.TelescopingAxis1", CheckUnitData(dataConfig.Items[3].Unit, itemValues[2]));
                        if (itemValues.Count>3)
                        {
                            InvokeClient.Instance.Service.DoOperation("System.SetConfig", $"{SystemName}.{SystemName}Parameter.PositionAxis.{item.Key}.TelescopingAxis2", CheckUnitData(dataConfig.Items[4].Unit, itemValues[3]));

                        }
                        if (itemValues.Count >4)
                        {
                            InvokeClient.Instance.Service.DoOperation("System.SetConfig", $"{SystemName}.{SystemName}Parameter.PositionAxis.{item.Key}.VariableSpacingAxis", CheckUnitData(dataConfig.Items[5].Unit, itemValues[4]));

                        }
                    }
                }
                GetDataOfConfigItems();
                BusyIndicatorVisibility = false;
                AllBtnIsEnable = true;

            }

            async void SetPositionConfigUpload()
            {

                var allNames = TableDataSource.Select(a => a.Name).ToList();
                List<string> parameterItem = new List<string>();
                foreach (var item in TableDataSource)
                {
                    parameterItem.Add($"{item.Name},{item.ParentNode.Items.FirstOrDefault().DefaultValue}");
                }

                string parameter = string.Join(";", parameterItem);
                if (!string.IsNullOrEmpty(parameter))
                {
                    InvokeClient.Instance.Service.DoOperation($"{SystemName}.ReadRobotParameters", "CurrentRobotPositionConfig", parameter);
                }
                await WaitForResultsAsync();
                if (ReadRobotParameterResultDict != null && ReadRobotParameterResultDict.Count > 0)
                {
                    foreach (var item in ReadRobotParameterResultDict)
                    {
                        if (!allNames.Contains(item.Key))
                        {
                            continue;
                        }
                        var dataConfig = TableDataSource.Where(a => a.Name == item.Key).FirstOrDefault();
                        var path = $"{dataConfig.Path}.{dataConfig.Name}.SetValue";

                        var unitConfig = dataConfig.Items.Where(a => a.Name == "Unit").FirstOrDefault();
                        var setValue = CheckUnitData(unitConfig.CurrentValue, item.Value.Split(',').LastOrDefault());
                        InvokeClient.Instance.Service.DoOperation("System.SetConfig", path, setValue);
                    }
                }
                GetDataOfConfigItems();
                BusyIndicatorVisibility = false;
                AllBtnIsEnable = true;
            }

            async void SetParameterUpload()
            {

                var allNames = TableDataSource.Select(a => a.Name.Replace("P", "")).ToList();
                string parameter = string.Join(";", allNames);

                if (!string.IsNullOrEmpty(parameter))
                {
                    InvokeClient.Instance.Service.DoOperation($"{SystemName}.ReadRobotParameters", "CurrentRobotParameters", parameter);
                }
                await WaitForResultsAsync();
                if (ReadRobotParameterResultDict != null && ReadRobotParameterResultDict.Count > 0)
                {
                    foreach (var item in ReadRobotParameterResultDict)
                    {
                        var itemConfig = TableDataSource.Where(a => a.Name == $"P{item.Key}").FirstOrDefault();

                        if (!allNames.Contains(item.Key) || itemConfig == null)
                            continue;

                        var unitConfig = itemConfig.Items.Where(a => a.Name == "Unit").FirstOrDefault();
                        var setValue = CheckUnitData(unitConfig.CurrentValue, item.Value);
                        InvokeClient.Instance.Service.DoOperation("System.SetConfig", $"{SystemName}.{SystemName}Parameter.Parameter.P{item.Key}.SetValue", setValue);
                    }
                }
                GetDataOfConfigItems();

                BusyIndicatorVisibility = false;
                AllBtnIsEnable = true;
            }

        }
        public List<double> ExtractFloatingPointNumbers(string input)
        {
            // 使用正则表达式匹配所有数字字符，包括小数点
            MatchCollection matches = Regex.Matches(input, @"\d+\.\d+|\d+");

            // 将匹配到的数字部分转换为 double 类型并添加到列表中
            List<double> result = new List<double>();
            foreach (Match match in matches)
            {
                if (double.TryParse(match.Value, out double number))
                {
                    result.Add(number);
                }
            }

            return result;
        }
        private double CheckUnitData(string unitStr, string valueStr, bool isDivision = false)
        {
            if (string.IsNullOrEmpty(unitStr))
            {
                return double.Parse(valueStr);
            }
            var numberData = ExtractFloatingPointNumbers(unitStr).FirstOrDefault();
            return isDivision ? double.Parse(valueStr) / numberData : double.Parse(valueStr) * numberData;

        }
        private string CheckUnitSetData(string unitStr, string valueStr, bool isDivision = false, int length = 11)
        {
            var setValue = CheckUnitData(unitStr, valueStr, isDivision);
            if (setValue >= 0)
            {
                return $"{Math.Abs(setValue).ToString().PadLeft(length, '0')}";
            }
            else
            {
                return $"{(Math.Abs(setValue) * -1).ToString().PadLeft(length, '0')}";

            }

        }
        private async Task WaitForResultsAsync()
        {
            // Simulate waiting for results using a delay
            // In a real-world scenario, you might wait for an event or a specific condition
            await Task.Delay(TableDataSource.Count * 300);

            // Here you can add logic to check if the results are ready
            // For example, polling or using a completion source
        }


        private string GetAxisValue(string value)
        {
            return (double.Parse(value.TrimStart('0')) / 1000).ToString("f3");

        }
        public void Download(object obj)
        {
            var selection = DialogBox.ShowDialog(DialogButton.Yes | DialogButton.No, DialogType.CONFIRM,
             $"Are you sure you want to Download?");
            if (selection == DialogButton.No)
                return;

            string parameter = "";
            string setParameter = "";
            if (obj.ToString().Equals("PositionConfig"))
            {
                SetPositionConfigDownload();
            }
            else if (obj.ToString().Equals("PositionAxis"))
            {
                SetPositionAxisDownload();
            }
            else if (obj.ToString().Equals("Parameter"))
            {
                SetParameterDownload();
            }
            if (!string.IsNullOrEmpty(parameter))
            {
                InvokeClient.Instance.Service.DoOperation($"{SystemName}.SetRobotParameters", setParameter, parameter);
                SetValues.Clear();
            }

            void SetParameterDownload()
            {
                setParameter = "SetParameter";

                foreach (var item in TableDataSource)
                {
                    var value = item.Items.Where(a => a.Name == "SetValue").FirstOrDefault().CurrentValue;
                    var unit = item.Items.Where(a => a.Name == "Unit").FirstOrDefault().CurrentValue;

                    var setValue = CheckUnitSetData(unit, value, true);
                    parameter = parameter + $"{item.Name.Replace("P", "")},{setValue};";

                }
                //foreach (var item in SetValues)
                //{

                //    parameter = parameter + $"{item.Key.Replace("P", "")},{item.Value};";
                //}

            };
            void SetPositionAxisDownload()
            {


                setParameter = "SetPositionAxis";
                foreach (var item in TableDataSource)
                {
                    List<string> valueStr = new List<string>();
                    for (int i = 1; i < item.Items.Count; i++)
                    {
                        var setValue = CheckUnitSetData(item.Items[i].Unit, item.Items[i].CurrentValue, true);
                        valueStr.Add(setValue);
                    }
                    parameter = parameter + $"{item.Name},{string.Join(",", valueStr.ToArray())};";
                }

            };
            void SetPositionConfigDownload()
            {
                setParameter = "SetPositionConfig";
                foreach (var item in TableDataSource)
                {
                    var value = item.Items.Where(a => a.Name == "SetValue").FirstOrDefault().CurrentValue;
                    var unit = item.Items.Where(a => a.Name == "Unit").FirstOrDefault().CurrentValue;

                    var setValue = CheckUnitSetData(unit, value, true);
                    parameter = parameter + $"{item.Name.Replace("P", "")},{setValue};";

                }

            };
        }
        public void ClearReadDicData()
        {
            InvokeClient.Instance.Service.DoOperation("CarrierRobot.ClearReadDicData");


        }
        public void SelectionChangedHandle(object obj, MouseButtonEventArgs e)
        {
            var source = e.OriginalSource as DependencyObject;
            while (source != null && !(source is ListViewItem))//只有listViewitem才触发
            {
                source = VisualTreeHelper.GetParent(source);
            }
            if (source == null) return;
            ConfigNode node = (ConfigNode)obj;
            if (node == null)
            {    
                return;
            }
            var windowManager = IoC.Get<IWindowManager>();
            var colData = TableDataSource.Where(a => a.Name.Equals(node.Name)).FirstOrDefault();
            if (_checkTypeParameter == "PositionConfig")
            {
                WaferRobotPositionEditViewModel editViewModel = new WaferRobotPositionEditViewModel();
                editViewModel.TableNodeItems = colData.Items;
                var rtn = (windowManager as WindowManager)?.ShowDialogWithTitle(editViewModel, null, $"Edit{SystemName}Position");
                if ((bool)rtn)
                {
                    if (string.IsNullOrEmpty(editViewModel.setValue))
                    {
                        return;
                    }
                    if (SetValues.ContainsKey(colData.Name))
                    {
                        SetValues[editViewModel._pName] = editViewModel.setValue;
                    }
                    else
                    {
                        SetValues.Add(editViewModel._pName, editViewModel.setValue);

                    }
                }
            }
            else if (_checkTypeParameter == "PositionAxis")
            {
                WaferRobotPositionAxisEditViewModel editViewModel = new WaferRobotPositionAxisEditViewModel();
                editViewModel.TableNodeItems = colData.Items;
                var rtn = (windowManager as WindowManager)?.ShowDialogWithTitle(editViewModel, null, $"Edit {SystemName}PositionAxis");
                if ((bool)rtn)
                {
                    if (string.IsNullOrEmpty(editViewModel.setValue))
                    {
                        return;
                    }
                    if (SetValues.ContainsKey(colData.Name))
                    {
                        SetValues[editViewModel._pName] = editViewModel.setValue;
                    }
                    else
                    {
                        SetValues.Add(editViewModel._pName, editViewModel.setValue);

                    }
                }
            }
            else
            {
                WaferRobotParameterEditViewModel editViewModel = new WaferRobotParameterEditViewModel();
                editViewModel.TableNodeItems = colData.Items;
                var rtn = (windowManager as WindowManager)?.ShowDialogWithTitle(editViewModel, null, $"Edit {SystemName}Parameter");
                if ((bool)rtn)
                {
                    if (string.IsNullOrEmpty(editViewModel.setValue))
                    {
                        return;
                    }
                    if (SetValues.ContainsKey(colData.Name))
                    {
                        SetValues[editViewModel._pName] = editViewModel.setValue;
                    }
                    else
                    {
                        SetValues.Add(editViewModel._pName, editViewModel.setValue);

                    }

                }
            }
            GetDataOfConfigItems();
            e.Handled = true;
        }
        protected override void OnInitialize()
        {
            base.OnInitialize();

            InitData();

        }
        private void InitData()
        {

            _allRootNode = SystemConfigProvider.Instance.GetConfig(true);
            SwitchListView(_checkTypeParameter);
        }
        protected override void InvokeAfterUpdateProperty(Dictionary<string, object> data)
        {
            base.InvokeAfterUpdateProperty(data);
            //         [Subscription("WaferRobot.ReadRobotParameterResultDict")]
            //public Dictionary<string, string> ReadRobotParameterResultDict { get; set; }
            IsShowRobotDownBtn = (bool)QueryDataClient.Instance.Service.GetConfig("System.IsShowRobotDownBtn");
            var readData = QueryDataClient.Instance.Service.GetData($"{SystemName}.ReadRobotParameterResultDict");
            if (readData != null)
            {
                ReadRobotParameterResultDict = (Dictionary<string, string>)readData;
            }
            if (WaferRobotStaus != null)
            {
                IsClickButton = true;
            }
        }
        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 + ".", ""));
        }

    }
}