ELK/FrameworkLocal/UIClient/CenterViews/Parameter/AlarmConditionTable.cs

using Caliburn.Micro.Core;
using RecipeEditorLib.RecipeModel.Params;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MECF.Framework.UI.Client.CenterViews.Parameter
{
    public class AlarmConditionTable : ParameterTable
    {

        private ObservableCollection<AlarmConditionHeaterTemp> _heaterTempList = new ObservableCollection<AlarmConditionHeaterTemp>();
        public ObservableCollection<AlarmConditionHeaterTemp> HeaterTempList
        {
            get => _heaterTempList;
            set
            {
                _heaterTempList = value;
                NotifyOfPropertyChange(nameof(HeaterTempList));
            }
        }

        private ObservableCollection<AlarmConditionBoatTemp> _boatTempList = new ObservableCollection<AlarmConditionBoatTemp>();
        public ObservableCollection<AlarmConditionBoatTemp> BoatTempList
        {
            get => _boatTempList;
            set
            {
                _boatTempList = value;
                NotifyOfPropertyChange(nameof(BoatTempList));
            }
        }

        private ObservableCollection<AlarmConditionMFCFlowDeviation> _mFCFlowDeviationList = new ObservableCollection<AlarmConditionMFCFlowDeviation>();
        public ObservableCollection<AlarmConditionMFCFlowDeviation> MFCFlowDeviationList
        {
            get => _mFCFlowDeviationList;
            set
            {
                _mFCFlowDeviationList = value;
                NotifyOfPropertyChange(nameof(MFCFlowDeviationList));
            }
        }

        private ObservableCollection<AlarmConditionMFCOther> _mFCOtherList = new ObservableCollection<AlarmConditionMFCOther>();
        public ObservableCollection<AlarmConditionMFCOther> MFCOtherList
        {
            get => _mFCOtherList;
            set
            {
                _mFCOtherList = value;
                NotifyOfPropertyChange(nameof(MFCOtherList));
            }
        }


        private ObservableCollection<AlarmConditionPress> _pressList = new ObservableCollection<AlarmConditionPress>();
        public ObservableCollection<AlarmConditionPress> PressList
        {
            get => _pressList;
            set
            {
                _pressList = value;
                NotifyOfPropertyChange(nameof(PressList));
            }
        }

        private ObservableCollection<AlarmConditionAUX> _aUXList = new ObservableCollection<AlarmConditionAUX>();
        public ObservableCollection<AlarmConditionAUX> AUXList
        {
            get => _aUXList;
            set
            {
                _aUXList = value;
                NotifyOfPropertyChange(nameof(AUXList));
            }
        }

        private ObservableCollection<AlarmConditionHWILK> _hWILKList = new ObservableCollection<AlarmConditionHWILK>();
        public ObservableCollection<AlarmConditionHWILK> HWILKList
        {
            get => _hWILKList;
            set
            {
                _hWILKList = value;
                NotifyOfPropertyChange(nameof(HWILKList));
            }
        }


        private ObservableCollection<AlarmConditionValveILK> _valveIlkList = new ObservableCollection<AlarmConditionValveILK>();

        public ObservableCollection<AlarmConditionValveILK> ValveIlkList
        {
            get => _valveIlkList;
            set
            {
                _valveIlkList = value;
                NotifyOfPropertyChange(nameof(ValveIlkList));
            }
        }

        private ObservableCollection<AlarmConditionTempControler> _tempControlerList = new ObservableCollection<AlarmConditionTempControler>();

        public ObservableCollection<AlarmConditionTempControler> TempControlerList
        {
            get => _tempControlerList;
            set
            {
                _tempControlerList = value;
                NotifyOfPropertyChange(nameof(TempControlerList));
            }
        }

        private ObservableCollection<AlarmConditionAPCControler> _apcControlerList = new ObservableCollection<AlarmConditionAPCControler>();

        public ObservableCollection<AlarmConditionAPCControler> APCControlerList
        {
            get => _apcControlerList;
            set
            {
                _apcControlerList = value;
                NotifyOfPropertyChange(nameof(APCControlerList));
            }
        }

        private ObservableCollection<AlarmConditionTransferError> _transferErrorList = new ObservableCollection<AlarmConditionTransferError>();

        public ObservableCollection<AlarmConditionTransferError> TransferErrorList
        {
            get => _transferErrorList;
            set
            {
                _transferErrorList = value;
                NotifyOfPropertyChange(nameof(TransferErrorList));
            }
        }

        private ObservableCollection<AlarmConditionSerialLineDown> _serialLineDownList = new ObservableCollection<AlarmConditionSerialLineDown>();
        public ObservableCollection<AlarmConditionSerialLineDown> SerialLineDownList
        {
            get => _serialLineDownList;
            set
            {
                _serialLineDownList = value;
                NotifyOfPropertyChange(nameof(SerialLineDownList));
            }
        }

        private ObservableCollection<AlarmConditionLanLineDown> _lanLineDownList = new ObservableCollection<AlarmConditionLanLineDown>();
        public ObservableCollection<AlarmConditionLanLineDown> LanLineDownList
        {
            get => _lanLineDownList;
            set
            {
                _lanLineDownList = value;
                NotifyOfPropertyChange(nameof(LanLineDownList));
            }
        }

        private ObservableCollection<AlarmConditionDeviceNetLineDown> _deviceNetLineDownList = new ObservableCollection<AlarmConditionDeviceNetLineDown>();
        public ObservableCollection<AlarmConditionDeviceNetLineDown> DeviceNetLineDownList
        {
            get => _deviceNetLineDownList;
            set
            {
                _deviceNetLineDownList = value;
                NotifyOfPropertyChange(nameof(DeviceNetLineDownList));
            }
        }

        private ObservableCollection<AlarmConditionSensor> _sensorList = new ObservableCollection<AlarmConditionSensor>();
        public ObservableCollection<AlarmConditionSensor> SensorList
        {
            get => _sensorList;
            set
            {
                _sensorList = value;
                NotifyOfPropertyChange(nameof(SensorList));
            }
        }

        private ObservableCollection<AlarmConditionOther> _otherList = new ObservableCollection<AlarmConditionOther>();
        public ObservableCollection<AlarmConditionOther> OtherList
        {
            get => _otherList;
            set
            {
                _otherList = value;
                NotifyOfPropertyChange(nameof(OtherList));
            }
        }

        public AlarmConditionTable() : base()
        {
        }

        public void SetHeaterTempData(string value)
        {
            if (string.IsNullOrEmpty(value)) return;
            string[] strHeaterTemp = value.Split('|');
            foreach (var item in strHeaterTemp)
            {
                if (string.IsNullOrEmpty(item)) continue;
                string[] subHeaterTemp = item.Split(';');
                var selectHeaterTemp = HeaterTempList.Where(x => x.ZoneName == subHeaterTemp[0]).FirstOrDefault();
                if (selectHeaterTemp != null)
                {
                    selectHeaterTemp.SetStringValue(item);
                }
            }
        }


        public void SetBoatTempData(string value)
        {
            if (string.IsNullOrEmpty(value)) return;
            string[] strBoatTemp = value.Split('|');
            foreach (var item in strBoatTemp)
            {
                if (string.IsNullOrEmpty(item)) continue;
                string[] subBoatTemp = item.Split(',');
                var selectBoatTemp = BoatTempList.Where(x => x.BoatMotion == subBoatTemp[0]).FirstOrDefault();
                if (selectBoatTemp != null)
                {
                    selectBoatTemp.SetStringValue(item);
                }
            }
        }


        public void SetMFCFlowDeviationData(string value)
        {
            if (string.IsNullOrEmpty(value)) return;
            string[] strFlowDeviation = value.Split('|');
            foreach (var item in strFlowDeviation)
            {
                if (string.IsNullOrEmpty(item)) continue;
                string[] subFlowDeviation = item.Split(';');
                var selectFlowDeviation = MFCFlowDeviationList.Where(x => x.MFCName == subFlowDeviation[1]).FirstOrDefault();
                if (selectFlowDeviation != null)
                {
                    selectFlowDeviation.SetStringValue(item);
                }
            }
        }


        public void SetPressData(string value)
        {
            if (string.IsNullOrEmpty(value)) return;
            string[] strPress = value.Split('|');
            int indexNo = 1;
            foreach (var item in strPress)
            {
                if (string.IsNullOrEmpty(item)) continue;
                string[] subPress = item.Split(';');
                AlarmConditionPress selectPress = null;
                if (subPress[0] == "0")
                {
                    selectPress = PressList.Where(x => x.Index == indexNo).FirstOrDefault();
                }
                else
                {
                    selectPress = PressList.Where(x => x.Index.ToString() == subPress[0]).FirstOrDefault();
                }
                indexNo++;
                if (selectPress != null)
                {
                    selectPress.SetStringValue(item);
                }
            }
        }


        public void SetAUXData(string value)
        {
            if (string.IsNullOrEmpty(value)) return;
            string[] strAUX = value.Split('|');
            foreach (var item in strAUX)
            {
                if (string.IsNullOrEmpty(item)) continue;
                string[] subAUX = item.Split(';');
                var selectAUX = AUXList.Where(x => x.Index.ToString() == subAUX[0]).FirstOrDefault();
                if (selectAUX != null)
                {
                    selectAUX.SetStringValue(item);
                }
            }
        }


        public void SetHWILKData(string value)
        {
            if (string.IsNullOrEmpty(value)) return;
            string[] strHWILK = value.Split('|');
            foreach (var item in strHWILK)
            {
                if (string.IsNullOrEmpty(item)) continue;
                string[] subHWILK = item.Split(',');
                var selectHWILK = HWILKList.Where(x => x.InterLockName == subHWILK[1]).FirstOrDefault();
                if (selectHWILK != null)
                {
                    selectHWILK.SetStringValue(item);
                }
            }
        }

        public void SetValveIlkData(string value)
        {
            if (string.IsNullOrEmpty(value)) return;
            string[] strValveIlk = value.Split('|');
            foreach (var item in strValveIlk)
            {
                if (string.IsNullOrEmpty(item)) continue;
                string[] subValveIlk = item.Split(',');
                var selectValveIlk = ValveIlkList.Where(x => x.InterLockName == subValveIlk[1]).FirstOrDefault();
                if (selectValveIlk != null)
                {
                    selectValveIlk.SetStringValue(item);
                }
            }
        }

        public void SetTempControlerData(string value)
        {
            if (string.IsNullOrEmpty(value)) return;
            string[] strTempControler = value.Split('|');
            foreach (var item in strTempControler)
            {
                if (string.IsNullOrEmpty(item)) continue;
                string[] subTempControler = item.Split(',');
                var selectTempControler = TempControlerList.Where(x => x.InterLockName == subTempControler[1]).FirstOrDefault();
                if (selectTempControler != null)
                {
                    selectTempControler.SetStringValue(item);
                }
            }
        }

        public void SetAPCControlerData(string value)
        {
            if (string.IsNullOrEmpty(value)) return;
            string[] strAPCControler = value.Split('|');
            foreach (var item in strAPCControler)
            {
                if (string.IsNullOrEmpty(item)) continue;
                string[] subAPCControler = item.Split(',');
                var selectAPCControler = APCControlerList.Where(x => x.InterLockName == subAPCControler[1]).FirstOrDefault();
                if (selectAPCControler != null)
                {
                    selectAPCControler.SetStringValue(item);
                }
            }
        }

        public void SetTransferErrorData(string value)
        {
            if (string.IsNullOrEmpty(value)) return;
            string[] strTransferError = value.Split('|');
            foreach (var item in strTransferError)
            {
                if (string.IsNullOrEmpty(item)) continue;
                string[] subTransferError = item.Split(',');
                var selectTransferError = TransferErrorList.Where(x => x.InterLockName == subTransferError[1]).FirstOrDefault();
                if (selectTransferError != null)
                {
                    selectTransferError.SetStringValue(item);
                }
            }
        }

        public void SetSerialLineDownData(string value)
        {
            if (string.IsNullOrEmpty(value)) return;
            string[] strSerialLineDown = value.Split('|');
            foreach (var item in strSerialLineDown)
            {
                if (string.IsNullOrEmpty(item)) continue;
                string[] subSerialLineDown = item.Split(',');
                var selectSerialLineDown = SerialLineDownList.FirstOrDefault(x => x.InterLockName == subSerialLineDown[1]);
                if (selectSerialLineDown != null)
                {
                    selectSerialLineDown.SetStringValue(item);
                }
            }
        }

        public void SetLanLineDownData(string value)
        {
            if (string.IsNullOrEmpty(value)) return;
            string[] strSerialLineDown = value.Split('|');
            foreach (var item in strSerialLineDown)
            {
                if (string.IsNullOrEmpty(item)) continue;
                string[] subSerialLineDown = item.Split(',');
                var selectSerialLineDown = LanLineDownList.FirstOrDefault(x => x.InterLockName == subSerialLineDown[1]);
                if (selectSerialLineDown != null)
                {
                    selectSerialLineDown.SetStringValue(item);
                }
            }
        }

        public void SetDeviceNetLineDownData(string value)
        {
            if (string.IsNullOrEmpty(value)) return;
            string[] strDeviceNetLineDown = value.Split('|');
            foreach (var item in strDeviceNetLineDown)
            {
                if (string.IsNullOrEmpty(item)) continue;
                string[] subDeviceNetLineDown = item.Split(',');
                var selectDeviceNetLineDown = DeviceNetLineDownList.FirstOrDefault(x => x.InterLockName == subDeviceNetLineDown[1]);
                if (selectDeviceNetLineDown != null)
                {
                    selectDeviceNetLineDown.SetStringValue(item);
                }
            }
        }

        public void SetSensorData(string value)
        {
            if (string.IsNullOrEmpty(value)) return;
            string[] strSensor = value.Split('|');
            foreach (var item in strSensor)
            {
                if (string.IsNullOrEmpty(item)) continue;
                string[] subSensor = item.Split(',');
                var selectSensor = SensorList.Where(x => x.SensorName == subSensor[1]).FirstOrDefault();
                if (selectSensor != null)
                {
                    selectSensor.SetStringValue(item);
                }
            }
        }

        public void SetOtherData(string value)
        {
            if (string.IsNullOrEmpty(value)) return;
            string[] strOther = value.Split('|');
            foreach (var item in strOther)
            {
                if (string.IsNullOrEmpty(item)) continue;
                string[] subOther = item.Split(',');
                var selectOther = OtherList.Where(x => x.InterLockName == subOther[1]).FirstOrDefault();
                if (selectOther != null)
                {
                    selectOther.SetStringValue(item);
                }
            }
        }

    }

    public class AlarmConditionDataBase : PropertyChangedBase
    {
        private int _index;
        public int Index
        {
            get => _index;
            set
            {
                _index = value;
                NotifyOfPropertyChange(nameof(Index));
            }
        }

        private string _interLockName;

        public string InterLockName
        {
            get => _interLockName;
            set
            {
                _interLockName = value;
                NotifyOfPropertyChange(nameof(InterLockName));
            }
        }

        private CheckType _type;

        public CheckType Type
        {
            get => _type;
            set
            {
                _type = value;
                NotifyOfPropertyChange(nameof(Type));
            }
        }

        private bool _isCheck;

        public bool IsCheck
        {
            get => _isCheck;
            set
            {
                _isCheck = value;
                NotifyOfPropertyChange(nameof(IsCheck));
            }
        }

        private string _errorCommand;

        public string ErrorCommand
        {
            get => _errorCommand;
            set
            {
                _errorCommand = value;
                NotifyOfPropertyChange(nameof(ErrorCommand));
            }
        }

        public override string ToString()
        {
            List<string> rtnList = new List<string>();
            rtnList.Add(Index.ToString());
            rtnList.Add(InterLockName);
            rtnList.Add(Type.ToString());
            rtnList.Add(IsCheck.ToString());
            rtnList.Add(ErrorCommand);
            return string.Join(",", rtnList.ToArray());
        }

        public virtual bool SetStringValue(string value)
        {
            return true;
        }
    }


    public class AlarmConditionHeaterTemp : PropertyChangedBase
    {
        private string _zoneName;

        public string ZoneName
        {
            get => _zoneName;
            set
            {
                _zoneName = value;
                NotifyOfPropertyChange(nameof(ZoneName));
            }
        }

        private TempData _alertTempData;
        public TempData AlertTempData
        {
            get => _alertTempData;
            set
            {
                _alertTempData = value;
                NotifyOfPropertyChange(nameof(AlertTempData));
            }
        }

        private TempData _alarmTempData;
        public TempData AlarmTempData
        {
            get => _alarmTempData;
            set
            {
                _alarmTempData = value;
                NotifyOfPropertyChange(nameof(AlarmTempData));
            }
        }

        public override string ToString()
        {
            return $"{ZoneName};{AlertTempData.ToString()};{AlarmTempData.ToString()}";
        }

        public bool SetStringValue(string value)
        {
            if (string.IsNullOrEmpty(value) || value.Split(';').Length != 3) return false;
            var list = value.Split(';');
            AlertTempData.SetStringValue(list[1]);
            AlarmTempData.SetStringValue(list[2]);
            return true;
        }
    }

    public class AlarmConditionBoatTemp : PropertyChangedBase
    {
        private string _boatMotion;
        public string BoatMotion
        {
            get => _boatMotion;
            set
            {
                _boatMotion = value;
                NotifyOfPropertyChange(nameof(BoatMotion));
            }
        }

        private CheckType _type = CheckType.Alarm;

        public CheckType Type
        {
            get => _type;
            set
            {
                _type = value;
                NotifyOfPropertyChange(nameof(Type));
            }
        }


        private bool _isCheck = false;

        public bool IsCheck
        {
            get => _isCheck;
            set
            {
                _isCheck = value;
                NotifyOfPropertyChange(nameof(IsCheck));
            }
        }

        private DoubleParam _highLimit;

        public DoubleParam HighLimit
        {
            get => _highLimit;
            set
            {
                _highLimit = value;
                NotifyOfPropertyChange(nameof(HighLimit));
            }
        }

        private string _unit;

        public string Unit
        {
            get => _unit;
            set
            {
                _unit = value;
                NotifyOfPropertyChange(nameof(Unit));
            }
        }

        public override string ToString()
        {
            List<string> rtnList = new List<string>();
            rtnList.Add(BoatMotion);
            rtnList.Add(Type.ToString());
            rtnList.Add(IsCheck.ToString());
            if (HighLimit == null)
            {
                rtnList.Add("");
            }
            else
            {
                rtnList.Add(HighLimit.Value);
            }
            rtnList.Add(Unit);
            return string.Join(",", rtnList.ToArray());
        }

        public bool SetStringValue(string value)
        {
            if (string.IsNullOrEmpty(value)) return false;
            if (!value.Contains(",") || value.Split(',').Length != 5) return false;
            var strArray = value.Split(',');
            BoatMotion = strArray[0];
            Type = (CheckType)Enum.Parse(typeof(CheckType), strArray[1]);
            IsCheck = bool.Parse(strArray[2]);
            if (HighLimit != null)
            {
                HighLimit.Value = strArray[3];
            }
            Unit = strArray[4];
            return true;
        }
    }

    public class AlarmConditionMFCDeviation : PropertyChangedBase
    {
        private int _index;

        public int Index
        {
            get => _index;
            set
            {
                _index = value;
                NotifyOfPropertyChange(nameof(Index));
            }
        }

        private string _mFCName;

        public string MFCName
        {
            get => _mFCName;
            set
            {
                _mFCName = value;
                NotifyOfPropertyChange(nameof(MFCName));
            }
        }

        private TempData _alertTempData;
        public TempData AlertTempData
        {
            get => _alertTempData;
            set
            {
                _alertTempData = value;
                NotifyOfPropertyChange(nameof(AlertTempData));
            }
        }

        private TempData _alarmTempData;
        public TempData AlarmTempData
        {
            get => _alarmTempData;
            set
            {
                _alarmTempData = value;
                NotifyOfPropertyChange(nameof(AlarmTempData));
            }
        }

        public override string ToString()
        {
            string[] strArray = new string[]
                {
                    Index.ToString(),
                    MFCName,
                    AlertTempData.ToString(),
                    AlarmTempData.ToString()
                };
            return string.Join(";", strArray);
        }

        public bool SetStringValue(string value)
        {
            if (string.IsNullOrEmpty(value) || value.Split(';').Length != 4) return false;
            var list = value.Split(';');
            Index = Convert.ToInt32(list[0]);
            MFCName = list[1];
            AlertTempData.SetStringValue(list[2]);
            AlarmTempData.SetStringValue(list[3]);
            return true;
        }
    }

    public class AlarmConditionMFCFlowDeviation : AlarmConditionMFCDeviation
    {
    }

    public class AlarmConditionMFCOther : AlarmConditionMFCDeviation
    { }


    public class AlarmConditionPress : PropertyChangedBase
    {
        private int _index;

        public int Index
        {
            get => _index;
            set
            {
                _index = value;
                NotifyOfPropertyChange(nameof(Index));
            }
        }

        private string _pressKindName;

        public string PressKindName
        {
            get => _pressKindName;
            set
            {
                _pressKindName = value;
                NotifyOfPropertyChange(nameof(PressKindName));
            }
        }

        private TempData _alertTempData;
        public TempData AlertTempData
        {
            get => _alertTempData;
            set
            {
                _alertTempData = value;
                NotifyOfPropertyChange(nameof(AlertTempData));
            }
        }

        private TempData _alarmTempData;
        public TempData AlarmTempData
        {
            get => _alarmTempData;
            set
            {
                _alarmTempData = value;
                NotifyOfPropertyChange(nameof(AlarmTempData));
            }
        }

        public override string ToString()
        {
            string[] strArray = new string[]
                {
                    Index.ToString(),
                    PressKindName,
                    AlertTempData.ToString(),
                    AlarmTempData.ToString()
                };
            return string.Join(";", strArray);
        }

        public bool SetStringValue(string value)
        {
            if (string.IsNullOrEmpty(value) || value.Split(';').Length != 4) return false;
            var list = value.Split(';');
            Index = Convert.ToInt32(list[0]);
            PressKindName = list[1];
            AlertTempData.SetStringValue(list[2]);
            AlarmTempData.SetStringValue(list[3]);
            return true;
        }
    }

    public class AlarmConditionAUX : PropertyChangedBase
    {
        private int _index;
        public int Index
        {
            get => _index;
            set
            {
                _index = value;
                NotifyOfPropertyChange(nameof(Index));
            }
        }

        private string _aUXName;

        public string AUXName
        {
            get => _aUXName;
            set
            {
                _aUXName = value;
                NotifyOfPropertyChange(nameof(AUXName));
            }
        }

        private TempData _alertTempData;
        public TempData AlertTempData
        {
            get => _alertTempData;
            set
            {
                _alertTempData = value;
                NotifyOfPropertyChange(nameof(AlertTempData));
            }
        }

        private TempData _alarmTempData;
        public TempData AlarmTempData
        {
            get => _alarmTempData;
            set
            {
                _alarmTempData = value;
                NotifyOfPropertyChange(nameof(AlarmTempData));
            }
        }

        public override string ToString()
        {
            string[] strArray = new string[]
                {
                    Index.ToString(),
                    AUXName,
                    AlertTempData.ToString(),
                    AlarmTempData.ToString()
                };
            return string.Join(";", strArray);
        }

        public bool SetStringValue(string value)
        {
            if (string.IsNullOrEmpty(value) || value.Split(';').Length != 4) return false;
            var list = value.Split(';');
            Index = Convert.ToInt32(list[0]);
            AUXName = list[1];
            AlertTempData.SetStringValue(list[2]);
            AlarmTempData.SetStringValue(list[3]);
            return true;
        }
    }

    public class AlarmConditionHWILK : PropertyChangedBase
    {
        private int _index;
        public int Index
        {
            get => _index;
            set
            {
                _index = value;
                NotifyOfPropertyChange(nameof(Index));
            }
        }

        private string _interLockName;

        public string InterLockName
        {
            get => _interLockName;
            set
            {
                _interLockName = value;
                NotifyOfPropertyChange(nameof(InterLockName));
            }
        }

        private CheckType _type;

        public CheckType Type
        {
            get => _type;
            set
            {
                _type = value;
                NotifyOfPropertyChange(nameof(Type));
            }
        }

        private bool _isCheck;

        public bool IsCheck
        {
            get => _isCheck;
            set
            {
                _isCheck = value;
                NotifyOfPropertyChange(nameof(IsCheck));
            }
        }

        private string _errorCommand;

        public string ErrorCommand
        {
            get => _errorCommand;
            set
            {
                _errorCommand = value;
                NotifyOfPropertyChange(nameof(ErrorCommand));
            }
        }

        public override string ToString()
        {
            List<string> rtnList = new List<string>();
            rtnList.Add(Index.ToString());
            rtnList.Add(InterLockName);
            rtnList.Add(Type.ToString());
            rtnList.Add(IsCheck.ToString());
            rtnList.Add(ErrorCommand);
            return string.Join(",", rtnList.ToArray());
        }

        public bool SetStringValue(string value)
        {
            if (string.IsNullOrEmpty(value)) return false;
            if (!value.Contains(",") || value.Split(',').Length != 5) return false;
            var strArray = value.Split(',');
            Index = Convert.ToInt32(strArray[0]);
            InterLockName = strArray[1];
            Type = (CheckType)Enum.Parse(typeof(CheckType), strArray[2]);
            IsCheck = bool.Parse(strArray[3]);
            ErrorCommand = strArray[4];
            return true;
        }
    }

    public class AlarmConditionHardSoft : PropertyChangedBase
    {
        private int _index;
        public int Index
        {
            get => _index;
            set
            {
                _index = value;
                NotifyOfPropertyChange(nameof(Index));
            }
        }

        private string _interLockName;

        public string InterLockName
        {
            get => _interLockName;
            set
            {
                _interLockName = value;
                NotifyOfPropertyChange(nameof(InterLockName));
            }
        }

        private CheckType _type;

        public CheckType Type
        {
            get => _type;
            set
            {
                _type = value;
                NotifyOfPropertyChange(nameof(Type));
            }
        }

        private bool _isCheck;

        public bool IsCheck
        {
            get => _isCheck;
            set
            {
                _isCheck = value;
                NotifyOfPropertyChange(nameof(IsCheck));
            }
        }

        private string _errorCommand;

        public string ErrorCommand
        {
            get => _errorCommand;
            set
            {
                _errorCommand = value;
                NotifyOfPropertyChange(nameof(ErrorCommand));
            }
        }

        public override string ToString()
        {
            List<string> rtnList = new List<string>();
            rtnList.Add(Index.ToString());
            rtnList.Add(InterLockName);
            rtnList.Add(Type.ToString());
            rtnList.Add(IsCheck.ToString());
            rtnList.Add(ErrorCommand);
            return string.Join(",", rtnList.ToArray());
        }

        public bool SetStringValue(string value)
        {
            if (string.IsNullOrEmpty(value)) return false;
            if (!value.Contains(",") || value.Split(',').Length != 5) return false;
            var strArray = value.Split(',');
            Index = Convert.ToInt32(strArray[0]);
            InterLockName = strArray[1];
            Type = (CheckType)Enum.Parse(typeof(CheckType), strArray[2]);
            IsCheck = bool.Parse(strArray[3]);
            ErrorCommand = strArray[4];
            return true;
        }
    }

    public class AlarmConditionValveILK : AlarmConditionHardSoft
    {
    }

    public class AlarmConditionTempControler : AlarmConditionHardSoft
    {
    }

    public class AlarmConditionAPCControler : AlarmConditionHardSoft
    {
    }

    public class AlarmConditionTransferError : AlarmConditionHardSoft
    {
    }

    public class AlarmConditionSerialLineDown : AlarmConditionDataBase
    {
        public override bool SetStringValue(string value)
        {
            if (string.IsNullOrEmpty(value)) return false;
            if (!value.Contains(",") || value.Split(',').Length != 5) return false;
            var strArray = value.Split(',');
            Index = Convert.ToInt32(strArray[0]);
            InterLockName = strArray[1];
            Type = (CheckType)Enum.Parse(typeof(CheckType), strArray[2]);
            IsCheck = bool.Parse(strArray[3]);
            ErrorCommand = strArray[4];
            return true;
        }
    }

    public class AlarmConditionLanLineDown : AlarmConditionDataBase
    {
        public override bool SetStringValue(string value)
        {
            if (string.IsNullOrEmpty(value)) return false;
            if (!value.Contains(",") || value.Split(',').Length != 5) return false;
            var strArray = value.Split(',');
            Index = Convert.ToInt32(strArray[0]);
            InterLockName = strArray[1];
            Type = (CheckType)Enum.Parse(typeof(CheckType), strArray[2]);
            IsCheck = bool.Parse(strArray[3]);
            ErrorCommand = strArray[4];
            return true;
        }
    }

    public class AlarmConditionDeviceNetLineDown : AlarmConditionDataBase
    {
        public override bool SetStringValue(string value)
        {
            if (string.IsNullOrEmpty(value)) return false;
            if (!value.Contains(",") || value.Split(',').Length != 5) return false;
            var strArray = value.Split(',');
            Index = Convert.ToInt32(strArray[0]);
            InterLockName = strArray[1];
            Type = (CheckType)Enum.Parse(typeof(CheckType), strArray[2]);
            IsCheck = bool.Parse(strArray[3]);
            ErrorCommand = strArray[4];
            return true;
        }
    }

    public class AlarmConditionSensor : PropertyChangedBase
    {
        private int _index;

        public int Index
        {
            get => _index;
            set
            {
                _index = value;
                NotifyOfPropertyChange(nameof(Index));
            }
        }

        private string _sensorName;

        public string SensorName
        {
            get => _sensorName;
            set
            {
                _sensorName = value;
                NotifyOfPropertyChange(nameof(SensorName));
            }
        }

        private TempData _alertTempData;
        public TempData AlertTempData
        {
            get => _alertTempData;
            set
            {
                _alertTempData = value;
                NotifyOfPropertyChange(nameof(AlertTempData));
            }
        }

        private TempData _alarmTempData;
        public TempData AlarmTempData
        {
            get => _alarmTempData;
            set
            {
                _alarmTempData = value;
                NotifyOfPropertyChange(nameof(AlarmTempData));
            }
        }

        public override string ToString()
        {
            string[] strArray = new string[]
                {
                    Index.ToString(),
                    SensorName,
                    AlertTempData.ToString(),
                    AlarmTempData.ToString()
                };
            return string.Join(";", strArray);
        }

        public bool SetStringValue(string value)
        {
            if (string.IsNullOrEmpty(value) || value.Split(';').Length != 4) return false;
            var list = value.Split(';');
            Index = Convert.ToInt32(list[0]);
            SensorName = list[1];
            AlertTempData.SetStringValue(list[2]);
            AlarmTempData.SetStringValue(list[3]);
            return true;
        }
    }

    public class AlarmConditionOther : AlarmConditionDataBase
    {
        public override bool SetStringValue(string value)
        {
            if (string.IsNullOrEmpty(value)) return false;
            if (!value.Contains(",") || value.Split(',').Length != 5) return false;
            var strArray = value.Split(',');
            Index = Convert.ToInt32(strArray[0]);
            InterLockName = strArray[1];
            Type = (CheckType)Enum.Parse(typeof(CheckType), strArray[2]);
            IsCheck = bool.Parse(strArray[3]);
            ErrorCommand = strArray[4];
            return true;
        }
    }


    public class TempData : PropertyChangedBase
    {
        private CheckType _type;

        public CheckType Type
        {
            get => _type;
            set
            {
                _type = value;
                NotifyOfPropertyChange(nameof(Type));
            }
        }

        private bool _isCheck;

        public bool IsCheck
        {
            get => _isCheck;
            set
            {
                _isCheck = value;
                NotifyOfPropertyChange(nameof(IsCheck));
            }
        }

        private DoubleParam _devHigh;

        public DoubleParam DevHigh
        {
            get => _devHigh;
            set
            {
                _devHigh = value;
                NotifyOfPropertyChange(nameof(DevHigh));
            }
        }


        private DoubleParam _devLow;

        public DoubleParam DevLow
        {
            get => _devLow;
            set
            {
                _devLow = value;
                NotifyOfPropertyChange(nameof(DevLow));
            }
        }

        private string _unit;

        public string Unit
        {
            get => _unit;
            set
            {
                _unit = value;
                NotifyOfPropertyChange(nameof(Unit));
            }
        }

        private DoubleParam _delayTime;

        public DoubleParam DelayTime
        {
            get => _delayTime;
            set
            {
                _delayTime = value;
                NotifyOfPropertyChange(nameof(_delayTime));
            }
        }

        private DoubleParam _time;

        public DoubleParam Time
        {
            get => _time;
            set
            {
                _time = value;
                NotifyOfPropertyChange(nameof(Time));
            }
        }

        private string _errorCommand;

        public string ErrorCommand
        {
            get => _errorCommand;
            set
            {
                _errorCommand = value;
                NotifyOfPropertyChange(nameof(ErrorCommand));
            }
        }

        public override string ToString()
        {
            string[] rtnString = new string[]
                {
                Type.ToString(),
                IsCheck.ToString(),
                DevHigh.Value,
                DevLow.Value,
                Unit,
                Time.Value,
                ErrorCommand,
                DelayTime.Value,
                };
            return string.Join(",", rtnString);
        }

        public bool SetStringValue(string value)
        {
            if (string.IsNullOrEmpty(value)) return false;
            string[] listStr = value.Split(',');
            if (listStr.Length == 7 || listStr.Length == 8)
            {
                IsCheck = Convert.ToBoolean(listStr[1]);
                DevHigh.Value = listStr[2];
                DevLow.Value = listStr[3];
                Unit = listStr[4];
                float time = 0;
                float.TryParse(listStr[5], out time);
                Time.Value = time.ToString("f1");
                ErrorCommand = listStr[6];
                if (listStr.Length == 8)
                {
                    float delayTime = 0;
                    float.TryParse(listStr[7], out delayTime);
                    DelayTime.Value = delayTime.ToString("f1");
                }
            }
            return true;
        }
    }



    public enum CheckType
    {
        Alert,
        Alarm
    }




}