PunkHPX8/PunkHPX8_MainPages/ViewModels/DqdrRecipeViewModel.cs

using Aitex.Core.UI.MVVM;
using Aitex.Core.Utilities;
using MECF.Framework.Common.DataCenter;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.RecipeCenter;
using MECF.Framework.Common.Utilities;
using Prism.Mvvm;
using PunkHPX8_MainPages.PMs;
using PunkHPX8_Themes.UserControls;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Input;

namespace PunkHPX8_MainPages.ViewModels
{
    public class DqdrRecipeViewModel : BindableBase
    {
        #region 常量
        private const string ENGINEERING = "Engineering";

        private const string DQDR = "dqdr";
        private const string DEP = "dep";
        #endregion

        #region 内部变量
        /// <summary>
        /// Recipe节点字典
        /// </summary>
        private Dictionary<string, RecipeNode> _recipeNodeDic = new Dictionary<string, RecipeNode>();
        /// <summary>
        /// 属性检验结果字典
        /// </summary>
        private Dictionary<string, bool> _propertyValidResultDic = new Dictionary<string, bool>();
        /// <summary>
        /// Recipe节点集合
        /// </summary>
        private ObservableCollection<RecipeNode> _recipeNodes;
        /// <summary>
        /// DepRecipe节点集合
        /// </summary>
        private ObservableCollection<RecipeNode> _depRecipeNodes;
        /// <summary>
        /// Plating Cell List
        /// </summary>
        private ObservableCollection<string> _platingCellList = new ObservableCollection<string>();
        /// <summary>
        /// DepRecipe Name List
        /// </summary>
        private ObservableCollection<string> _depRecipeNameList = new ObservableCollection<string>();
        /// <summary>
        /// uiRecipeManager
        /// </summary>
        private UiRecipeManager _uiRecipeManager = new UiRecipeManager();
        /// <summary>
        /// recipe
        /// </summary>
        private DqdrRecipe _recipe;
        /// <summary>
        /// 编辑可用性
        /// </summary>
        private bool _editEnable;
        /// <summary>
        /// 创建可用性
        /// </summary>
        private bool _createEnable;
        /// <summary>
        /// 当前节点
        /// </summary>
        private RecipeNode _currentNode;
        /// <summary>
        /// 是否可用
        /// </summary>
        private bool _enable = false;
        /// <summary>
        /// 是否为编辑(true-Edit,false-add)
        /// </summary>
        private bool _isEdit = false;
        #endregion

        #region 属性
        public ObservableCollection<RecipeNode> RecipeNodes
        {
            get { return _recipeNodes; }
            set { SetProperty(ref _recipeNodes, value); }
        }
        public ObservableCollection<RecipeNode> DepRecipeNodes
        {
            get { return _depRecipeNodes; }
            set { SetProperty(ref _depRecipeNodes, value); }
        }
        public ObservableCollection<string> PlatingCellList
        {
            get { return _platingCellList; }
            set { SetProperty(ref _platingCellList, value); }
        }
        public ObservableCollection<string> DepRecipeNameList
        {
            get { return _depRecipeNameList; }
            set { SetProperty(ref _depRecipeNameList, value); }
        }
        /// <summary>
        /// Recipe
        /// </summary>
        public DqdrRecipe Recipe
        {
            get { return _recipe; }
            set { SetProperty(ref _recipe, value); }
        }
        /// <summary>
        /// 创建可用性
        /// </summary>
        public bool CreateEnable
        {
            get { return _createEnable; }
            set { SetProperty(ref _createEnable, value); }
        }
        /// <summary>
        /// 编辑可用性
        /// </summary>
        public bool EditEnable
        {
            get { return _editEnable; }
            set { SetProperty(ref _editEnable, value); }
        }
        /// <summary>
        /// 当前节点
        /// </summary>
        public RecipeNode CurrentNode
        {
            get { return _currentNode; }
            set { SetProperty(ref _currentNode, value); }
        }
        /// <summary>
        /// 可用性
        /// </summary>
        public bool Enable
        {
            get { return _enable; }
            set { SetProperty(ref _enable, value); }
        }
        /// <summary>
        /// 属性数据检验结果
        /// </summary>
        public Dictionary<string, bool> PropertyValidResultDic
        {
            get { return _propertyValidResultDic; }
            set { SetProperty(ref _propertyValidResultDic, value); }
        }

        #endregion

        #region 指令
        [IgnorePropertyChange]
        public ICommand OperationCommand
        {
            get;
            private set;
        }

        [IgnorePropertyChange]
        public ICommand CreateCommand { get; private set; }

        [IgnorePropertyChange]
        public ICommand EditCommand { get; private set; }
        [IgnorePropertyChange]
        public ICommand SaveRecipeCommand { get; private set; }
        [IgnorePropertyChange]
        public ICommand SaveAsRecipeCommand { get; private set; }
        public ICommand LinkedDepRecipeChangeCommand { get; private set; }

        #endregion
        /// <summary>
        /// 构造函数
        /// </summary>
        public DqdrRecipeViewModel()
        {
            OperationCommand = new DelegateCommand<object>(SelectionChangedAction);
            CreateCommand = new DelegateCommand<object>(CreateAction);
            EditCommand = new DelegateCommand<object>(EditAction);
            SaveRecipeCommand = new DelegateCommand<object>(SaveAction);
            SaveAsRecipeCommand = new DelegateCommand<object>(SaveAsAction);
            LinkedDepRecipeChangeCommand = new DelegateCommand<object>(LinkedDepRecipeChangeAction);
          
            InitializeProprtyValidResultDictionary();

            InitializePlatingCellNameList();

        }
        /// <summary>
        /// 初始化属性数据检验结果字典
        /// </summary>
        private void InitializeProprtyValidResultDictionary()
        {
            PropertyValidResultDic["ReclaimSpeed"] = false;
            PropertyValidResultDic["ReclaimTime"] = false;

            PropertyValidResultDic["RinseSpeed"] = false;
            PropertyValidResultDic["RinseTime"] = false;

            PropertyValidResultDic["DrySpeed"] = false;
            PropertyValidResultDic["DryTime"] = false;

            PropertyValidResultDic["IntervalRinseSpeed"] = false;
            PropertyValidResultDic["IntervalRinseTime"] = false;


        }
        /// <summary>
        /// 加载数据
        /// </summary>
        public void LoadRecipeData()
        {
            RecipeNodes = _uiRecipeManager.GetRecipesByType(DQDR);
            DepRecipeNodes = _uiRecipeManager.GetRecipesByType(DEP);
            _recipeNodeDic.Clear();
            InitializeDictionary(RecipeNodes);
            InitializeDepRecipeList();

        }
        /// <summary>
        /// 初始化字典
        /// </summary>
        /// <param name="nodes"></param>
        private void InitializeDictionary(ObservableCollection<RecipeNode> nodes)
        {
            if (nodes != null)
            {
                foreach (var node in nodes)
                {
                    if (node.NodeType == RecipeNodeType.File)
                    {
                        _recipeNodeDic[node.Name] = node;
                    }
                    InitializeDictionary(node.Children);
                }
            }
        }
        /// <summary>
        /// 初始化DEP recipe名字列表
        /// </summary>
        private void InitializeDepRecipeList()
        {
            DepRecipeNameList.Clear();
            if (DepRecipeNodes != null && DepRecipeNodes.Count > 0)
            {
                foreach (var item in DepRecipeNodes[0].Children)
                {
                    DepRecipeNameList.Add(item.FileName);
                }
            }
            
        }
        /// <summary>
        /// 初始化platingcell list
        /// </summary>
        private void InitializePlatingCellNameList()
        {
            PlatingCellList.Clear();
            PlatingCellList.Add(ModuleName.PlatingCell1.ToString());
            PlatingCellList.Add(ModuleName.PlatingCell2.ToString());
            PlatingCellList.Add(ModuleName.PlatingCell2.ToString());
            PlatingCellList.Add(ModuleName.PlatingCell4.ToString());
        }
        /// <summary>
        /// 操作
        /// </summary>
        /// <param name="param"></param>
        private void SelectionChangedAction(object param)
        {
            if (_recipeNodeDic.ContainsKey(param.ToString()))
            {
                CurrentNode = _recipeNodeDic[param.ToString()];
                if (CurrentNode.NodeType == RecipeNodeType.File)
                {
                    if (CurrentNode.RecipeLocation == ENGINEERING)
                    {
                        EditEnable = true;
                        CreateEnable = true;
                    }
                    else
                    {
                        EditEnable = false;
                        CreateEnable = false;
                    }
                }
                Recipe = _uiRecipeManager.LoadRecipe<DqdrRecipe>(CurrentNode.RecipeFullFileName);
                if (Recipe == null)
                {
                    MessageBox.Show("Invalid Recipe", "Load Recipe", MessageBoxButton.OK, MessageBoxImage.Error);
                    EditEnable = false;
                    CreateEnable = false;
                }
                Enable = false;
            }
            else
            {
                if (param.ToString() == ENGINEERING)
                {
                    CreateEnable = true;
                }
                else
                {
                    CreateEnable = false;
                }
                CurrentNode = null;
                Recipe = null;
                EditEnable = false;
                Enable = false;
            }
        }
        #region Action
        /// <summary>
        /// 创建
        /// </summary>
        /// <param name="param"></param>
        private void CreateAction(object param)
        {
            RecipeNameDialog recipeNameDialog = new RecipeNameDialog();
            if (recipeNameDialog.ShowDialog().Value)
            {
                Recipe = new DqdrRecipe();
                Recipe.CreateDate = DateTime.Now;
                Recipe.Ppid = recipeNameDialog.RecipeName;
                Recipe.Description = recipeNameDialog.RecipeDescription;
                Enable = true;
                _isEdit = false;
            }
        }
        /// <summary>
        /// 编辑
        /// </summary>
        /// <param name="param"></param>
        private void EditAction(object param)
        {
            Enable = true;
            _isEdit = false;
        }
        /// <summary>
        /// 确认当前dummy rinse recipe与关联的dep recipe的时间是否相等
        /// </summary>
        /// <param name="dqdr"></param>
        /// <param name="depRecipe"></param>
        /// <returns></returns>
        private void LinkedDepRecipeChangeAction(object param)
        {
            Recipe.IsIdentical = false;
            string linkedDepRecipeName = Recipe.LinkedDepRecipeName;
            string fullName = DepRecipeNodes[0].Children.FirstOrDefault(node => node.FileName == linkedDepRecipeName)?.RecipeFullFileName;
            DepRecipe deprecipe = _uiRecipeManager.LoadRecipe<DepRecipe>(fullName);
            if (deprecipe != null)
            {
                if (deprecipe.ReclaimTime == Recipe.ReclaimTime
                    && deprecipe.RinseTime == Recipe.RinseTime
                    && deprecipe.DryTime == Recipe.DryTime
                    && deprecipe.RinseBeforeEntryEnable == Recipe.RinseBeforeEntryEnable
                    && deprecipe.IntervalRinseTime == Recipe.IntervalRinseTime)
                {
                    Recipe.IsIdentical = true;
                }
            }

        }
        /// <summary>
        /// 保存
        /// </summary>
        /// <param name="param"></param>
        private void SaveAction(object param)
        {
            if (CheckValid(_isEdit))
            {
                Recipe.SaveDate = DateTime.Now;
                try
                {
                    _uiRecipeManager.SaveRecipe<DqdrRecipe>(ENGINEERING, Recipe.Ppid, "dqdr", Recipe);
                    LoadRecipeData();
                    MessageBox.Show("Save Recipe Success", "Save Recipe", MessageBoxButton.OK, MessageBoxImage.Information);
                    Enable = false;
                }
                catch (Exception ex)
                {
                    MessageBox.Show(ex.Message, "Save Recipe", MessageBoxButton.OK, MessageBoxImage.Error);
                }
            }
        }
        /// <summary>
        /// 另存为
        /// </summary>
        /// <param name="param"></param>
        private void SaveAsAction(object param)
        {
            if (Recipe == null)
            {
                MessageBox.Show("Select a Recipe first", "SaveAs Recipe", MessageBoxButton.OK, MessageBoxImage.Error);
                return;
            }
            DqdrRecipe recipe = new DqdrRecipe();
            if (CheckValid(_isEdit))
            {
                RecipeNameDialog recipeNameDialog = new RecipeNameDialog();
                if (recipeNameDialog.ShowDialog().Value)
                {
                    if (!CheckNameExist(recipeNameDialog.RecipeName))
                    {
                        recipe = new DqdrRecipe();
                        recipe = (DqdrRecipe)PropertyUtil.Clone(Recipe);
                        recipe.CreateDate = DateTime.Now;
                        recipe.Ppid = recipeNameDialog.RecipeName;
                        recipe.Description = recipeNameDialog.RecipeDescription;
                    }
                    else if (recipeNameDialog.RecipeName != null)
                    {
                        MessageBox.Show("Name can not be Null", "Create Recipe", MessageBoxButton.OK, MessageBoxImage.Error);
                        return;
                    }
                    else
                    {
                        return;
                    }
                }
                try
                {
                    _uiRecipeManager.SaveRecipe<DqdrRecipe>(ENGINEERING, recipe.Ppid, "dqdr", recipe);
                    LoadRecipeData();
                    MessageBox.Show("Save As Recipe Success", "SaveAs Recipe", MessageBoxButton.OK, MessageBoxImage.Information);
                    Enable = false;
                }
                catch (Exception ex)
                {
                    MessageBox.Show(ex.Message, "Save As Recipe", MessageBoxButton.OK, MessageBoxImage.Error);
                }
            }
        }
        /// <summary>
        /// 检验名称是否已经存在
        /// </summary>
        /// <param name="name"></param>
        /// <returns></returns>
        private bool CheckNameExist(string name)
        {
            foreach (string item in _recipeNodeDic.Keys)
            {
                if (item == name)
                {
                    MessageBox.Show($"{name} is exsit", "Save Recipe", MessageBoxButton.OK, MessageBoxImage.Error);
                    return true;
                }
            }
            return false;
        }
        /// <summary>
        /// 检验合法性
        /// </summary>
        /// <param name="editType"></param>
        /// <returns></returns>
        private bool CheckValid(bool editType)
        {
            foreach (string key in _propertyValidResultDic.Keys)
            {
                bool valid = _propertyValidResultDic[key];
                if (!valid)
                {
                    MessageBox.Show($"{key} data invalid", "Save Recipe", MessageBoxButton.OK, MessageBoxImage.Error);
                    return false;
                }
            }
            return true;
        }
        #endregion
    }
}