ZZ-EFEM/Jet/Jet_001_2P_Jet/EfemUI/ViewModels/TopViewModel2.cs

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Windows;
using Aitex.Core.Common.DeviceData;
using Aitex.Core.UI.MVVM;
using System.Windows.Input;
using System.Windows.Media;
using Aitex.Core.RT.Event;
using Aitex.Core.UI.Control;
using Aitex.Core.UI.Dialog;
using Aitex.Core.Util;
using Aitex.Core.WCF;
using Aitex.Sorter.Common;
using Aitex.Sorter.UI.ViewModel;
using Hardcodet.Wpf.TaskbarNotification;
using MECF.Framework.Common.OperationCenter;
using MECF.Framework.UI.Core.Accounts;
using MECF.Framework.UI.Core.Applications;
using Aitex.Core.RT.OperationCenter;

namespace Sorter.UI.ViewModel
{

	public class TopViewModel2 : UIViewModelBase
	{

		public string SoftwareVersion
		{
			get;
			set;
		}
 

        [Subscription(ParamName.RTStatus, SystemStateModule)]
		public int RoutManagerState
		{
			get;
			set;
		}
		public string SystemStatus
		{
			get { return ((RtState)RoutManagerState).ToString(); }
		}
	    public string SystemStatusBackground
	    {
	        get
	        {
	            switch (RoutManagerState)
	            {
	                case (int)RtState.Init:
	                    return "Yellow";
	                case (int)RtState.Initializing:
	                case (int)RtState.ManualTransfer:
	                case (int)RtState.Transfer:
	                case (int)RtState.Cycle:
	                case (int)RtState.PrepareCycle:
	                case (int)RtState.PostCycle:
	                case (int)RtState.Reset:
	                case (int)RtState.Processing:
	                case (int)RtState.PostProcess:
	                case (int)RtState.PauseProcess:
	                case (int)RtState.SetSpeed:
	                    return "LawnGreen";
	                case (int)RtState.Error:
	                case (int)RtState.Maintenance:
	                    return "Red";
	                case (int)RtState.Idle:
	                    return "Transparent";
	                default:
	                    return "Goldenrod";

	            }
	        }
	    }

 
        [Subscription("Status", "LP1")]
	    public string LoadPort1Status
        {
	        get;
	        set;
	    }

	    public string LoadPort1StatusBackground
	    {
	        get { return GetUnitStatusBackground(LoadPort1Status); }
	    }

	    [Subscription("Status", "LP2")]
	    public string LoadPort2Status
        {
	        get;
	        set;
	    }
	    public string LoadPort2StatusBackground
	    {
	        get { return GetUnitStatusBackground(LoadPort2Status); }
	    }

        [Subscription("LoadportState", "LP3")]
        public string LoadPort3Status
        {
            get;
            set;
        }
        public string LoadPort3StatusBackground
        {
            get { return GetUnitStatusBackground(LoadPort3Status); }
        }

        [Subscription("LoadportState", "LP4")]
        public string LoadPort4Status
        {
            get;
            set;
        }
        public string LoadPort4StatusBackground
        {
            get { return GetUnitStatusBackground(LoadPort4Status); }
        }
        
        [Subscription("Robot.State")]
	    public string RobotStatus
	    {
	        get;
	        set;
	    }
	    public string RobotStatusBackground
        {
	        get { return GetUnitStatusBackground(RobotStatus); }
	    }

        [Subscription("System.SignalTower.DeviceData")]
		public AITSignalTowerData SignalTower
		{
			get;
			set;
		}

		[Subscription("System.IsOnlineMode")]
		public bool IsOnlineMode { get; set; }

	    public string OnlineStatus
	    {
	        get { return IsOnlineMode ? "Online" : "Offline"; }
	    }

	    private bool _simulatorMode = false;

	    [Subscription("System.ServerStatus")]
	    public string ServerStatus
	    {
	        get; set; 

	    }

		public R_TRIG _trig = new R_TRIG();
		public bool _clearEventLogEnable;
		[Subscription("System.ClearEventLogEnable")]
		public bool ClearEventLogEnable
		{     
			get;
			set;
			//get
   //         {
			//	return _clearEventLogEnable;
			//}
			//set 
			//{
			//	_clearEventLogEnable = value;
			//	if (value)
			//	{
			//		_trig.CLK = value;
			//		if (_trig.Q)
			//			EventLogList.Clear();
			//	}
			//	else
			//	{
			//		_trig.RST = true;
			//	}
			//}
		}
			
	    [Subscription("CoolingBuffer1.CoolingBuffer1.Status")]
		public string CoolingBuffer1Status
		{
			get; set;

		}
		public string _CoolingBuffer1Status => CoolingBuffer1Status=="Disable"?"": CoolingBuffer1Status;
		public string CoolingBuffer1Background
		{
			get { return GetUnitStatusBackground(CoolingBuffer1Status); }
		}

		[Subscription("CoolingBuffer2.CoolingBuffer2.Status")]
		public string CoolingBuffer2Status
		{
			get; set;

		}
		public string _CoolingBuffer2Status => CoolingBuffer2Status == "Disable" ? "" : CoolingBuffer2Status;
		public string CoolingBuffer2Background
		{
			get { return GetUnitStatusBackground(CoolingBuffer2Status); }
		}
		[Subscription("Aligner1.Aligner1.Status")]
		public string Aligner1Status
		{
			get; set;

		}
		public string _Aligner1Status => Aligner1Status == "Disable" ? "" : Aligner1Status;
		public string Aligner1Background
		{
			get { return GetUnitStatusBackground(Aligner1Status); }
		}
		[Subscription("Aligner2.Aligner2.Status")]
		public string Aligner2Status
		{
			get; set;

		}
		public string _Aligner2Status => Aligner2Status == "Disable" ? "" : Aligner2Status;
		public string Aligner2Background
		{
			get { return GetUnitStatusBackground(Aligner2Status); }
		}

		public string ServerStatusBackground
        {
	        get { return GetServerStatusBackground(ServerStatus); }
	    }
        public string GetServerStatusBackground(string status)
	    {
	        return "Transparent";

         //   if (status != null)
	        //    status = status.Trim().ToLower();

	        //switch (status)
	        //{
	        //    case "unknown":
	        //        return "Yellow";
	        //    case "idle":
	        //        return "Transparent";
	        //    case "busy":
	        //        return "LawnGreen";
	        //    default:
	        //        return "Yellow";
	        //}
	    }
        

        public string GetUnitStatusBackground(string status)
	    {
            if (status!=null)
	            status = status.Trim().ToLower();

            switch (status)
	        {
	            case "unknown":
	                return "Yellow";
	            case "idle":
	                return "Transparent";
	            case "busy":
	                return "LawnGreen";
				//case "disable":
				//	return "DarkOrange";
				default:
	                return "Yellow";
	        }
	    }

	    public string TopBackground
        {
	        get
	        {
	            return ServerStatus=="Connected" ? "ForestGreen" : "Yellow";
	        }
	    }

	    public string OnlineStatusBackground
        {
	        get
	        {
	            return IsOnlineMode ? "Transparent" : "Yellow";
	        }
	    }

        


        public string TopViewBackground
		{
			get
			{
				return _simulatorMode ? "Goldenrod" : "Transparent";
			}
		}



		public string User
		{
			get
			{
				return AccountClient.Instance.CurrentUser== null ? "" : AccountClient.Instance.CurrentUser.AccountId;
			}
		}

		public string Role
		{
			get
			{
				return AccountClient.Instance.CurrentUser == null ? "" : AccountClient.Instance.CurrentUser.Role;
			}
		}



	    public ICommand SwitchOffBuzzerCommand { get; set; }
	    public ICommand ResetCommand { get; set; }
	    public ICommand LogoffCommand { get; set; }
 
        public bool IsEnableOnline
        {
		    get { return !IsOnlineMode; }
        }
	    public bool IsEnableOffline
        {
	        get { return IsOnlineMode; }
        }
        
        MessageControl _balloonControl;
	    private bool _logoff;

	    public ObservableCollection<EventItem> EventLogList { get; set; }


        public TopViewModel2()
			: base("TopViewModel2")
		{
			SwitchOffBuzzerCommand = new DelegateCommand<object>(OnSwitchOffBuzzer);
		    ResetCommand = new DelegateCommand<object>(DoReset);
		    LogoffCommand = new DelegateCommand<object>(DoLogoff);

            SoftwareVersion = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version.ToString();
			InvokePropertyChanged("SoftwareVersion");

		    EventLogList = new ObservableCollection<EventItem>();

		    _balloonControl = new MessageControl();

		    EventClient.Instance.OnEvent += Instance_OnEvent;
		    EventClient.Instance.Start();
			
		}

	    private void Instance_OnEvent(EventItem obj)
	    {

	        if (_logoff)
	            return;

	        switch (obj.Type)
	        {
	            case EventType.EventUI_Notify:
	                LogEvent(obj);
	                break;
	            case EventType.Dialog_Nofity:
	                PopDialog(obj);
	                break;
	            case EventType.KickOut_Notify:
	                break;
	            case EventType.Sound_Notify:
	                break;
	            case EventType.UIMessage_Notify:
	                PopUIMessage(obj);
	                break;
	        }


	    }

	    private void DoLogoff(object obj)
	    {
	        _logoff = true;
	        UiApplication.Instance.Logoff();
	    }

	    private void DoReset(object obj)
	    {
	        InvokeClient.Instance.Service.DoOperation("System.Reset");
	        EventLogList.Clear();
			InvokeClient.Instance.Service.DoOperation("LP1.LPReset");
			InvokeClient.Instance.Service.DoOperation("LP2.LPReset");
		}
        public void Reset()
		{
		    InvokeClient.Instance.Service.DoOperation(OperationName.ResetAlarm);
		    InvokeClient.Instance.Service.DoOperation(OperationName.ResetDevice);
		    InvokeClient.Instance.Service.DoOperation(OperationName.ResetRouteManager);
		}

        void OnSwitchOffBuzzer(object param)
		{
			InvokeClient.Instance.Service.DoOperation("System.SignalTower.SwitchOffBuzzer1");
			InvokeClient.Instance.Service.DoOperation("System.SignalTower.SwitchOffBuzzer2");
			
		}




	    void PopUIMessage(EventItem obj)
	    {
	        Application.Current.Dispatcher.Invoke(new Action(() =>
	        {
	            _balloonControl.SetMessage(MessageType.Info, obj.Description);

	            ShowNotifyIcon(2000);

	        }));


	    }
        void LogEvent(EventItem obj)
        {
            if (obj.Type != EventType.EventUI_Notify)
                return;

            Application.Current.Dispatcher.Invoke(new Action(() =>
            {   
                while (EventLogList.Count > 100)
                {
                    EventLogList.RemoveAt(0);
                }
                EventLogList.Add(obj);

            }));
 

        }


        void ShowNotifyIcon(int time)
	    {
	        TaskbarIcon icon = new TaskbarIcon();

	        icon.ShowCustomBalloon(_balloonControl, global::System.Windows.Controls.Primitives.PopupAnimation.Slide, time);
	    }

	    void PopDialog(EventItem item)
	    {
	        Application.Current.Dispatcher.Invoke(new Action(() =>
	        {
	            switch (item.Level)
	            {
	                case EventLevel.Alarm:
	                    MessageBoxEx.ShowError(item.Description, item.Explaination);
	                    break;
	                case EventLevel.Warning:
	                    MessageBoxEx.ShowWarning(item.Description, item.Explaination);
	                    break;
	                case EventLevel.Information:
	                    MessageBoxEx.ShowInfo(item.Description, item.Explaination);
	                    break;
	            }

	        }));



	    }
        protected override void InvokeBeforeUpdateProperty(Dictionary<string, object> data)
		{
			Application.Current.Dispatcher.Invoke(new Action(() =>
			{
				_trig.CLK = ClearEventLogEnable;
				if (_trig.Q)
				{
					InvokeClient.Instance.Service.DoOperation("System.Reset");
					EventLogList.Clear();
					InvokeClient.Instance.Service.DoOperation("LP1.LPReset");
					InvokeClient.Instance.Service.DoOperation("LP2.LPReset");
					InvokeClient.Instance.Service.DoOperation("System.ClearEventLogEnable");
                }
			}));
		}

	}

}