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

using Caliburn.Micro.Core;
using FurnaceUI.DataModule;
using FurnaceUI.Models;
using FurnaceUI.Views.Operations;
using MECF.Framework.Common.OperationCenter;
using RecipeEditorLib.RecipeModel.Params;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;

namespace FurnaceUI.Views.Editors
{
    public class DummyWaferUseParameterEditViewModel : FurnaceUIViewModelBase
    {
        private ObservableCollection<WaferInfoItem> _stockerWaferInfoItems { get; set; }//传入数据源
        public ObservableCollection<DummywaferUseInfo> StockerWaferItems { get; set; }

        private string _moduleName = string.Empty;
        public DummywaferUseInfo CurrentSelection { get; set; }
        private bool _isEdit;

        public bool IsEdit
        {
            get { return _isEdit; }
            set
            {
                if (_isEdit != value)
                {
                    _isEdit = value;
                    NotifyOfPropertyChange(nameof(IsEdit));
                }
            }
        }
        private bool _isAllChecked;

        public bool IsAllChecked
        {
            get { return _isAllChecked; }
            set
            {
                if (_isAllChecked != value)
                {
                    _isAllChecked = value;
                    foreach (var item in StockerWaferItems)
                    {
                        if (item.IsEnable) item.IsChecked = _isAllChecked;
                    }
                    NotifyOfPropertyChange(nameof(IsAllChecked));
                }
            }
        }


        public DummyWaferUseParameterEditViewModel(ObservableCollection<WaferInfoItem> waferInfoItems, string moduleName)
        {
            _moduleName = moduleName;
            _stockerWaferInfoItems = waferInfoItems;
            var dummyTypes = GlobalDataManager.Instance.WaferTypes.Values.Where(r => r.IsDummy).Select(r => r.Name).ToList();
            StockerWaferItems = new ObservableCollection<DummywaferUseInfo>(waferInfoItems.Select(r => new DummywaferUseInfo
            {
                SlotID = r.SlotID,
                WaferType = r.WaferType,
                IsEnable = r.WaferStatus != 0 && dummyTypes.Contains(r.WaferType),
                UseCountCurrent = r.UseCount,
                UseThickCurrent = r.UseThick,
                UseTimeCurrent = r.UseTime
            }));
        }
        public void SetValueChange(DoubleParam param)
        {
            PropertyInfo[] properties = typeof(DummywaferUseInfo).GetProperties();
            var property = properties.FirstOrDefault(x => x.Name == param.Name);
            if (property == null) return;
            foreach (var item in StockerWaferItems)
            {
                if (item.IsChecked)
                {
                    var proParam = property.GetValue(item);
                    if (proParam is DoubleParam && proParam != param)
                    {
                        ((DoubleParam)proParam).SetValue(param.Value);
                        property.SetValue(item, proParam);
                    }
                }
            }
        }
        public void Save()
        {
            for (int i = 0; i < StockerWaferItems.Count; i++)
            {
                bool isChange = false;
                if (!StockerWaferItems[i].IsEnable) continue;
                if (StockerWaferItems[i].UseCountCurrent != StockerWaferItems[i].UseCountSet.Value)
                {
                    isChange = true;
                }
                if (StockerWaferItems[i].UseTimeCurrent != StockerWaferItems[i].UseTimeSet.Value)
                {
                    isChange = true;
                }
                if (StockerWaferItems[i].UseThickCurrent != StockerWaferItems[i].UseThickSet.Value)
                {
                    isChange = true;
                }
                //如果有改变直接更新
                if (isChange)
                {
                    var info = new List<string>
                    {
                        _moduleName,
                        $"{StockerWaferItems[i].SlotID}",
                        StockerWaferItems[i].WaferType,
                        StockerWaferItems[i].UseCountSet.Value,
                        StockerWaferItems[i].UseTimeSet.Value,
                        StockerWaferItems[i].UseThickSet.Value,
                    };
                    InvokeClient.Instance.Service.DoOperation("System.UpdateWafer", info.ToArray());
                }
            }
            TryClose(true);
        }
        public void Close()
        {
            TryClose(false);
        }

    }
    public class DummywaferUseInfo : PropertyChangedBase
    {
        public int SlotID { get; set; }
        public bool IsEnable { get; set; }
        public string WaferType { get; set; }
        public string UseCountCurrent { get; set; }
        public string UseThickCurrent { get; set; }
        public string UseTimeCurrent { get; set; }
        private bool _isChecked;

        public bool IsChecked
        {
            get { return _isChecked; }
            set
            {
                if (IsChecked != value)
                {
                    _isChecked = value;
                    NotifyOfPropertyChange(() => IsChecked);
                }
            }
        }

        private DoubleParam _useCountSet = new DoubleParam { Name = nameof(UseCountSet), Value = "0" };

        public DoubleParam UseCountSet
        {
            get { return _useCountSet; }
            set
            {
                _useCountSet = value;
                NotifyOfPropertyChange(() => UseCountSet);
            }
        }
        private DoubleParam _useThickSet = new DoubleParam { Name = nameof(UseThickSet), Value = "0" };

        public DoubleParam UseThickSet
        {
            get { return _useThickSet; }
            set
            {
                _useThickSet = value;
                NotifyOfPropertyChange(() => UseThickSet);
            }
        }
        private DoubleParam _useTimeSet = new DoubleParam { Name = nameof(UseTimeSet), Value = "0" };

        public DoubleParam UseTimeSet
        {
            get { return _useTimeSet; }
            set
            {
                _useTimeSet = value;
                NotifyOfPropertyChange(() => UseTimeSet);
            }
        }
    }
}