CyberX8/CyberX8_MainPages/ViewModels/WaferHolderViewModel.cs

using Aitex.Core.Common;
using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.Routine;
using Aitex.Core.UI.MVVM;
using Aitex.Core.Utilities;
using MECF.Framework.Common.CommonData;
using MECF.Framework.Common.DataCenter;
using MECF.Framework.Common.DBCore;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.OperationCenter;
using MECF.Framework.Common.SubstrateTrackings;
using MECF.Framework.Common.WaferHolder;
using OpenSEMI.ClientBase;
using CyberX8_MainPages.Model;
using Prism.Common;
using Prism.Mvvm;
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;
using Unity;
using WPF.Themes.UserControls;
using MECF.Framework.Common.Layout;
using MECF.Framework.Common.Utilities;
using Aitex.Core.UI.ControlDataContext;
using System.Reflection;
using System.Windows.Threading;
using Aitex.Core.Util;
using Aitex.Core.RT.Log;

namespace CyberX8_MainPages.ViewModels
{
    public class WaferHolderViewModel : BindableBase
    {
        #region 局部变量
        /// <summary>
        /// buffer数据
        /// </summary>
        private ObservableCollection<WaferHolderBufferData> _bufferDatas = null;
        /// <summary>
        /// 未使用的载具
        /// </summary>
        private ObservableCollection<WaferHolderInfo> _unusedWaferHoders = null;
        /// <summary>
        /// 选择数据
        /// </summary>
        private WaferHolderBufferData _selectedBufferData = null;
        /// <summary>
        /// 选择未使用数据
        /// </summary>
        private WaferHolderInfo _selectedUnusedWaferHolderInfo = null;
        /// <summary>
        /// csr 类型集合
        /// </summary>
        private List<string> _crsTypeLst = null;
        /// <summary>
        /// Wafer尺寸集合
        /// </summary>
        private List<string> _waferSizeLst = null;
        /// <summary>
        /// 临时数据
        /// </summary>
        private WaferHolderBufferData _tmpWaferHolderBufferData = null;
        /// <summary>
        /// 化学液集合
        /// </summary>
        private List<string> _chemistryLst = null;
        /// <summary>
        /// Location位置集合
        /// </summary>
        private List<string> _locationLst = new List<string>();
        /// <summary>
        /// Reservoir集合
        /// </summary>
        private List<string> _reservoirLst = new List<string>();
        /// <summary>
        /// 是否编辑
        /// </summary>
        private bool _isEdit = false;
        /// <summary>
        /// 是否编辑Current Location
        /// </summary>
        private bool _isLocationEdit = false;
        /// <summary>
        /// 是否启用SaveandCancel按钮
        /// </summary>
        private bool _isSaveandCancelEdit = false;
        /// <summary>
        /// 操作
        /// </summary>
        /// <summary>
        /// 操作
        /// </summary>
        private string operation = "";
        /// <summary>
        /// 是否编辑载具Id
        /// </summary>
        private bool _isEditWaferHolderId = false;
        /// <summary>
        /// 定时器
        /// </summary>
        DispatcherTimer _timer;
        /// <summary>
        /// 查询后台数据集合
        /// </summary>
        private List<string> _rtDataKeys = new List<string>();
        /// <summary>
        /// rt查询key数值字典
        /// </summary>
        private Dictionary<string, object> _rtDataValueDic = new Dictionary<string, object>();
        /// <summary>
        /// ProcessTransporter是否Busy
        /// </summary>
        private bool _isProcessTransBusy;
        /// <summary>
        /// LoaderTransporter是否Busy
        /// </summary>
        private bool _isLoaderTransBusy;
        /// <summary>
        /// 是否在Auto模式下
        /// </summary>
        private bool _isAutoMode;
        #endregion

        #region 属性
        public List<string> CrsTypeLst
        {
            get { return _crsTypeLst; }
            set { SetProperty(ref _crsTypeLst, value); }
        }

        public List<string> WaferSizeLst
        {
            get { return _waferSizeLst; }
            set { SetProperty(ref _waferSizeLst, value); }
        }

        public List<string> ChemistryLst
        {
            get { return _chemistryLst; }
            set { SetProperty(ref _chemistryLst, value); }
        }
        /// <summary>
        /// Location位置集合
        /// </summary>
        public List<string> LocationLst
        {
            get { return _locationLst; }
            set { SetProperty(ref _locationLst, value); }
        }
        public ObservableCollection<WaferHolderBufferData> BufferDatas
        {
            get { return _bufferDatas; }
            set 
            { 
                SetProperty(ref _bufferDatas, value);
            }
        }
        /// <summary>
        /// 未使用载具
        /// </summary>
        public ObservableCollection<WaferHolderInfo> UnusedWaferHolders
        {
            get { return _unusedWaferHoders; }
            set
            {
                SetProperty(ref _unusedWaferHoders, value);
            }
        }

        /// <summary数据>
        /// 选择
        /// </summary>
        public WaferHolderBufferData SelectedBufferData
        {
            get { return _selectedBufferData; }
            set 
            { 
                if(_selectedBufferData==null||(value!=null&&value.Id!=_selectedBufferData.Id))
                {
                    BufferDataSelectedChanged(value);
                }
                SetProperty(ref _selectedBufferData, value); 
            }
        }
        /// <summary数据>
        /// 选择未使用的载具
        /// </summary>
        public WaferHolderInfo SelectedUnusedWaferHolderInfo
        {
            get { return _selectedUnusedWaferHolderInfo; }
            set
            {
                SetProperty(ref _selectedUnusedWaferHolderInfo, value);
            }
        }
        /// <summary>
        /// 临时数据
        /// </summary>
        public WaferHolderBufferData TmpBufferData
        {
            get { return _tmpWaferHolderBufferData; }
            set { SetProperty(ref _tmpWaferHolderBufferData, value); }
        }
        /// <summary>
        /// 是否编辑
        /// </summary>
        public bool IsEdit
        {
            get { return _isEdit; }
            set 
            {
                if(!value)
                {
                    IsEditWaferHolderId = false;
                }
                SetProperty(ref _isEdit, value);
            }
        }
        /// <summary>
        /// 是否编辑Current Location
        /// </summary>
        public bool IsLocationEdit
        {
            get { return _isLocationEdit; }
            set
            {
                SetProperty(ref _isLocationEdit, value);
            }
        }
        /// <summary>
        /// 是否启用Save和Cancel
        /// </summary>
        public bool IsSaveandCancelEdit
        {
            get { return _isSaveandCancelEdit; }
            set
            {               
                SetProperty(ref _isSaveandCancelEdit, value);
            }
        }
        /// <summary>
        /// 是否编辑载具Id
        /// </summary>
        public bool IsEditWaferHolderId
        {
            get { return _isEditWaferHolderId; }
            set { SetProperty(ref _isEditWaferHolderId, value); }
        }
               
        #endregion

        #region 按钮事件
        [IgnorePropertyChange]
        public ICommand EnableCommand
        {
            get;
            private set;
        }
        [IgnorePropertyChange]
        public ICommand DisableCommand
        {
            get;
            private set;
        }
        /// <summary>
        /// 增加
        /// </summary>
        public ICommand AddCommand
        { get; private set; }
        /// <summary>
        /// 编辑
        /// </summary>
        public ICommand EditCommand
        { get; private set; } 
        
        /// <summary>
        /// 保存
        /// </summary>
        public ICommand SaveCommand { get; private set; }
        /// <summary>
        /// 取消
        /// </summary>
        public ICommand CancelCommand { get; private set; }
        /// <summary>
        /// 移至Loader
        /// </summary>
        public ICommand MoveToLoaderCommand { get; private set; }
        /// <summary>
        /// 移出Loader
        /// </summary>
        public ICommand MoveFromLoaderCommand {  get; private set; }
        /// <summary>
        /// 移除
        /// </summary>
        public ICommand RemoveCommand { get; private set; }
        /// <summary>
        /// MoveLocation
        /// </summary>
        public ICommand MoveLocationCommand { get; private set; }
        #endregion
        /// <summary>
        /// 构造函数
        /// </summary>
        public WaferHolderViewModel() 
        {
            EnableCommand = new DelegateCommand<object>(EnableAction);
            DisableCommand=new DelegateCommand<object>(DisableAction);
            AddCommand=new DelegateCommand<object>(AddAction);
            EditCommand = new DelegateCommand<object>(EditAction);
            SaveCommand=new DelegateCommand<object>(SaveAction);
            CancelCommand=new DelegateCommand<object>(CancelAction);
            MoveToLoaderCommand = new DelegateCommand<object>(MoveToLoaderAction);
            MoveFromLoaderCommand = new DelegateCommand<object>(MoveFromLoaderAction);
            RemoveCommand = new DelegateCommand<object>(RemoveAction);
            MoveLocationCommand = new DelegateCommand<object>(MoveLocationAction);
            //Wafer尺寸集合
            WaferSizeLst = new List<string>();
            WaferSizeLst.Add("200");
            WaferSizeLst.Add("300");
            //化学液集合
            string chemistryContent = QueryDataClient.Instance.Service.GetConfig($"System.ChemistryList").ToString();
            if (!string.IsNullOrEmpty(chemistryContent))
            {
                ChemistryLst = chemistryContent.Split(',').ToList();
            }
            //CrsType集合
            string crstypeContent = QueryDataClient.Instance.Service.GetConfig($"System.LSType").ToString();
            if(!string.IsNullOrEmpty(crstypeContent))
            {
                _crsTypeLst = crstypeContent.Split(',').ToList();
            }
            //Location集合
            List<string> _rtDataKeys = new List<string>();
            _rtDataKeys.Add("System.LayoutCellItems");
            var _rtDataValueDic = QueryDataClient.Instance.Service.PollData(_rtDataKeys);
            if (_rtDataValueDic != null)
            {
                //获取ProcessCell列表
                LocationLst= CommonFunction.GetValue<List<string>>(_rtDataValueDic, "System.LayoutCellItems");                
            }                              

        }

        /// <summary>
        /// 加载数据
        /// </summary>
        public void LoadData(string systemName)
        {
            if (_timer == null)
            {
                _timer = new DispatcherTimer();
                _timer.Interval = TimeSpan.FromMilliseconds(200);
                _timer.Tick += Timer_Tick;
            }
            _timer.Start();

            _rtDataKeys.Clear();
            _rtDataKeys.Add($"Transporter1.IsBusy");
            _rtDataKeys.Add($"Transporter2.IsBusy");
            _rtDataKeys.Add("System.IsAutoMode");
        }
        /// <summary>
        /// 定时器执行
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Timer_Tick(object sender, EventArgs e)
        {
            if (_rtDataKeys.Count != 0)
            {
                _rtDataValueDic = QueryDataClient.Instance.Service.PollData(_rtDataKeys);
                if (_rtDataValueDic != null)
                {
                    _isProcessTransBusy = CommonFunction.GetValue<bool>(_rtDataValueDic, $"Transporter1.IsBusy");
                    _isLoaderTransBusy = CommonFunction.GetValue<bool>(_rtDataValueDic, $"Transporter2.IsBusy");
                    _isAutoMode = CommonFunction.GetValue<bool>(_rtDataValueDic, $"System.IsAutoMode");
                }
            }
        }
        /// <summary>
        /// 加载载具数据
        /// </summary>
        public void LoadWaferHolderDatas()
        {
            BufferDatas = new ObservableCollection<WaferHolderBufferData>();
            for (int i = 1; i <= 16; i++)
            {
                BufferDatas.Add(new WaferHolderBufferData() { Id = i });
            }
            List<WaferHolderInfo> waferHolderInfos = WaferHolderDataClient.Instance.Service.GetAllWaferHolderDatas();
            UpdateWaferHolderBufferDatas(waferHolderInfos);
            GetUnusedWaferHolderData(waferHolderInfos);
            IsEdit = false;
            IsSaveandCancelEdit = false;
            IsLocationEdit = false;
        }
        /// <summary>
        /// 更新buffer数据
        /// </summary>
        /// <param name="waferHolderInfos"></param>
        private void UpdateWaferHolderBufferDatas(List<WaferHolderInfo> waferHolderInfos)
        {
            for (int i=0;i< BufferDatas.Count;i++)
            {
                WaferHolderInfo holderInfo= waferHolderInfos.Find(O => O.BufferId == BufferDatas[i].Id && !string.IsNullOrEmpty(O.CurrentLocation));
                if(holderInfo != null)
                {
                    SwitchWaferInfoToWaferHolderBufferData(holderInfo, BufferDatas[i]);
                }
            }
        }

        /// <summary>
        /// 获取未使用载具数据
        /// </summary>
        /// <param name="waferHolderInfos"></param>
        private void GetUnusedWaferHolderData(List<WaferHolderInfo> waferHolderInfos)
        {
            UnusedWaferHolders = new ObservableCollection<WaferHolderInfo>();
            UnusedWaferHolders.AddRange(waferHolderInfos.FindAll(O => string.IsNullOrEmpty(O.CurrentLocation)));
        }
        /// <summary>
        /// 检验选择
        /// </summary>
        /// <returns></returns>
        private bool CheckSelection()
        {
            if (_selectedBufferData == null)
            {
                MessageBox.Show("please select one data", "Check", MessageBoxButton.OK, MessageBoxImage.Error);
                return false;
            }
            if (string.IsNullOrEmpty(SelectedBufferData.WaferHolderId))
            {
                MessageBox.Show("empty data", "Check", MessageBoxButton.OK, MessageBoxImage.Error);
                return false;
            }
            return true;
        }
        /// <summary>
        /// 启用事件
        /// </summary>
        /// <param name="param"></param>
        private void EnableAction(object param)
        {
            if(!CheckSelection())
            {
                return;
            }
            int result= WaferHolderDataClient.Instance.Service.UpdateWaferHolderEnable(SelectedBufferData.WaferHolderId, true);
            if(result!=0)
            {
                SelectedBufferData.Enabled = "True";
            }
        }
        /// <summary>
        /// 启用事件
        /// </summary>
        /// <param name="param"></param>
        private void DisableAction(object param)
        {
            if (!CheckSelection())
            {
                return;
            }

            int result= WaferHolderDataClient.Instance.Service.UpdateWaferHolderEnable(SelectedBufferData.WaferHolderId, false);
            if(result!=0)
            {
                SelectedBufferData.Enabled = "False";
            }
        }
        /// <summary>
        /// 新增
        /// </summary>
        /// <param name="param"></param>
        private void AddAction(object param)
        {
            if (_selectedBufferData == null)
            {
                MessageBox.Show("please select one data", "Add", MessageBoxButton.OK, MessageBoxImage.Error);
                return;
            }
            if (!string.IsNullOrEmpty(SelectedBufferData.WaferHolderId))
            {
                MessageBox.Show("data exist,can not add operation", "Add", MessageBoxButton.OK, MessageBoxImage.Error);
                return;
            }
            IsEditWaferHolderId = true;
            operation = "Add";
            InitialWaferHolderBuffer();
            IsEdit = true;
            IsSaveandCancelEdit = true;
        }
        /// <summary>
        /// 初始数据
        /// </summary>
        private void InitialWaferHolderBuffer()
        {
            if(SelectedBufferData==null)
            {
                return;
            }
            TmpBufferData = new WaferHolderBufferData();
            TmpBufferData.Enabled = "True";
            TmpBufferData.Id = SelectedBufferData.Id;
            TmpBufferData.CrsATotalUses = "0";
            TmpBufferData.CrsAUsesSincePadClean = "0";
            TmpBufferData.CrsAUsesSinceSealClean = "0";
            TmpBufferData.CrsBTotalUses = "0";
            TmpBufferData.CrsBUsesSincePadClean = "0";
            TmpBufferData.CrsBUsesSinceSealClean = "0";
            TmpBufferData.TotalDummyWafers = "0";
            TmpBufferData.TotalProductWafers = "0";
            TmpBufferData.TotalUses = "0";
        }
        /// <summary>
        /// 编辑
        /// </summary>
        /// <param name="param"></param>
        private void EditAction(object param)
        {
            if (!CheckSelection())
            {
                return;
            }
            if(string.IsNullOrEmpty(SelectedBufferData.WaferHolderId))
            {
                MessageBox.Show("empty data","Edit",MessageBoxButton.OK,MessageBoxImage.Error);
                return;
            }
            operation= "edit";
            IsEdit = true;
            IsSaveandCancelEdit = true;
        }
        /// <summary>
        /// 检验
        /// </summary>
        /// <returns></returns>
        private bool Validation(out string reason)
        {
            reason = "";
            if (string.IsNullOrEmpty(TmpBufferData.WaferHolderId))
            {
                reason = "WS Id is Empty";
                return false;
            }
            if(string.IsNullOrEmpty(TmpBufferData.CrsType))
            {
                reason = "LS Type is Empty";
                return false;
            }
            if (string.IsNullOrEmpty(TmpBufferData.WaferSize))
            {
                reason = "Wafer Size is empty";
                return false;
            }
            if (string.IsNullOrEmpty(TmpBufferData.CrsAId))
            {
                reason = "LS-A Id is empty";
                return false;
            }
            if (string.IsNullOrEmpty(TmpBufferData.CrsBId))
            {
                reason = "LS-B Id is empty";
                return false;
            }
            if (TmpBufferData.CrsAId == TmpBufferData.CrsBId)
            {
                reason = "The LS Id of A and B can not be the same";
                return false;
            }
            if (string.IsNullOrEmpty(TmpBufferData.Chemistry))
            {
                reason = "Chemistry is empty";
                return false;
            }
            for (int i = 0; i < BufferDatas.Count; i++)
            {
                if ( BufferDatas[i].Id != TmpBufferData.Id && (TmpBufferData.CrsAId == BufferDatas[i].CrsAId || TmpBufferData.CrsAId == BufferDatas[i].CrsBId))
                {
                    reason = "LS-A Id is already exist";
                    return false;
                }
                if ( BufferDatas[i].Id != TmpBufferData.Id && (TmpBufferData.CrsBId == BufferDatas[i].CrsBId || TmpBufferData.CrsBId == BufferDatas[i].CrsAId) )
                {
                    reason = "LS-B Id is already exist";
                    return false;
                }
            }
            TmpBufferData.TotalDummyWafers = string.IsNullOrEmpty(TmpBufferData.TotalDummyWafers) ? "0" : TmpBufferData.TotalDummyWafers;
            TmpBufferData.TotalUses = string.IsNullOrEmpty(TmpBufferData.TotalUses) ? "0" : TmpBufferData.TotalUses;
            TmpBufferData.TotalProductWafers = string.IsNullOrEmpty(TmpBufferData.TotalProductWafers) ? "0" : TmpBufferData.TotalProductWafers;
            TmpBufferData.CrsATotalUses = string.IsNullOrEmpty(TmpBufferData.CrsATotalUses) ? "0" : TmpBufferData.CrsATotalUses;
            TmpBufferData.CrsAUsesSincePadClean = string.IsNullOrEmpty(TmpBufferData.CrsAUsesSincePadClean) ? "0" : TmpBufferData.CrsAUsesSincePadClean;
            TmpBufferData.CrsAUsesSinceSealClean = string.IsNullOrEmpty(TmpBufferData.CrsAUsesSinceSealClean) ? "0" : TmpBufferData.CrsAUsesSinceSealClean;
            TmpBufferData.CrsBTotalUses = string.IsNullOrEmpty(TmpBufferData.CrsBTotalUses) ? "0" : TmpBufferData.CrsBTotalUses;
            TmpBufferData.CrsBUsesSincePadClean = string.IsNullOrEmpty(TmpBufferData.CrsBUsesSincePadClean) ? "0" : TmpBufferData.CrsBUsesSincePadClean;
            TmpBufferData.CrsBUsesSinceSealClean = string.IsNullOrEmpty(TmpBufferData.CrsBUsesSinceSealClean) ? "0" : TmpBufferData.CrsBUsesSinceSealClean;
            
            if(!CheckWaferHolderId())
            {
                reason = "WS Id exist";
                return false;
            }

            return true;
        }
        /// <summary>
        /// 检验载具唯 一性
        /// </summary>
        /// <returns></returns>
        private bool CheckWaferHolderId()
        {
            string waferHolderId = TmpBufferData.WaferHolderId;
            for(int i=0;i<BufferDatas.Count;i++)
            {
                if (waferHolderId == BufferDatas[i].WaferHolderId)
                {
                    if (BufferDatas[i].Id != TmpBufferData.Id)
                    {
                        return false;
                    }
                }
            }
            for(int i=0;i<UnusedWaferHolders.Count;i++)
            {
                if (waferHolderId == UnusedWaferHolders[i].Id)
                {
                    return false;
                }
            }
            return true;
        }
        /// <summary>
        /// 保存
        /// </summary>
        /// <param name="param"></param>
        public void SaveAction(object  param)
        {
            bool validation = Validation(out var reason);
            if(!validation)
            {
                WPFMessageBox.ShowError(reason);
                return;
            }
            WaferHolderInfo info = WaferHolderBuferDataConvertToWaferHolderInfo();
            int result = 0;
            if(operation=="Add")
            {
                info.BufferId = SelectedBufferData.Id;
                if(info.CurrentLocation == null)
                {
                    info.CurrentLocation = $"Buffer{info.BufferId}";
                }                  
                info.WaferAId = $"{info.Id}.01";
                info.WaferBId = $"{info.Id}.02";
                info.WaferAType = (int)WaferType.Assit;
                info.WaferBType = (int)WaferType.Assit;
                TmpBufferData.CurrentLocation = info.CurrentLocation;
                result= WaferHolderDataClient.Instance.Service.AddWaferHolderData(SelectedBufferData.Id, info);
            }else if(operation == "MoveLocation")
            {
                //判断能否更新位置
                if (!string.IsNullOrEmpty(SelectedBufferData.CurrentLocation) && !string.IsNullOrEmpty(info.CurrentLocation))
                {
                    if (!_isLoaderTransBusy && !_isProcessTransBusy && !_isAutoMode)
                    {
                        info.WaferAId = $"{info.Id}.01";
                        info.WaferBId = $"{info.Id}.02";
                        info.WaferAType = (int)WaferType.Assit;
                        info.WaferBType = (int)WaferType.Assit;
                        result = WaferHolderDataClient.Instance.Service.UpdateWaferHolderData(SelectedBufferData.WaferHolderId, info,true);
                        InvokeClient.Instance.Service.DoOperation($"WaferHolder.TransferWaferHolder", $"{SelectedBufferData.CurrentLocation}", $"{info.CurrentLocation}");
                    }
                    else if (_isAutoMode)
                    {
                        SelectedBufferData.SwitchData(TmpBufferData);
                        MessageBox.Show("Auto mode can't do this operation", "Save", MessageBoxButton.OK, MessageBoxImage.Error);
                    }
                    else
                    {
                        SelectedBufferData.SwitchData(TmpBufferData);
                        MessageBox.Show("Loader or Process Transporter is in Busy state", "Save", MessageBoxButton.OK, MessageBoxImage.Error);
                    }
                }               
            }
            else
            {
                //todo edit
                info.BufferId = SelectedBufferData.Id;
                info.WaferAId = $"{info.Id}.01";
                info.WaferBId = $"{info.Id}.02";
                info.WaferAType = (int)WaferType.Assit;
                info.WaferBType = (int)WaferType.Assit;
                result = WaferHolderDataClient.Instance.Service.UpdateWaferHolderData(SelectedBufferData.WaferHolderId, info, true);
                
            }
            if (result > 0)
            {
                SetSelectedWaferHolderData();                
            }
            IsEdit = false;
            IsLocationEdit = false;
            IsSaveandCancelEdit = false;
            operation = "";
        }
        /// <summary>
        /// 取消
        /// </summary>
        /// <param name="param"></param>
        public void CancelAction(object param)
        {
            if(operation=="Add")
            {
                TmpBufferData = new WaferHolderBufferData();
            }
            else
            {
                TmpBufferData = SelectedBufferData.Clone();
            }
            IsEdit = false;
            IsSaveandCancelEdit = false;
            IsLocationEdit= false;
        }
       
        /// <summary>
        /// 移入
        /// </summary>
        /// <param name="param"></param>
        public void MoveToLoaderAction(object param)
        {
            if(SelectedUnusedWaferHolderInfo==null)
            {
                MessageBox.Show("please select one unused data", "Move To Buffer", MessageBoxButton.OK, MessageBoxImage.Error);
                return;
            }
            if(SelectedBufferData==null)
            {
                MessageBox.Show("please select one data", "Edit", MessageBoxButton.OK, MessageBoxImage.Error);
                return;
            }
            if (!string.IsNullOrEmpty(SelectedBufferData.WaferHolderId))
            {
                MessageBox.Show("data exist,can not move operation", "Edit", MessageBoxButton.OK, MessageBoxImage.Error);
                return;
            }

            if (MessageBox.Show("do you want to move selected wafer shuttle to buffer", "Move To Buffer", MessageBoxButton.YesNoCancel, MessageBoxImage.Question) == MessageBoxResult.Yes)
            {
                SelectedUnusedWaferHolderInfo.CurrentLocation = $"Buffer{SelectedBufferData.Id}";
                SelectedUnusedWaferHolderInfo.BufferId = SelectedBufferData.Id;
                int result = WaferHolderDataClient.Instance.Service.UpdateWaferHolderData(SelectedUnusedWaferHolderInfo.Id, SelectedUnusedWaferHolderInfo,true);
                if (result != 0)
                {
                    SwitchWaferInfoToWaferHolderBufferData(SelectedUnusedWaferHolderInfo, SelectedBufferData);
                    BufferDataSelectedChanged(SelectedBufferData);
                    UnusedWaferHolders.Remove(SelectedUnusedWaferHolderInfo);
                    SelectedUnusedWaferHolderInfo = null;
                }
            }
        }
        /// <summary>
        /// 移出
        /// </summary>
        /// <param name="param"></param>
        public void MoveFromLoaderAction(object  param)
        {
            if(!CheckSelection())
            {               
                return;
            }
            if (MessageBox.Show("do you want to move out selected wafer shuttle from buffer", "Move From Buffer", MessageBoxButton.YesNoCancel, MessageBoxImage.Question) == MessageBoxResult.Yes)
            {
                WaferHolderInfo info = WaferHolderBuferDataConvertToWaferHolderInfo();
                string preLocation = info.CurrentLocation;
                info.CurrentLocation = "";
                int result = WaferHolderDataClient.Instance.Service.UpdateWaferHolderData(SelectedBufferData.WaferHolderId, info, true);
                if (result != 0)
                {
                    TmpBufferData = new WaferHolderBufferData();
                    TmpBufferData.Id = SelectedBufferData.Id;
                    TmpBufferData.SwitchData(SelectedBufferData);
                    UnusedWaferHolders.Add(info);
                }
            }
        }
        /// <summary>
        /// 移除
        /// </summary>
        /// <param name="param"></param>
        public void RemoveAction(object param)
        {
            if (SelectedUnusedWaferHolderInfo == null)
            {
                MessageBox.Show("please select one unused data", "Edit", MessageBoxButton.OK, MessageBoxImage.Error);
                return;
            }
            if (MessageBox.Show("do you want to remove selected unused wafer shuttle","remove",MessageBoxButton.YesNoCancel,MessageBoxImage.Question)==MessageBoxResult.Yes)
            {
                int result = WaferHolderDataClient.Instance.Service.DeleteWaferHolderData(SelectedUnusedWaferHolderInfo.Id);
                if (result != 0)
                {
                    UnusedWaferHolders.Remove(SelectedUnusedWaferHolderInfo);
                    SelectedUnusedWaferHolderInfo = null;
                }
            }
        }
        /// <summary>
        /// 编辑CurrentLocation
        /// </summary>
        /// <param name="param"></param>
        private void MoveLocationAction(object param)
        {
            if (!CheckSelection())
            {
                return;
            }
            if (string.IsNullOrEmpty(SelectedBufferData.WaferHolderId))
            {
                MessageBox.Show("empty data", "Move Location", MessageBoxButton.OK, MessageBoxImage.Error);
                return;
            }
            operation = "MoveLocation";
            IsLocationEdit = true;
            IsSaveandCancelEdit = true;
        }
        /// <summary>
        /// 数据切换
        /// </summary>
        /// <param name="waferHolderBufferData"></param>
        public void BufferDataSelectedChanged(WaferHolderBufferData waferHolderBufferData)
        {
            TmpBufferData=waferHolderBufferData.Clone();
            IsEdit = false;
            IsLocationEdit = false;
            IsSaveandCancelEdit = false;
        }
        /// <summary>
        /// 数据转换
        /// </summary>
        /// <returns></returns>
        private WaferHolderInfo WaferHolderBuferDataConvertToWaferHolderInfo()
        {
            WaferHolderInfo info = new WaferHolderInfo();
            info.Id = TmpBufferData.WaferHolderId;
            info.CrsType = TmpBufferData.CrsType;
            info.WaferSize = int.Parse(TmpBufferData.WaferSize);
            info.Chemistry = TmpBufferData.Chemistry;
            info.TotalUses = int.Parse(TmpBufferData.TotalUses);
            info.TotalDummyWafers = int.Parse(TmpBufferData.TotalDummyWafers);
            info.TotalProductWafers = int.Parse(TmpBufferData.TotalProductWafers);
            info.CrsAId = TmpBufferData.CrsAId;
            info.CrsATotalUses =int.Parse(TmpBufferData.CrsATotalUses);
            info.CrsAUsesSincePadClean = int.Parse(TmpBufferData.CrsAUsesSincePadClean);
            info.CrsAUsesSinceSealClean = int.Parse(TmpBufferData.CrsAUsesSinceSealClean);
            info.CrsBId = TmpBufferData.CrsBId;
            info.CrsBTotalUses = int.Parse(TmpBufferData.CrsBTotalUses);
            info.CrsBUsesSincePadClean = int.Parse(TmpBufferData.CrsBUsesSincePadClean);
            info.CrsBUsesSinceSealClean = int.Parse(TmpBufferData.CrsBUsesSinceSealClean);
            info.Enabled =bool.Parse(TmpBufferData.Enabled);
            info.CurrentLocation = TmpBufferData.CurrentLocation;
            info.Status = info.Enabled ? WaferHolderStatus.Normal : WaferHolderStatus.Disabled;
            return info;
        }
        /// <summary>
        /// 交换载具数据至载具Buffer数据
        /// </summary>
        /// <param name="info"></param>
        /// <param name="data"></param>
        private void SwitchWaferInfoToWaferHolderBufferData(WaferHolderInfo info,WaferHolderBufferData data)
        {
            data.CrsType = info.CrsType;
            data.WaferHolderId = info.Id;
            data.CrsType = info.CrsType;
            data.Chemistry = info.Chemistry;
            data.WaferSize = info.WaferSize.ToString();
            data.Enabled = info.Enabled.ToString();
            data.TotalUses = info.TotalUses.ToString();
            data.CrsAId = info.CrsAId;
            data.CrsATotalUses = info.CrsATotalUses.ToString();
            data.CrsAUsesSincePadClean = info.CrsAUsesSincePadClean.ToString();
            data.CrsAUsesSinceSealClean = info.CrsAUsesSinceSealClean.ToString();
            data.CrsBId = info.CrsBId;
            data.CrsBTotalUses = info.CrsBTotalUses.ToString();
            data.CrsBUsesSincePadClean = info.CrsBUsesSincePadClean.ToString();
            data.CrsBUsesSinceSealClean = info.CrsBUsesSinceSealClean.ToString();
            data.TotalDummyWafers = info.TotalDummyWafers.ToString();
            data.TotalProductWafers = info.TotalProductWafers.ToString();
            data.CurrentLocation = info.CurrentLocation;
        }
        /// <summary>
        /// 将临时变量赋值
        /// </summary>
        private void SetSelectedWaferHolderData()
        {
            SelectedBufferData.Id = TmpBufferData.Id;
            SelectedBufferData.WaferHolderId = TmpBufferData.WaferHolderId;
            SelectedBufferData.Chemistry = TmpBufferData.Chemistry;
            SelectedBufferData.CrsType = TmpBufferData.CrsType;
            SelectedBufferData.WaferSize = TmpBufferData.WaferSize;
            SelectedBufferData.TotalUses = TmpBufferData.TotalUses;
            SelectedBufferData.TotalProductWafers = TmpBufferData.TotalProductWafers;
            SelectedBufferData.TotalDummyWafers = TmpBufferData.TotalDummyWafers;
            SelectedBufferData.CrsAId = TmpBufferData.CrsAId;
            SelectedBufferData.CrsATotalUses = TmpBufferData.CrsATotalUses;
            SelectedBufferData.CrsAUsesSincePadClean = TmpBufferData.CrsBUsesSincePadClean;
            SelectedBufferData.CrsAUsesSinceSealClean = TmpBufferData.CrsAUsesSinceSealClean;
            SelectedBufferData.CrsBId = TmpBufferData.CrsBId;
            SelectedBufferData.CrsBTotalUses = TmpBufferData.CrsBTotalUses;
            SelectedBufferData.CrsBUsesSincePadClean = TmpBufferData.CrsBUsesSincePadClean;
            SelectedBufferData.CrsBUsesSinceSealClean = TmpBufferData.CrsBUsesSinceSealClean;
            SelectedBufferData.Enabled = TmpBufferData.Enabled;
            SelectedBufferData.CurrentLocation = TmpBufferData.CurrentLocation;
        }
    }
}