Kepler-Release/Venus/Venus_MainPages/ViewModels/RFCalibrationViewModel.cs

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Venus_Core;
using Prism.Commands;
using Prism.Mvvm;
using MECF.Framework.Common.DataCenter;
using Aitex.Core.Common.DeviceData;
using MECF.Framework.Common.CommonData;
using System.Xml.Serialization;
using Aitex.Core.Util;

namespace Venus_MainPages.ViewModels
{
    public class RFCalibrationViewModel:BindableBase
    {
        #region 字段
        public ObservableCollection<CalibrationTableItem> m_CalibrationItems=new ObservableCollection<CalibrationTableItem>();
        public string ModuleName;
        private CalibrationTableItem m_CurrentSelection;
        public AITRfData rf;
        private string _GeneratorSerialNumber;
        private string _SensorSerialNumber;
        private double _RFPhysicalMaxPower;
        private double _CurrentRFMaxPower;
        private double _RFCalibratedMaxPower;
        private bool   _IsSelectedAllEnable;
        private ObservableCollection<NotifiableCalibrationTableItem> _TableData;
        private AITRfData _CurrentSelectionRF;
        #endregion

        #region 属性
        public ObservableCollection<CalibrationTableItem> CalibrationItems
        {
            get { return m_CalibrationItems; }
            set { SetProperty(ref m_CalibrationItems, value); }

        }
        public CalibrationTableItem CurrentSelection
        {
            get { return m_CurrentSelection; }
            set 
            {
                ChangeSelection(value);
                SetProperty(ref m_CurrentSelection, value); 
            }

        }
        public string GeneratorSerialNumber
        {
            get { return _GeneratorSerialNumber; }
            set { SetProperty(ref _GeneratorSerialNumber, value); }

        }
        public string SensorSerialNumber
        {
            get { return _SensorSerialNumber; }
            set { SetProperty(ref _SensorSerialNumber, value); }

        }
        public double RFPhysicalMaxPower
        {
            get { return _RFPhysicalMaxPower; }
            set { SetProperty(ref _RFPhysicalMaxPower, value); }
        }
        public double CurrentRFMaxPower
        {
            get { return _CurrentRFMaxPower; }
            set { SetProperty(ref _CurrentRFMaxPower, value); }
        }
        public double RFCalibratedMaxPower
        {
            get { return _RFCalibratedMaxPower; }
            set { SetProperty(ref _RFCalibratedMaxPower, value); }
        }
        public ObservableCollection<NotifiableCalibrationTableItem> TableData
        {
            get { return _TableData; }
            set { SetProperty(ref _TableData, value); }
        }
        public AITRfData CurrentSelectionRF
        {
            get { return _CurrentSelectionRF; }
            set { SetProperty(ref _CurrentSelectionRF, value); }
        }
        public bool IsSelectedAllEnable
        {
            get { return _IsSelectedAllEnable; }
            set { SetProperty(ref _IsSelectedAllEnable, value); }
        }
        #endregion

        #region 命令
        private DelegateCommand _CheckCommand;
        public DelegateCommand CheckCommand =>
            _CheckCommand ?? (_CheckCommand = new DelegateCommand(OnCheck));

        private DelegateCommand _UnCheckCommand;
        public DelegateCommand UnCheckCommand =>
            _UnCheckCommand ?? (_UnCheckCommand = new DelegateCommand(OnUnCheck));
        #endregion

        #region 构造函数
        public RFCalibrationViewModel() 
        {
            CalibrationItems.Add(new CalibrationTableItem()
            {
                DisplayName = "Source RF",
                ItemEnableScName = $"{ModuleName}.Rf.EnableCalibration",
                ItemTableScName = $"{ModuleName}.Rf.CalibrationTable",
            });
            CalibrationItems.Add(new CalibrationTableItem()
            {
                DisplayName = "Bias RF",
                ItemEnableScName = $"{ModuleName}.BiasRf.EnableCalibration",
                ItemTableScName = $"{ModuleName}.BiasRf.CalibrationTable",
            });
            
        }
        #endregion

        #region 命令方法
        public void OnCheck()
        {
            if (TableData != null && TableData.Count > 0) 
            {
                for (int i = 0; i < TableData.Count; i++)
                {
                    TableData[i].IsSelected = true;
                }
            }
            //TableData.ForEachDo(x =>
            //{
            //    x.IsSelected = true;
            //    x.InvokePropertyChanged("IsSelected");
            //});
           
        }

        public void OnUnCheck()
        {
            //if (TableData != null && TableData.Count > 0)
            //    TableData.ForEachDo(x =>
            //    {
            //        x.IsSelected = false;
            //        x.InvokePropertyChanged("IsSelected");
            //    });
            if (TableData != null && TableData.Count > 0)
            {
                for (int i = 0; i < TableData.Count; i++)
                {
                    TableData[i].IsSelected = false;
                }
            }
        }
        #endregion

        #region 私有方法
        protected void ChangeSelection(CalibrationTableItem item)
        {
            string name=item.DisplayName== "Source RF"?VenusDevice.Rf.ToString():VenusDevice.BiasRf.ToString();
            CurrentSelectionRF= rf = (AITRfData)QueryDataClient.Instance.Service.GetData($"{ModuleName}.{name}.DeviceData");
            if (rf == null) return;

            
            GeneratorSerialNumber =  QueryDataClient.Instance.Service.GetConfig($"{rf.Module}.{rf.DeviceName}.GeneratorSerialNumber")?.ToString();
            SensorSerialNumber    =  QueryDataClient.Instance.Service.GetConfig($"{rf.Module}.{rf.DeviceName}.SensorSerialNumber")?.ToString();
            double result;
            double.TryParse(QueryDataClient.Instance.Service.GetConfig($"{rf.Module}.{rf.DeviceName}.RFPhysicalMaxPower")?.ToString(),out result);
            RFPhysicalMaxPower = result;
            double.TryParse(QueryDataClient.Instance.Service.GetConfig($"{rf.Module}.{rf.DeviceName}.CurrentRFMaxPower")?.ToString(),out result);
            CurrentRFMaxPower = result;
            double.TryParse(QueryDataClient.Instance.Service.GetConfig($"{rf.Module}.{rf.DeviceName}.RFCalibratedMaxPower")?.ToString(),out result);
            RFCalibratedMaxPower = result;

            var tableValues = QueryDataClient.Instance.Service.GetConfig($"{ModuleName}{item.ItemTableDetailScName}");
            if (tableValues == null)
                return;

            var scValue = (string)tableValues;

            if (string.IsNullOrEmpty(scValue))
            {
                InitTableData(item);
                return;
            }

            try
            {
                var tableData = CustomXmlSerializer.Deserialize<List<NotifiableCalibrationTableItem>>(scValue);
                TableData = new ObservableCollection<NotifiableCalibrationTableItem>(tableData);
            }
            catch (Exception ex)
            {
                InitTableData(item);
            }


        }
        private void InitTableData(CalibrationTableItem item)
        {
            var tableData = new List<NotifiableCalibrationTableItem>();
            for (int i = 0; i < 20; i++)
            {
                tableData.Add(new NotifiableCalibrationTableItem() { DisplayName = item.DisplayName, SetPoint = (i + 1) * 100, ForwardPowerUI = (i + 1) * 100, ForwardPowerMeter = (i + 1) * 100 });
            }

            TableData = new ObservableCollection<NotifiableCalibrationTableItem>(tableData);
        }


        #endregion
    }
    public class CalibrationTableItem
    {
        public string DisplayName { get; set; }
        public string ItemTableScName { get; set; }
        public string ItemTableDetailScName
        {
            get => ItemTableScName + "Detail";
        }
        public string ItemEnableScName { get; set; }
    }
    public class NotifiableCalibrationTableItem : NotifiableItem
    {
        public string DisplayName { get; set; }

        public bool IsSelected { get; set; }

        [XmlIgnore]
        public bool IsSelectedEnable { get; set; } = true;

        public float _setPoint;
        public float SetPoint
        {
            get
            {
                return _setPoint;
            }
            set
            {
                _setPoint = value;
                InvokePropertyChanged("SetPoint");
            }
        }

        [XmlIgnore]
        public bool SetPointEnable { get; set; } = true;

        public float _forwardPowerUI;
        public float ForwardPowerUI
        {
            get
            {
                return _forwardPowerUI;
            }
            set
            {
                _forwardPowerUI = value;
                InvokePropertyChanged("ForwardPowerUI");
            }
        }

        private float _forwardPowerMeter;
        public float ForwardPowerMeter
        {
            get
            {
                return _forwardPowerMeter;
            }
            set
            {
                _forwardPowerMeter = value;
                InvokePropertyChanged("ForwardPowerMeter");
                InvokePropertyChanged("Difference");
                InvokePropertyChanged("DifferenceBackground");
            }
        }

        public float ReflectedPower { get; set; }

        public float Difference
        {
            get
            {
                if (SetPoint == 0)
                    return 0;
                return (ForwardPowerMeter - SetPoint) * 100 / SetPoint;
            }
        }

        public string DifferenceBackground
        {
            get
            {
                return Math.Abs(Difference) <= 3 ? "LightGreen" : "Red";
            }
        }
    }
}