ShellViewModel.cs

namespace ServiceControl.Config.UI.Shell
{
    using System;
    using System.Linq;
    using System.Threading;
    using System.Threading.Tasks;
    using System.Windows.Input;
    using Caliburn.Micro;
    using Commands;
    using Events;
    using Framework;
    using Framework.Rx;
    using ListInstances;
    using NoInstances;
    using NuGet.Versioning;
    using ServiceControlInstaller.Engine.Instances;

    class ShellViewModel : RxConductor<RxScreen>.OneActive, IHandle<PostRefreshInstances>, IHandle<ResetInstances>
    {
        public ShellViewModel(
            NoInstancesViewModel noInstances,
            ListInstancesViewModel listInstances,
            AddServiceControlInstanceCommand addInstance,
            AddMonitoringInstanceCommand addMonitoringInstance,
            LicenseStatusManager licenseStatusManager,
            IEventAggregator eventAggregator
        )
        {
            this.listInstances = listInstances;
            this.noInstances = noInstances;
            this.addInstance = addInstance;
            this.addMonitoringInstance = addMonitoringInstance;
            OpenUrl = new OpenURLCommand();
            LicenseStatusManager = licenseStatusManager;
            DisplayName = "ServiceControl Config";
            IsModal = false;
            LoadAppVersion();
#pragma warning disable RS0030 // Do not use banned apis: UtcNow for copyright is acceptable
            CopyrightInfo = $"{DateTime.UtcNow.Year} © Particular Software";
#pragma warning restore RS0030

            RefreshInstancesCmd = Command.Create(async () =>
            {
                await eventAggregator.PublishOnUIThreadAsync(new RefreshInstances());
                // Used to "blink" the refresh button to indicate the refresh actually ran.
                await Task.Delay(500);
            });
        }

        public async Task LaunchServiceControlAdd(bool installError, bool installAudit, bool installServicePulse, CancellationToken cancellationToken = default)
        {
            ShowingMenuOverlay = false;
            await addInstance.ExecuteWithOptions(installError, installAudit, installServicePulse, cancellationToken);
        }

        public void LaunchMonitoringAdd()
        {
            ShowingMenuOverlay = false;
            addMonitoringInstance.Execute(null);
        }

        public object ActiveContext { get; set; }

        public bool IsModal { get; set; }

        public bool ShowOverlay => Overlay != null;

        public bool ShowRefresh => !ShowOverlay && !IsModal;

        public bool ShowingMenuOverlay { get; set; }

        public RxScreen Overlay { get; set; }

        public SemanticVersion AppVersion { get; private set; }

        public string CopyrightInfo { get; }

        public bool HasInstances { get; private set; }

        public ICommand OpenUrl { get; private set; }

        public ICommand OpenFeedBack { get; set; }

        public ICommand RefreshInstancesCmd { get; }

        public LicenseStatusManager LicenseStatusManager { get; private set; }

        public bool UpdateAvailable { get; set; }

        public string UpdateAvailableText { get; set; }

        public string AvailableUpgradeReleaseLink { get; set; }

        public Task HandleAsync(PostRefreshInstances message, CancellationToken cancellationToken = default) => RefreshInstances(cancellationToken);

        public Task HandleAsync(ResetInstances message, CancellationToken cancellationToken = default) => RefreshInstances(cancellationToken);

        protected override Task OnInitialize(CancellationToken cancellationToken = default) => RefreshInstances(cancellationToken);

        protected override async Task OnActivate(CancellationToken cancellationToken = default)
        {
            await base.OnActivate(cancellationToken);

            BeginCheckForUpdates();
        }

        protected override void OnViewLoaded(object view)
        {
            base.OnViewLoaded(view);

            // First run: nothing is installed yet, so open the "choose a setup scenario"
            // popup immediately instead of leaving the user on the empty instance list.
            // OnViewLoaded fires once, so alt-tabbing back or hitting refresh (both of
            // which re-run RefreshInstances) won't re-trigger it, and dismissing the
            // popup leaves the user on the NoInstances view.
            if (!HasInstances)
            {
                ShowingMenuOverlay = true;
            }
        }

        public async Task RefreshInstances(CancellationToken cancellationToken = default)
        {
            HasInstances = InstanceFinder.AllInstances().Any();

            if (ActiveItem == null || ActiveItem == listInstances || ActiveItem == noInstances)
            {
                if (HasInstances)
                {
                    await ActivateItem(listInstances, cancellationToken);
                }
                else
                {
                    await ActivateItem(noInstances, cancellationToken);
                }
            }
        }

        void LoadAppVersion() => AppVersion = Constants.CurrentVersion;

        void BeginCheckForUpdates()
        {
            if (updateCheckTask is not null)
            {
                return;
            }

            updateCheckTask = CheckForUpdates(CancellationToken.None);

            NotifyOfPropertyChange(nameof(IsCheckingForUpdate));
        }

        async Task CheckForUpdates(CancellationToken cancellationToken)
        {
            try
            {
                var availableUpgradeRelease = await VersionCheckerHelper.GetLatestRelease(AppVersion, cancellationToken);

                if (availableUpgradeRelease.Version == AppVersion)
                {
                    UpdateAvailable = false;
                }
                else
                {
                    AvailableUpgradeReleaseLink = availableUpgradeRelease.Assets.FirstOrDefault()?.Download.ToString();
                    UpdateAvailableText = $"v{availableUpgradeRelease.Version} - Update Available";
                    UpdateAvailable = true;
                }
            }
            catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
            {
                throw;
            }
            catch
            {
                UpdateAvailable = false;
            }
            finally
            {
                updateCheckTask = null;

                NotifyOfPropertyChange(nameof(UpdateAvailable));
                NotifyOfPropertyChange(nameof(UpdateAvailableText));
                NotifyOfPropertyChange(nameof(AvailableUpgradeReleaseLink));
                NotifyOfPropertyChange(nameof(IsCheckingForUpdate));
            }
        }

        public bool IsCheckingForUpdate => updateCheckTask is not null;

        Task updateCheckTask;
        readonly ListInstancesViewModel listInstances;
        readonly NoInstancesViewModel noInstances;
        readonly AddServiceControlInstanceCommand addInstance;
        readonly ICommand addMonitoringInstance;
    }
}