FurnaceELK/Furnace/FurnaceUI/Views/Editors/RecipeCombinationViewModel.cs

using Caliburn.Micro;
using FurnaceUI.Models;
using MECF.Framework.UI.Client.CenterViews.Editors;
using MECF.Framework.UI.Client.CenterViews.Editors.Parameter;
using MECF.Framework.UI.Client.CenterViews.Editors.Recipe;
using MECF.Framework.UI.Client.CenterViews.Editors.Sequence;
using MECF.Framework.UI.Client.CenterViews.Parameter;
using SciChart.Charting.Common.Extensions;
using System.Collections.ObjectModel;
using System.IO;
using System.Linq;
using System.Windows;

namespace FurnaceUI.Views.Editors
{
    public class RecipeCombinationViewModel : FurnaceUIViewModelBase
    {
        public bool IsSave { get; set; }
        public bool IsEnable => CGlobal.RecipeProcessEditViewEnable;//是否是View模式
        public Combination CombinationData { get; set; } = new Combination();
        public string RecipeType { get; set; }



        protected override void OnViewLoaded(object view)
        {
            base.OnViewLoaded(view);
        }

        public void ParameterFileSelect(string cmd, object value)
        {
            WindowManager wm = new WindowManager();
            var parameterProvider = new ParameterProvider();
            var typeFileList = new ObservableCollection<MECF.Framework.UI.Client.CenterViews.Editors.Recipe.ProcessTypeFileItem>();
            var type = new MECF.Framework.UI.Client.CenterViews.Editors.Recipe.ProcessTypeFileItem();
            ParameterSelectDialogViewModel parameterSelectDialogViewModel=new ParameterSelectDialogViewModel();
            parameterSelectDialogViewModel.DisplayName = cmd;
            string prefix = "";
            switch (cmd)
            {
                case "AlarmCondition":
                    var alarmCondition = parameterProvider.GetXmlParameterList($"Parameter\\AlarmCondition");
                    type.FileListByProcessType = ParameterTreeBuilder.BuildFileNode($"Parameter\\AlarmCondition", "", false, alarmCondition)[0].Files;
                    typeFileList.Add(type);
                    type.ProcessType = "AlarmCondition";
                    prefix = $"Parameter\\AlarmCondition";
                    SetProcessTypeIndexSelection(typeFileList, CombinationData.AlarmCondition);

                    parameterSelectDialogViewModel.ProcessTypeFileList = typeFileList;
                    if ((bool)wm.ShowDialog(parameterSelectDialogViewModel))
                    {
                        CombinationData.AlarmCondition = $"{parameterSelectDialogViewModel.DialogResult}";
                    }
                    break;
                case "LeakCheck":
                    var leakCheckCorrect = parameterProvider.GetXmlParameterList($"Parameter\\LeakCheckCondition");
                    type.FileListByProcessType = ParameterTreeBuilder.BuildFileNode($"Parameter\\LeakCheckCondition", "", false, leakCheckCorrect)[0].Files;
                    typeFileList.Add(type);
                    type.ProcessType = "LeakCheck";
                    prefix = $"Parameter\\LeakCheckCondition";
                    SetProcessTypeIndexSelection(typeFileList, CombinationData.LeakCheck);

                    parameterSelectDialogViewModel.ProcessTypeFileList = typeFileList;
                    if ((bool)wm.ShowDialog(parameterSelectDialogViewModel))
                    {
                        CombinationData.LeakCheck = $"{parameterSelectDialogViewModel.DialogResult}";
                    }
                    break;
                case "PressAPC":
                    var apcPIDCorrect = parameterProvider.GetXmlParameterList($"Parameter\\APCPID");
                    type.FileListByProcessType = ParameterTreeBuilder.BuildFileNode($"Parameter\\APCPID", "", false, apcPIDCorrect)[0].Files;
                    typeFileList.Add(type);
                    type.ProcessType = "PressAPC";
                    prefix = $"Parameter\\APCPID";
                    SetProcessTypeIndexSelection(typeFileList, CombinationData.PressAPC);

                    parameterSelectDialogViewModel.ProcessTypeFileList = typeFileList;
                    if ((bool)wm.ShowDialog(parameterSelectDialogViewModel))
                    {
                        CombinationData.PressAPC = $"{parameterSelectDialogViewModel.DialogResult}";
                    }
                    break;
                case "TempCorrection":
                    var tempCorrect = parameterProvider.GetXmlParameterList($"Parameter\\TempCorrection");
                    type.FileListByProcessType = ParameterTreeBuilder.BuildFileNode($"Parameter\\TempCorrection", "", false, tempCorrect)[0].Files;
                    typeFileList.Add(type);
                    type.ProcessType = "TempCorrection";
                    prefix = $"Parameter\\TempCorrection";
                    SetProcessTypeIndexSelection(typeFileList, CombinationData.TempCorrection);

                    parameterSelectDialogViewModel.ProcessTypeFileList = typeFileList;
                    if ((bool)wm.ShowDialog(parameterSelectDialogViewModel))
                    {
                        CombinationData.TempCorrection = $"{parameterSelectDialogViewModel.DialogResult}";
                    }
                    break;
                case "TempPID":
                    var tempPID = parameterProvider.GetXmlParameterList($"Parameter\\TempPID");
                    type.FileListByProcessType = ParameterTreeBuilder.BuildFileNode($"Parameter\\TempPID", "", false, tempPID)[0].Files;
                    typeFileList.Add(type);
                    type.ProcessType = "TempPID";
                    prefix = $"Parameter\\TempPID";
                    SetProcessTypeIndexSelection(typeFileList, CombinationData.TempPID);

                    parameterSelectDialogViewModel.ProcessTypeFileList = typeFileList;
                    if ((bool)wm.ShowDialog(parameterSelectDialogViewModel))
                    {
                        CombinationData.TempPID = $"{parameterSelectDialogViewModel.DialogResult}";
                    }
                    break;
                case "ProfileCondition":
                    var profileCorrect = parameterProvider.GetXmlParameterList($"Parameter\\TempProfile");
                    type.FileListByProcessType = ParameterTreeBuilder.BuildFileNode($"Parameter\\TempProfile", "", false, profileCorrect)[0].Files;
                    typeFileList.Add(type);
                    type.ProcessType = "ProfileCondition";
                    prefix = $"Parameter\\ProfileCondition";
                    SetProcessTypeIndexSelection(typeFileList, CombinationData.ProfileCondition);
                    parameterSelectDialogViewModel.ProcessTypeFileList = typeFileList;
                    if ((bool)wm.ShowDialog(parameterSelectDialogViewModel))
                    {
                        CombinationData.ProfileCondition = $"{parameterSelectDialogViewModel.DialogResult}";
                    }
                    break;
                default:
                    break;
            }
        }
        private void SetProcessTypeIndexSelection(ObservableCollection<ProcessTypeFileItem> processTypeFileList, string selectName)
        {
            if (string.IsNullOrEmpty(selectName)) return;

            foreach (var item in processTypeFileList.FirstOrDefault().FileListByProcessType)
            {
                if (selectName.Contains('\\'))
                {
                    if (item.FullPath == Path.GetDirectoryName(selectName))
                    {
                        foreach (var subItem in item.Files)
                        {
                            subItem.IsSelected = false;
                            if (subItem.Name.Equals(Path.GetFileName(selectName)))
                            {
                                subItem.IsSelected = true;
                                return;
                            }
                        } 
                    }
                }
                else
                {
                    item.IsSelected = false;
                    if (item.Name.Equals(selectName))
                    {
                        item.IsSelected = true;
                        return;
                    }
                }
            }
        }
        public void RecipeFileSelect(string cmd, object value)
        {
            RecipeSelectDialogViewModel selectDialog = new RecipeSelectDialogViewModel();
            WindowManager wm = new WindowManager();
            var type = new ProcessTypeFileItem();
            var prefix = "";
            switch (cmd)
            {
                case "SubRecipe":
                    type.ProcessType = "sub";
                    prefix = $"Furnace\\sub";
                    break;
                case "AlarmRecipe":
                    type.ProcessType = "alarm";
                    prefix = $"Furnace\\alarm";
                    break;
                case "AbortRecipe":
                    type.ProcessType = "abort";
                    prefix = $"Furnace\\abort";
                    break;
                default:
                    break;
            }
            if (string.IsNullOrEmpty(prefix))
                return;
            selectDialog.DisplayName = "Select Recipe";
            var recipeProvider = new RecipeProvider();
            var ProcessTypeFileList = new ObservableCollection<ProcessTypeFileItem>();
            var recipes = recipeProvider.GetXmlRecipeList(prefix);
            type.FileListByProcessType = RecipeSequenceTreeBuilder.BuildFileNode(prefix, "", false, recipes)[0].Files;
            ProcessTypeFileList.Add(type);

            switch (cmd)
            {
                case "SubRecipe":
                    SetProcessTypeIndexSelection(ProcessTypeFileList, CombinationData.SubRecipePath);
                    break;
                case "AlarmRecipe":
                    SetProcessTypeIndexSelection(ProcessTypeFileList, CombinationData.AlarmRecipePath);
                    break;
                case "AbortRecipe":
                    SetProcessTypeIndexSelection(ProcessTypeFileList, CombinationData.AbortRecipePath);
                    break;
                default:
                    break;
            }

            selectDialog.ProcessTypeFileList = ProcessTypeFileList;
            if ((bool)wm.ShowDialog(selectDialog))
            {
                switch (cmd)
                {
                    case "SubRecipe":
                        CombinationData.SubRecipePath = $"{selectDialog.DialogResult}";
                        break;
                    case "AlarmRecipe":
                        CombinationData.AlarmRecipePath = $"{selectDialog.DialogResult}";
                        break;
                    case "AbortRecipe":
                        CombinationData.AbortRecipePath = $"{selectDialog.DialogResult}";
                        break;
                    default:
                        break;
                }
            }
        }

        public void ClearClick(string cmd)
        {
            if (CombinationData == null) return;
            switch (cmd)
            {
                case "SubRecipe":
                    CombinationData.SubRecipePath = "";
                    break;
                case "AlarmRecipe":
                    CombinationData.AlarmRecipePath = "";
                    break;
                case "AlarmCondition":
                    CombinationData.AlarmCondition = "";
                    break;
                case "LeakCheck":
                    CombinationData.LeakCheck = "";
                    break;
                case "AbortRecipe":
                    CombinationData.AbortRecipePath = "";
                    break;
                case "PressAPC":
                    CombinationData.PressAPC = "";
                    break;
                case "TempCorrect":
                    CombinationData.TempCorrection = "";
                    break;
                case "TempPID":
                    CombinationData.TempPID = "";
                    break;
                case "ProfileCondition":
                    CombinationData.ProfileCondition = "";
                    break;
                default:
                    break;
            }
        }
        public void TempSetSave()
        {
            IsSave = true;
            CombinationData.SetValueToParam();
            ((Window)GetView()).DialogResult = true;
        }

        public void TempSetCancel()
        {
            IsSave = false;

            ((Window)GetView()).DialogResult = false;
        }


    }
}