Virgo_D_SLN/Virgo_DUI/MainViewModel.cs

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Drawing;
using System.Linq;
using System.Reflection;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using System.Windows.Threading;
using Aitex.Core.Account;
using Aitex.Core.Common.DeviceData;
using Aitex.Core.RT.Event;
using Aitex.Core.RT.Log;
using Aitex.Core.Util;
using Aitex.Core.WCF;
using Caliburn.Micro;
using MECF.Framework.Common.Account.Extends;
using MECF.Framework.Common.DataCenter;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.OperationCenter;
using MECF.Framework.UI.Core.Accounts;
using OpenSEMI.ClientBase;
using OpenSEMI.ClientBase.Command;
using OpenSEMI.ClientBase.Utility;
using OpenSEMI.Core.Msg;
using SciChart.Charting.ChartModifiers;
using SciChart.Charting.Visuals;
using SciChart.Charting.Visuals.Annotations;
using SciChart.Charting.Visuals.Axes;
using Virgo_DCommon;
using Cali = Caliburn.Micro.Core;

namespace Virgo_DUI.Client
{
    public class TimeredMainViewModel : Cali.Conductor<Cali.Screen>.Collection.OneActive
    {
        private PeriodicJob _timer;
        private ConcurrentBag<string> _subscribedKeys = new ConcurrentBag<string>();
        public R_TRIG _rfAlarmTrigger = new R_TRIG();
        private Func<object, bool> _isSubscriptionAttribute;
        private Func<MemberInfo, bool> _hasSubscriptionAttribute;

        public string SoftwareVersion
        {
            get;
            set;
        }
        
        [Subscription("PMA.Rf.RfAlarm")]
        public bool RfAlarm
        {
            get;
            set;
        }
        
        [Subscription("PMA.IoMfc.MfcGas1.MfcAlarm")]
        public bool MfcAlarm1
        {
            get;
            set;
        }

        [Subscription("PMA.IoMfc.MfcGas2.MfcAlarm")]
        public bool MfcAlarm2
        {
            get;
            set;
        }

        [Subscription("PMA.IoMfc.MfcGas3.MfcAlarm")]
        public bool MfcAlarm3
        {
            get;
            set;
        }

        public string GetUnitStatusBackground(string status)
        {
            if (status == null) return "Black";

            status = status.Trim().ToLower();

            switch (status)
            {
            case "error":
                return "red";
            case "idle":
                return "Transparent";
            case "init":
            case "unknown":
                return "Yellow";
            default:
                return "LawnGreen";
            }
        }

        public TimeredMainViewModel()
        {
            _timer = new PeriodicJob(100, this.OnTimer, "UIUpdaterThread - " + GetType().Name);

            _isSubscriptionAttribute = attribute => attribute is SubscriptionAttribute;
            _hasSubscriptionAttribute = mi => mi.GetCustomAttributes(false).Any(_isSubscriptionAttribute);

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

            SubscribeKeys(this);
        }

        //
        protected virtual bool OnTimer()
        {
            try
            {
                Poll();
            }
            catch (Exception ex)
            {
                LOG.Error(ex.Message);
            }

            return true;
        }

        public virtual void EnableTimer(bool enable)
        {
            if (enable) _timer.Start();
            else _timer.Pause();
        }

        protected virtual void Poll()
        {
            _rfAlarmTrigger.CLK = RfAlarm || MfcAlarm1 || MfcAlarm2 || MfcAlarm3;
            if (_rfAlarmTrigger.Q)
                InvokeClient.Instance.Service.DoOperation($"{ModuleName.PMA}.SignalTower.SwitchOnBuzzerAndRed");

            if (_subscribedKeys.Count > 0)
            {
                Dictionary<string, object> result = QueryDataClient.Instance.Service.PollData(_subscribedKeys);

                if (result == null)
                {
                    LOG.Error("获取RT数据失败");
                    return;
                }

                if (result.Count != _subscribedKeys.Count)
                {
                    string unknowKeys = string.Empty;
                    foreach (string key in _subscribedKeys)
                    {
                        if (!result.ContainsKey(key))
                        {
                            unknowKeys += key + "\r\n";
                        }
                    }
                    //System.Diagnostics.Debug.Assert(false, unknowKeys);
                }

                InvokeBeforeUpdateProperty(result);

                UpdateValue(result);

                Application.Current.Dispatcher.Invoke(new System.Action(() =>
                {
                    InvokePropertyChanged();

                    InvokeAfterUpdateProperty(result);
                }));
            }
        }

        private void InvokePropertyChanged()
        {
            Refresh();
        }

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

        protected virtual void InvokeAfterUpdateProperty(Dictionary<string, object> data)
        {
        }

        void UpdateValue(Dictionary<string, object> data)
        {
            if (data == null)
                return;

            UpdateSubscribe(data, this);

            var properties = GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance).Where(p => p.GetCustomAttribute<SubscriptionModuleAttribute>() != null);
            foreach (var property in properties)
            {
                var moduleAttr = property.GetCustomAttribute<SubscriptionModuleAttribute>();
                UpdateSubscribe(data, property.GetValue(this), moduleAttr.Module);
            }
        }

        protected void Subscribe(string key)
        {
            if (!string.IsNullOrEmpty(key))
            {
                _subscribedKeys.Add(key);
            }
        }

        public void SubscribeKeys(TimeredMainViewModel target)
        {
            Parallel.ForEach(target.GetType().GetProperties().Where(_hasSubscriptionAttribute),
                property =>
                {
                    SubscriptionAttribute subscription = property.GetCustomAttributes(false).First(_isSubscriptionAttribute) as SubscriptionAttribute;
                    string key = subscription.ModuleKey;
                    if (!_subscribedKeys.Contains(key))
                        _subscribedKeys.Add(key);
                });

            Parallel.ForEach(target.GetType().GetFields().Where(_hasSubscriptionAttribute),
                method =>
                {
                    SubscriptionAttribute subscription = method.GetCustomAttributes(false).First(_isSubscriptionAttribute) as SubscriptionAttribute;
                    string key = subscription.ModuleKey;
                    if (!_subscribedKeys.Contains(key))
                        _subscribedKeys.Add(key);
                });
        }

        public void UpdateSubscribe(Dictionary<string, object> data, object target, string module = null)
        {
            Parallel.ForEach(target.GetType().GetProperties().Where(_hasSubscriptionAttribute),
                property =>
                {
                    PropertyInfo pi = (PropertyInfo)property;
                    SubscriptionAttribute subscription = property.GetCustomAttributes(false).First(_isSubscriptionAttribute) as SubscriptionAttribute;
                    string key = subscription.ModuleKey;
                    key = module == null ? key : string.Format("{0}.{1}", module, key);

                    if (_subscribedKeys.Contains(key) && data.ContainsKey(key))
                    {
                        try
                        {
                            var convertedValue = Convert.ChangeType(data[key], pi.PropertyType);
                            var originValue = Convert.ChangeType(pi.GetValue(target, null), pi.PropertyType);
                            if (originValue != convertedValue)
                            {
                                if (pi.Name == "PumpLimitSetPoint")
                                    pi.SetValue(target, convertedValue, null);
                                else
                                    pi.SetValue(target, convertedValue, null);
                            }
                        }
                        catch (Exception ex)
                        {
                            LOG.Error("由RT返回的数据更新失败" + key, ex);
                        }
                    }
                });

            Parallel.ForEach(target.GetType().GetFields().Where(_hasSubscriptionAttribute),
                property =>
                {
                    FieldInfo pi = (FieldInfo)property;
                    SubscriptionAttribute subscription = property.GetCustomAttributes(false).First(_isSubscriptionAttribute) as SubscriptionAttribute;
                    string key = subscription.ModuleKey;

                    if (_subscribedKeys.Contains(key) && data.ContainsKey(key))
                    {
                        try
                        {
                            var convertedValue = Convert.ChangeType(data[key], pi.FieldType);
                            pi.SetValue(target, convertedValue);
                        }
                        catch (Exception ex)
                        {
                            LOG.Error("由RT返回的数据更新失败" + key, ex);
                        }
                    }
                });
        }
    }

    public class MainViewModel : TimeredMainViewModel
    {
        public ObservableCollection<EventItem> WarnEventLogList { get; set; }
        public ObservableCollection<EventItem> EventLogList { get; set; }

        public Visibility AllEventsVisibility { get; set; }
        public Visibility WarnEventsVisibility { get; set; }

        [Subscription("Rt.Status")]
        public string RtStatus { get; set; }
        public string RtStatusBackground
        {
            get { return GetUnitStatusBackground(RtStatus); }
        }

        [Subscription("EFEM.FsmState")]
        public string EfemStatus { get; set; }
        public string EfemStatusBackground
        {
            get { return GetUnitStatusBackground(EfemStatus); }
        }

        [Subscription("FA.Status")]
        public string HostStatus { get; set; }
        public string HostStatusBackground
        {
            get { return GetUnitStatusBackground("Idle"); }
        }

        [Subscription("PMA.FsmState")]
        public string PMAStatus { get; set; }
        public string PMAStatusBackground
        {
            get { return GetUnitStatusBackground(PMAStatus); }
        }

        [Subscription("PMB.FsmState")]
        public string PMBStatus { get; set; }
        public string PMBStatusBackground
        {
            get { return GetUnitStatusBackground(PMBStatus); }
        }

        [Subscription("PMA.IsOnline")]
        public bool PMAIsOnline { get; set; }
        public string PMA_TopFrame_TextColor
        {
            get { return PMAIsOnline ? "LimeGreen" : "White"; }
        }

        [Subscription("PMB.IsOnline")]
        public bool PMBIsOnline { get; set; }
        public string PMB_TopFrame_TextColor
        {
            get { return PMBIsOnline ? "LimeGreen" : "White"; }
        }

        //[Subscription("EFEM.SignalTower")]
        [Subscription("PMA.SignalTower.DeviceData")]
        public AITSignalTowerData SignalTowerData
        {
            get;
            set;
        }

        private string _lastLoginName;
        public string LastLoginName
        {
            get { return _lastLoginName; }
            set
            {
                _lastLoginName = value;
                this.NotifyOfPropertyChange("LastLoginName");
            }
        }

        public MainViewModel()
        {
            BaseApp.Instance.Initialize();
            ((Virgo_DUI.Client.ClientApp)BaseApp.Instance).ViewModelSwitcher = this;
            this._models = new Dictionary<Type, BaseModel>();

            //for login part
            Roles = RoleAccountProvider.Instance.GetRoles();

            EventLogList = new ObservableCollection<EventItem>();
            EventClient.Instance.OnEvent += Instance_OnEvent;
            EventClient.Instance.OnDisconnectedWithRT += Instance_OnDisconnectedWithRT;
            EventClient.Instance.Start();

            WarnEventLogList = new ObservableCollection<EventItem>();

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

        private void Instance_OnDisconnectedWithRT()
        {
            MessageBox.Show("Disconnected with RT, UI will exit", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
            Environment.Exit(0);
        }

        public void ShowAlarmEvents()
        {
            AllEventsVisibility = Visibility.Hidden;
            WarnEventsVisibility = Visibility.Visible;
            this.NotifyOfPropertyChange("AllEventsVisibility");
            this.NotifyOfPropertyChange("WarnEventsVisibility");
        }

        public void ShowAllEvents()
        {
            AllEventsVisibility = Visibility.Visible;
            WarnEventsVisibility = Visibility.Hidden;
            this.NotifyOfPropertyChange("AllEventsVisibility");
            this.NotifyOfPropertyChange("WarnEventsVisibility");
        }

        private void Instance_OnEvent(EventItem obj)
        {
            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;
            }
        }

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

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

               if (obj.Level == EventLevel.Alarm)
                   this.WarnEventLogList.Add(obj);
           });
        }

        #region login part

        public void Enter(KeyEventArgs args, string loginName, PasswordBox password, Role role)
        {
            if (args.Key == Key.Enter)
                this.Login(loginName, password, role);
        }

        public void Login(string loginName, PasswordBox password, Role role)
        {
            try
            {
                LoginResult result = AccountClient.Instance.Service.LoginEx(loginName, password.Password, role.RoleID);
                if (result.ActSucc)
                {
                    ClientApp.Instance.UserContext.LoginId = result.SessionId;

                    ClientApp.Instance.UserMode = UserMode.Normal;
                    ClientApp.Instance.UserContext.LoginName = loginName;
                    ClientApp.Instance.UserContext.Role = role;
                    ClientApp.Instance.UserContext.RoleID = role.RoleID;
                    ClientApp.Instance.UserContext.RoleName = role.RoleName;
                    ClientApp.Instance.UserContext.LoginTime = DateTime.Now;
                    //ClientApp.Instance.UserContext.Token = token;
                    ClientApp.Instance.UserContext.LastAccessTime = DateTime.Now;
                    ClientApp.Instance.UserContext.IsLogin = true;

                    //Load menu by role
                    //filer menu if necessary...
                    ClientApp.Instance.MenuManager.LoadMenu(RoleAccountProvider.Instance.GetMenusByRole(role.RoleID, ClientApp.Instance.MenuLoader.MenuList));

                    InitMenu(); //bind menu to main view

                    IsLogin = true; //control the display logic of main view

                    //main view is common page, need register keys with true flag
                    ClientApp.Instance.StatesManager.Register(new List<string>() { "System.RtStatus" }, true);

                    LOG.Info(string.Format("{0} login as {1}", loginName, role.RoleName));
                }
                else
                {
                    Enum.TryParse(result.Description, out AuthorizeResult errCode);

                    switch (errCode)
                    {
                    case AuthorizeResult.None:
                        DialogBox.ShowError("Not connected with RT.");
                        break;
                    case AuthorizeResult.WrongPwd:
                        DialogBox.ShowError("Invalid password.");
                        break;
                    case AuthorizeResult.HasLogin:
                        DialogBox.ShowError("{0} has already logged in.", loginName);
                        break;
                    case AuthorizeResult.NoMatchRole:
                        DialogBox.ShowError("{0} does not match {1} role.", loginName, role.RoleName);
                        break;
                    case AuthorizeResult.NoMatchUser:
                        DialogBox.ShowError("{0} does not exists.", loginName);
                        break;
                    case AuthorizeResult.NoSession:
                        DialogBox.ShowError("The current session is invalid.");
                        break;
                    }
                }
                password.Clear();
            }
            catch (Exception ex)
            {
                LOG.Error(ex.Message, ex);
            }
        }

        #endregion login part

        public void Logout()
        {
            this.OnLogoutCommand();
        }

        public void OnLogoutCommand()
        {
            WindowManager windowmanager = new WindowManager();
            var logoffViewmodel = new LogoffViewModel();
            windowmanager.ShowDialog(logoffViewmodel);

            BaseApp.Instance.UserMode = logoffViewmodel.DialogResult;

            switch (logoffViewmodel.DialogResult)
            {
            case UserMode.Logoff:
                BaseApp.Instance.UserMode = UserMode.Logoff;
                if (BaseApp.Instance.UserContext.IsLogin)
                {
                    try
                    {
                        AccountClient.Instance.Service.LogoutEx(BaseApp.Instance.UserContext.LoginName, BaseApp.Instance.UserContext.LoginId);

                        BaseApp.Instance.UserContext.IsLogin = false;
                        LOG.Info(string.Format("{0} logoff as {1}", BaseApp.Instance.UserContext.LoginName, BaseApp.Instance.UserContext.RoleName));
                    }
                    catch (Exception exp)
                    {
                        LOG.Write(exp);
                    }
                }
                IsLogin = false;    //no independent login page
                break;
            case UserMode.Exit:
                AccountClient.Instance.Service.LogoutEx(BaseApp.Instance.UserContext.LoginName, BaseApp.Instance.UserContext.LoginId);

                BaseApp.Instance.UserMode = UserMode.Exit;
                LOG.Info(string.Format("{0} exit as {1}", BaseApp.Instance.UserContext.LoginName, BaseApp.Instance.UserContext.RoleName));
                MsgPool.TerminateAll();

                this.TryClose();
                break;
            case UserMode.Shutdown:
                AccountClient.Instance.Service.LogoutEx(BaseApp.Instance.UserContext.LoginName, BaseApp.Instance.UserContext.LoginId);
                ShutdownWindow = new ShutdownViewModel();
                ShutdownThread = ShutdownExecute;
                windowmanager.ShowWindow(ShutdownWindow);
                ShutdownThread.BeginInvoke(ShutdownCallBack, ShutdownThread);
                break;
            }
        }

        public void Reset()
        {
            _rfAlarmTrigger.RST = true;
            InvokeClient.Instance.Service.DoOperation("System.Reset");
        }

        public void BuzzerOff()
        {
            //InvokeClient.Instance.Service.DoOperation($"{ModuleName.EFEM}.{EfemOperation.TurnOffAllLights}");
            InvokeClient.Instance.Service.DoOperation($"{ModuleName.PMA}.SignalTower.SwitchOffBuzzer");
        }

        #region override functions

        public override void CanClose(Action<bool> callback)
        {
            if (BaseApp.Instance.UserMode == UserMode.Normal)
            {
                callback(false);
                Application.Current.Dispatcher.BeginInvoke(DispatcherPriority.Background, (ThreadStart)delegate
                {
                    this.OnLogoutCommand();
                });
            }
            else
                callback(true);
        }

        protected override void OnInitialize()
        {
            //display system version or other info...
            this.DisplayName = QueryDataClient.Instance.Service.GetConfig($"System.DisplayLogoName")?.ToString();

            base.OnInitialize();
            this.StartTimer();

            DrawSciChart();

            //TODO, Login
            //Login("admin", new PasswordBox() { Password = "admin" }, new Role("0", "Manager", false, 1000, ""));
        }

        protected override void OnActivate()
        {
            base.OnActivate();
            this.ShowAllEvents();
            EnableTimer(true);
        }

        void DrawSciChart()
        {
            // Create the chart surface
            var sciChartSurface = new SciChartSurface();

            // Create the X and Y Axis
            var xAxis = new NumericAxis() { AxisTitle = "Number of Samples (per series)" };
            var yAxis = new NumericAxis() { AxisTitle = "Value" };

            sciChartSurface.XAxis = xAxis;
            sciChartSurface.YAxis = yAxis;

            // Specify Interactivity Modifiers
            sciChartSurface.ChartModifier = new ModifierGroup(new RubberBandXyZoomModifier(), new ZoomExtentsModifier());
            // Add annotation hints to the user
            var textAnnotation = new TextAnnotation()
            {
                Text = "Hello World!",
                X1 = 5.0,
                Y1 = 5.0
            };
            sciChartSurface.Annotations.Add(textAnnotation);
        }

        protected override void OnViewLoaded(object view)
        {
            base.OnViewLoaded(view);
            this._view = view as MainView;
            this._view.tbLoginName.Focus();
        }

        protected override void OnDeactivate(bool close)
        {
            base.OnDeactivate(close);
            EnableTimer(false);
        }

        #endregion override functions

        #region
        #region Sync ShutDown Thread

        public delegate void ShutDownSysncThread();

        private ShutDownSysncThread ShutdownThread = null;
        private ShutdownViewModel ShutdownWindow = null;

        private void ShutdownExecute()
        {
            MsgPool.TerminateAll();
            BaseApp.Instance.UserMode = UserMode.Shutdown;
            BaseApp.Instance.UserContext.IsLogin = false;
            LOG.Info(string.Format("{0} shutdown as {1}", BaseApp.Instance.UserContext.LoginName, BaseApp.Instance.UserContext.RoleName));

            this.TryClose();
        }

        private void ShutdownCallBack(IAsyncResult result)
        {
            if (ShutdownWindow != null)
            {
                ShutdownWindow.TryClose();
            }
            ShutdownThread.EndInvoke(result);
        }

        #endregion Sync ShutDown Thread

        #region Menu Control and page switch

        private void InitMenu()
        {
            this.MenuItems = BaseApp.Instance.MenuManager.MenuItems;
            this.HistoryMenus = new ObservableCollection<AppMenu>();

            if (this.MenuItems.Count > 0)
            {
                foreach (AppMenu menuitem in this.MenuItems)
                {
                    if (menuitem.MenuItems.Count > 0)
                    {
                        this.SwitchMenuItem(menuitem.MenuItems[0]);
                        break;
                    }
                }
            }
        }

        public void MainSwitchMenuItem(AppMenu menuViewItem)
        {
            if (menuViewItem.MenuItems.Count > 0)
            {
                if (menuViewItem.LastSelectedSubMenu != null)
                    SwitchMenuItem(menuViewItem.LastSelectedSubMenu);
                else
                    SwitchMenuItem(menuViewItem.MenuItems[0]);
            }
        }

        public void SwitchMenuItem(AppMenu menuViewItem)
        {
            if (menuViewItem.ViewModel != null && menuViewItem.ViewModel != string.Empty)
            {
                if (menuViewItem.Model == null)
                {
                    menuViewItem.Model = (BaseModel)AssemblyUtil.CreateInstance(AssemblyUtil.GetType(menuViewItem.ViewModel));
                    ((BaseModel)menuViewItem.Model).Permission = menuViewItem.Permission;
                    ((BaseModel)menuViewItem.Model).Token = BaseApp.Instance.UserContext.Token;

                    if (menuViewItem.Model is ISupportMultipleSystem)
                        (menuViewItem.Model as ISupportMultipleSystem).SystemName = menuViewItem.System;
                }

                this.ActivateItem(((BaseModel)menuViewItem.Model));
                CurrentViewModel = ((BaseModel)menuViewItem.Model);

                if (((BaseModel)menuViewItem.Model).Page != PageID.MAX_PAGE)
                    BaseApp.Instance.SetCurrentPage(((BaseModel)menuViewItem.Model).Page);

                this.HandleSubAndHistoryMenu(menuViewItem);

                if (this._currentMenuItem != null)
                {
                    this._currentMenuItem.Selected = false;
                    this._currentMenuItem.Parent.Selected = false;
                }

                menuViewItem.Selected = true;
                menuViewItem.Parent.Selected = true;
                menuViewItem.Parent.LastSelectedSubMenu = menuViewItem;

                this._currentMenuItem = menuViewItem;
            }
        }

        private void HandleSubAndHistoryMenu(AppMenu menuitem)
        {
            this.SubMenuItems = menuitem.Parent.MenuItems;

            if (!this.HistoryMenus.Contains(menuitem))
            {
                if (this.HistoryMenus.Count >= 8)
                    this.HistoryMenus.RemoveAt(7);
                this.HistoryMenus.Insert(0, menuitem);
            }
            else
            {
                this.HistoryMenus.Remove(menuitem);
                this.HistoryMenus.Insert(0, menuitem);
            }
        }

        public bool SwitchPage(string firstLevelMenuID, string secondLevelMenuID)
        {
            foreach (AppMenu menuitem in BaseApp.Instance.MenuManager.MenuItems)
            {
                if (menuitem.MenuID == firstLevelMenuID)
                {
                    foreach (AppMenu menu in menuitem.MenuItems)
                    {
                        if (menu.MenuID == secondLevelMenuID)
                        {
                            SwitchMenuItem(menu);
                            return true;
                        }
                    }
                }
            }
            return false;
        }

        #endregion Menu Control and page switch

        #region Refresh Date Time on page

        private void StartTimer()
        {
            System.Windows.Threading.DispatcherTimer myDispatcherTimer =
                new System.Windows.Threading.DispatcherTimer();
            myDispatcherTimer.Interval = new TimeSpan(0, 0, 0, 0, 1000);
            myDispatcherTimer.Tick += new EventHandler(Each_Tick);
            myDispatcherTimer.Start();
        }

        public void Each_Tick(object o, EventArgs sender)
        {
            this.NowDateTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
            this.NotifyOfPropertyChange("NowDateTime");
        }

        #endregion Refresh Date Time on page
        #endregion

        public string NowDateTime { get; set; }

        private bool _IsLogin = false;
        public bool IsLogin
        {
            get { return _IsLogin; }
            set { _IsLogin = value; NotifyOfPropertyChange("IsLogin"); }
        }

        private List<Role> roles;
        public List<Role> Roles
        {
            get { return this.roles; }
            set { this.roles = value; this.RaisePropertyChangedEventImmediately("Roles"); }
        }

        private ICommand menuItemClickCommand;
        public ICommand MenuItemClickCommand
        {
            get
            {
                if (this.menuItemClickCommand == null)
                    this.menuItemClickCommand = new BaseCommand<AppMenu>((AppMenu menuViewItem) => this.SwitchMenuItem(menuViewItem));
                return this.menuItemClickCommand;
            }
        }

        private ICommand mainmenuItemClickCommand;
        public ICommand MainMenuItemClickCommand
        {
            get
            {
                if (this.mainmenuItemClickCommand == null)
                    this.mainmenuItemClickCommand = new BaseCommand<AppMenu>((AppMenu menuViewItem) => this.MainSwitchMenuItem(menuViewItem));
                return this.mainmenuItemClickCommand;
            }
        }

        public List<AppMenu> MenuItems
        {
            get { return this.menuItems; }
            set { this.menuItems = value; this.NotifyOfPropertyChange("MenuItems"); }
        }

        public List<AppMenu> SubMenuItems
        {
            get { return this.subMenuItems; }
            set { this.subMenuItems = value; this.NotifyOfPropertyChange("SubMenuItems"); }
        }

        public ObservableCollection<AppMenu> HistoryMenus
        {
            get { return this.historyItems; }
            set { this.historyItems = value; this.NotifyOfPropertyChange("HistoryMenus"); }
        }

        public string Context
        {
            get { return this.context; }
            set { this.context = value; this.NotifyOfPropertyChange("Context"); }
        }

        public BaseModel CurrentViewModel { get; private set; }
        public UserContext User { get { return BaseApp.Instance.UserContext; } }

        private AppMenu _currentMenuItem;
        private List<AppMenu> menuItems;
        private List<AppMenu> subMenuItems;
        private ObservableCollection<AppMenu> historyItems;
        private string context;
        private MainView _view;
        private Dictionary<Type, BaseModel> _models;
    }
}