ZZ-EFEM/Framework/AitexSorterUI/ViewModel/FAViewModelII.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Windows;
using System.Windows.Input;
using Aitex.Core.Common;
using Aitex.Core.RT.Event;
using Aitex.Core.RT.SCCore;
using Aitex.Core.UI.Dialog;
using Aitex.Core.UI.MVVM;
using Aitex.Core.UI.View.Common;
using Aitex.Core.Util;
using Aitex.Core.Utilities;
using Aitex.Sorter.Common;
using Aitex.Sorter.UI.Controls.Common;
using MECF.Framework.Common.DataCenter;
using MECF.Framework.Common.OperationCenter;
using MessageBox = Xceed.Wpf.Toolkit.MessageBox;
using PageSCValue = MECF.Framework.UI.Core.View.Common.PageSCValue;

namespace Aitex.Sorter.UI.ViewModel
{
    public class PageSCFAII : PageSCValue
    {

        public string FA_HsmsConnectionMode { get; set; }

        public string FA_HsmsLocalIP { get; set; }
        public int FA_HsmsLocalPort { get; set; }
        public string FA_HsmsRemoteIP { get; set; }
        public int FA_HsmsRemotePort { get; set; }

        public int FA_HsmsT3timeout { get; set; }
        public int FA_HsmsT5timeout { get; set; }
        public int FA_HsmsT6timeout { get; set; }
        public int FA_HsmsT7timeout { get; set; }
        public int FA_HsmsT8timeout { get; set; }
        public bool FA_EnableSpooling { get; set; }
        public int FA_FaLinkTestInterval { get; set; }
        public string FA_FaDefaultCommunicationState { get; set; }
        public string FA_FaDefaultControlState { get; set; }
        public string FA_FaDefaultControlSubState { get; set; }
        public string FA_DeviceID { get; set; }

        public PageSCFAII()
        {
            UpdateKeys(typeof(PageSCFAII).GetProperties());
        }

    }

    class FAViewModelII : UIViewModelBase
    {
        #region subscrib
        [Subscription(ParamName.IsSpoolingEnable, ChamberSetString.System)]
        public bool IsSpoolingEnable
        {
            get;
            set;
        }

        [Subscription(ParamName.SpoolingState, ChamberSetString.System)]
        public string SpoolingState
        {
            get;
            set;
        }
        [Subscription(ParamName.SpoolingActual, ChamberSetString.System)]
        public string SpoolingActual
        {
            get;
            set;
        }
        [Subscription(ParamName.SpoolingTotal, ChamberSetString.System)]
        public string SpoolingTotal
        {
            get;
            set;
        }
        [Subscription(ParamName.SpoolingFullTime, ChamberSetString.System)]
        public string SpoolingFullTime
        {
            get;
            set;
        }
        [Subscription(ParamName.SpoolingStartTime, ChamberSetString.System)]
        public string SpoolingStartTime
        {
            get;
            set;
        }

        [Subscription(ParamName.ControlStatus, ChamberSetString.System)]
        public string HostControlStatus
        {
            get;
            set;
        }

        [Subscription(ParamName.CommunicationStatus, ChamberSetString.System)]
        public string HostCommunicationStatus
        {
            get;
            set;
        }

        #endregion

        #region  logic

        public FACommunicationState FACommunicationState
        {
            get
            {
                return string.IsNullOrEmpty(HostCommunicationStatus) ? FACommunicationState.Disabled
              : (FACommunicationState)Enum.Parse(typeof(FACommunicationState), HostCommunicationStatus);
            }
        }

        public FAControlState FAControlState
        {
            get
            {
                return string.IsNullOrEmpty(HostControlStatus) ? FAControlState.Unknown
              : (FAControlState)Enum.Parse(typeof(FAControlState), HostControlStatus);
            }
        }

        //Disabled,
        //Enabled,
        //EnabledNotCommunicating,
        //EnabledCommunicating,
        //WaitCRA,
        //WaitDelay,
        //WaitCRFromHost,

        public bool IsEnableEnableButton
        {
            get { return FACommunicationState == FACommunicationState.Disabled; }
        }

        public bool IsEnableDisableButton
        {
            get { return FACommunicationState != FACommunicationState.Disabled; }
        }

        //Unknown,
        //EquipmentOffline,
        //AttemptOnline,
        //HostOffline,
        //OnlineLocal,
        //OnlineRemote,
        public bool IsEnableOnlineButton
        {
            get { return FAControlState == FAControlState.Unknown || FAControlState == FAControlState.EquipmentOffline; }
        }

        public bool IsEnableOfflineButton
        {
            get { return FAControlState == FAControlState.Unknown || FAControlState != FAControlState.EquipmentOffline; }
        }

        public bool IsEnableLocalButton
        {
            get { return FAControlState == FAControlState.OnlineRemote; }
        }

        public bool IsEnableRemoteButton
        {
            get { return FAControlState == FAControlState.OnlineLocal; }
        }

        public bool IsEnableSpoolingEnableButton
        {
            get
            {
                return !IsSpoolingEnable;//SpoolingState == FASpoolingState.Inactive.ToString();
            }
        }

        public bool IsEnableSpoolingDisableButton
        {
            get
            {
                return IsSpoolingEnable;// SpoolingState == FASpoolingState.Active.ToString();
            }
        }



        #endregion
        [IgnorePropertyChange]
        public PageSCFAII ConfigFeedback
        {
            get;
            set;
        }

        [IgnorePropertyChange]
        public PageSCFAII ConfigSetPoint
        {
            get;
            set;
        }

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

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

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

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


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

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

        public FAViewModelII() : base(nameof(FAViewModel))
        {
            ConfigFeedback = new PageSCFAII();
            ConfigSetPoint = new PageSCFAII();
            SetConfigCommand = new DelegateCommand<object>(SetConfig);
            SetConfigExCommand = new DelegateCommand<DependencyObject>(SetConfigEx);
            SetConfig2Command = new DelegateCommand<object>(SetConfig2);
            InitializeCommand = new DelegateCommand<object>(InitializeFa);
            SetHSMSCommand = new DelegateCommand<object>(SetHSMS);
            SetHSMSCommandEx = new DelegateCommand<DependencyObject>(SetHSMSEx);
            UpdateSetHSMS();
        }
        string[] keysisInt = new string[] { "HsmsLocalPort", "HsmsRemotePort", "HsmsT3timeout"
            ,"HsmsT5timeout","HsmsT6timeout","HsmsT7timeout","HsmsT8timeout" };
        private void UpdateSetHSMS()
        {
            var liststr = ConfigFeedback.GetKeys();
            Dictionary<string, object> keyValuePairs = new Dictionary<string, object>();
            foreach (var item in liststr)
            {
                object value = QueryDataClient.Instance.Service.GetData(item);
                if (value != null)
                {
                    if (keysisInt.Contains(item))
                    { keyValuePairs.Add(item, int.Parse(value.ToString())); }
                    else
                    { keyValuePairs.Add(item, value); }
                }
            }
            ConfigFeedback.Update(keyValuePairs);
            ConfigSetPoint.Update(keyValuePairs);
            InvokeAllPropertyChanged();
        }
        private void SetHSMS(object sender)
        {
            object[] sc = (object[])sender;
            InvokeClient.Instance.Service.DoOperation("FACommand", sc);
            UpdateSetHSMS();
        }
      
        private void SetHSMSEx(DependencyObject sender)
        {
            // object[] sc = (object[])obj;
            var command = CommandHelper.GetCommandItem(sender);
            var lstParameter = new List<object>(command.Parameters);
            lstParameter.Insert(0, command.CommandName);
            //  lstParameter.Insert(1, command.Parameters);
            InvokeClient.Instance.Service.DoOperation("FACommand", lstParameter.ToArray());
            UpdateSetHSMS();
        }


        private void InitializeFa(object obj)
        {
            if (MessageBox.Show("Are you sure you want to re-initialize FA connection?",
                    "Confirm", MessageBoxButton.YesNo, MessageBoxImage.Question) == MessageBoxResult.Yes)
            {
                InvokeClient.Instance.Service.DoOperation("Fa.Initialize");

            }
        }

        void SetConfig(object param)
        {
            object[] sc = (object[])param;
            if (!PerformInvokeFunctionCheck(new string[] { "Config", "Set" })) return;
            InvokeClient.Instance.Service.DoOperation("System.SetConfig", sc[0].ToString(), sc[1].ToString());
            UpdateConfig();
        }

        void SetConfigEx(DependencyObject sender)
        {
            var command = CommandHelper.GetCommandItem(sender);
            var lstParameter = new List<object>(command.Parameters);
            //lstParameter.Insert(0, command.CommandName);
            InvokeClient.Instance.Service.DoOperation("System.SetConfig", command.CommandName, (string)lstParameter[0]);
            UpdateConfig();
        }

        void SetConfig2(object param)
        {
            string id = (string)param;
            string key = id.Replace("FA.", "FA_");

            PropertyInfo[] property = typeof(PageSCFA).GetProperties();

            foreach (PropertyInfo prop in property)
            {
                if (prop.Name == key)
                {

                    InvokeClient.Instance.Service.DoOperation("System.SetConfig", id, prop.GetValue(ConfigSetPoint, null).ToString());

                    break;
                }
            }


            UpdateConfig();
        }

        public void UpdateConfig()
        {
            ConfigFeedback.Update(QueryDataClient.Instance.Service.PollConfig(ConfigFeedback.GetKeys()));
            ConfigSetPoint.Update(QueryDataClient.Instance.Service.PollConfig(ConfigSetPoint.GetKeys()));

            InvokeAllPropertyChanged();
        }

        protected override void InvokeBeforeUpdateProperty(Dictionary<string, object> data)
        {

        }
    }
}