ShakerControl/ShakerManger/ViewModel/MainWindowViewModel.cs

using HandyControl.Interactivity.Commands;
using Shaker.Model;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Input;

namespace ShakerManger.ViewModel
{
    internal class MainWindowViewModel:Shaker.ViewModel.ViewModelBase<Shaker.Model.ModelBase>
    {
        
        public bool IsEnabled { get => isEnabled; set =>UpdateProperty(ref isEnabled, value); }
        [AllowNull]
        private IMainPageViewModel currentMainPage;
        private bool isEnabled = true;
        private bool isSaveData = false;
        private bool layoutVisibily = true;

        private MainWindowViewModel()
        {
            this.GetType().Assembly.GetTypes().Where(x => x.GetInterface(typeof(IMainPageViewModel).FullName!)!= null && x.IsAnsiClass && !x.IsAbstract)
                .Select(x => (IMainPageViewModel)Activator.CreateInstance(x)!)
                .Where(x => x != null)
                .OrderBy(x => x!.MainPageType)
                .ToList()
                .ForEach(x => MainPages.Add(x!));
            Shakers = MainPages.OfType<ShakersViewModel>().First();
            LogManger = MainPages.OfType<LogMangerViewModel>().First();
            SystemConfig = MainPages.OfType<SystemConfigViewModel>().First();
            DataManger = MainPages.OfType<DataMangerViewModel>().First();
            WarnManger = MainPages.OfType<WarnMangerViewModel>().First();
            if(MainPages.Count > 0)
            {
                CurrentMainPage = MainPages[0];
            }
            LayoutManger.Close = () =>
            {
                Shakers.Layout = LayoutManger.Selected;
            };
        }
        public DataMangerViewModel DataManger { get; init; }
        public LogMangerViewModel LogManger { get; init; }
        static MainWindowViewModel()
        {

        }

        public ICommand StartAllCommand => new DelegateCommand(StartAll);
        private void StartAll()
        {
            BusManger.Defaut.Bus.PubSub.PublishAsync(new SysControl()
            {
                Cmd = SysCmd.Start,
            });
        }
        public ICommand StopAllCommand => new DelegateCommand(StopAll);
        private void StopAll()
        {
            BusManger.Defaut.Bus.PubSub.PublishAsync(new SysControl()
            {
                Cmd = SysCmd.Stop,
            });
        }
        public SystemConfigViewModel SystemConfig { get; init; }
        public override void Init()
        {
            base.Init();
            var result = Sql.Default.Connect();
            if(!result)
            {
                Tools.MessageBoxHelper.Error("数据库连接失败，程序退出");
                App.Current.Shutdown();
                return; 
            }
            BusManger.Defaut.Init();
            if(Thread.CurrentThread == Application.Current.Dispatcher.Thread)
            {

                Shakers.Init();
                SystemConfig.Init();
            }
            else
            {
                App.Current.Dispatcher.Invoke(() =>
                {
                    Shakers.Init();
                    SystemConfig.Init();
                });
            }
            BusManger.Defaut.Bus.PubSub.PublishAsync(new Shaker.Model.MangerExitModel()
            {
                Online = true,
            });
            BusManger.Defaut.Bus.PubSub.Subscribe<Shaker.Model.WarnModel>((data, _) =>
            {
                Sql.Default.Insert(data);
            });
            if (Thread.CurrentThread == Application.Current.Dispatcher.Thread)
            {
                InitedAction?.Invoke();
            }
            else
            {
                App.Current.Dispatcher.Invoke(() =>
                {
                    InitedAction?.Invoke();
                });
            }
        }
        public WarnMangerViewModel WarnManger { get; }
        public ShakersViewModel Shakers { get; }
        public LayoutMangerViewModel LayoutManger { get; }= new LayoutMangerViewModel();
        public ICommand ExitCommand => new DelegateCommand(Exit);
        private void Exit()
        {
            PromptViewModel.Default.Init();
            PromptViewModel.Default.Message = "是否退出程序?";
            PromptViewModel.Default.YesAction = () => App.Current.Shutdown();
            PromptViewModel.Default.IsOpen = true;
        }
        public bool LayoutVisibily { get => layoutVisibily; set =>UpdateProperty(ref layoutVisibily , value); }

        public ICommand SaveDataCommand => new DelegateCommand(() => IsSaveData = !IsSaveData);
        public bool IsSaveData { get => isSaveData; set =>UpdateProperty(ref isSaveData, value); }
        [AllowNull]
        public Action InitedAction { get; set; }
        public IMainPageViewModel CurrentMainPage { get => currentMainPage; set =>UpdateProperty(ref currentMainPage, value); }
        public ObservableCollection<IMainPageViewModel> MainPages { get; } = new ObservableCollection<IMainPageViewModel>();
        public static MainWindowViewModel Default { get; } = new MainWindowViewModel();
        public ICommand CloseCommand=> new DelegateCommand(Close);
        private void Close()
        {
            if(BusManger.Defaut.Bus!=null)
            {
                BusManger.Defaut.Bus.PubSub.PublishAsync(new Shaker.Model.MangerExitModel()
                {
                    Online = false,
                });
                BusManger.Defaut.Bus.Dispose();
            }
            LogManger.AddLog("程序退出");
        }
        public ICommand ShutDownCommand=> new DelegateCommand(()=> App.Current.Shutdown());
    }
}