Ask for execution policy change before running script.

Daybreak/Configuration/ProjectConfiguration.cs

@@ -5,6 +5,7 @@ using Daybreak.Services.Configuration;
 using Daybreak.Services.Credentials;
 using Daybreak.Services.Logging;
 using Daybreak.Services.Screenshots;
+using Daybreak.Services.Updater;
 using Daybreak.Services.ViewManagement;
 using Daybreak.Views;
 using Microsoft.Web.WebView2.Core;
@@ -29,6 +30,7 @@ namespace Daybreak.Configuration
             serviceProducer.RegisterSingleton<IScreenshotProvider, ScreenshotProvider>();
             serviceProducer.RegisterSingleton<IConfigurationManager, ConfigurationManager>();
             serviceProducer.RegisterSingleton<IBloogumClient, BloogumClient>();
+            serviceProducer.RegisterSingleton<IApplicationUpdater, ApplicationUpdater>();
             serviceProducer.RegisterSingleton<CoreWebView2Environment, CoreWebView2Environment>((sp) => TaskExtensions.RunSync(() => CoreWebView2Environment.CreateAsync(null, "BrowserData", null)));
         }
         public static void RegisterLifetimeServices(IApplicationLifetimeProducer applicationLifetimeProducer)
@@ -44,6 +46,8 @@ namespace Daybreak.Configuration
 
             viewProducer.RegisterView<MainView>();
             viewProducer.RegisterView<SettingsView>();
+            viewProducer.RegisterView<AskUpdateView>();
+            viewProducer.RegisterView<UpdateView>();
         }
     }
 }

Daybreak/Daybreak.csproj

@@ -9,7 +9,7 @@
     <CopyLocalLockFileAssemblies>false</CopyLocalLockFileAssemblies>
     <LangVersion>preview</LangVersion>
     <ApplicationIcon>Daybreak.ico</ApplicationIcon>
-    <Version>0.1.3</Version>
+    <Version>0.2.1</Version>
   </PropertyGroup>
 
   <ItemGroup>

Daybreak/Launch/MainWindow.xaml.cs

@@ -1,5 +1,6 @@
 using Daybreak.Services.Bloogum;
 using Daybreak.Services.Screenshots;
+using Daybreak.Services.Updater;
 using Daybreak.Services.ViewManagement;
 using Daybreak.Views;
 using Pepa.Wpf.Utilities;
@@ -26,6 +27,7 @@ namespace Daybreak.Launch
         private readonly IViewManager viewManager;
         private readonly IScreenshotProvider screenshotProvider;
         private readonly IBloogumClient bloogumClient;
+        private readonly IApplicationUpdater applicationUpdater;
         private readonly CancellationTokenSource cancellationToken = new();
 
         public string CreditText
@@ -37,18 +39,20 @@ namespace Daybreak.Launch
         public MainWindow(
             IViewManager viewManager,
             IScreenshotProvider screenshotProvider,
-            IBloogumClient bloogumClient)
+            IBloogumClient bloogumClient,
+            IApplicationUpdater applicationUpdater)
         {
             this.viewManager = viewManager.ThrowIfNull(nameof(viewManager));
             this.screenshotProvider = screenshotProvider.ThrowIfNull(nameof(screenshotProvider));
             this.bloogumClient = bloogumClient.ThrowIfNull(nameof(bloogumClient));
+            this.applicationUpdater = applicationUpdater.ThrowIfNull(nameof(applicationUpdater));
             InitializeComponent();
         }
 
         private void Window_Loaded(object sender, RoutedEventArgs e)
         {
-            this.viewManager.ShowView<MainView>();
             this.SetupImageCycle();
+            this.CheckForUpdates();
         }
 
         private void TitleBar_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
@@ -145,6 +149,19 @@ namespace Daybreak.Launch
             }
         }
 
+        private async void CheckForUpdates()
+        {
+            var updateAvailable = await this.applicationUpdater.UpdateAvailable().ConfigureAwait(true);
+            if (updateAvailable)
+            {
+                this.viewManager.ShowView<AskUpdateView>();
+            }
+            else
+            {
+                this.viewManager.ShowView<MainView>();
+            }
+        }
+
         private static Color GetAverageColor(BitmapSource bitmap)
         {
             var format = bitmap.Format;

Daybreak/Models/UpdateStatus.cs

@@ -0,0 +1,44 @@
+using System.ComponentModel;
+
+namespace Daybreak.Models
+{
+    public sealed class UpdateStatus : INotifyPropertyChanged
+    {
+        public static readonly UpdateStep StartingStep = new("Starting");
+        public static readonly UpdateStep CheckingLatestVersion = new("Checking latest version");
+        public static UpdateStep Downloading(double progress) => new DownloadUpdateStep("Downloading", progress);
+        public static readonly UpdateStep DownloadFinished = new("Download finished. Application will restart in order to apply the update.");
+
+        private UpdateStep currentStep = StartingStep;
+
+        public event PropertyChangedEventHandler PropertyChanged;
+
+        public UpdateStep CurrentStep
+        {
+            get => this.currentStep;
+            set
+            {
+                this.currentStep = value;
+                this.PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(CurrentStep)));
+            }
+        }
+
+        public class UpdateStep
+        {
+            public string Name { get; }
+            internal UpdateStep(string name)
+            {
+                this.Name = name;
+            }
+        }
+        public class DownloadUpdateStep : UpdateStep
+        {
+            internal DownloadUpdateStep(string name, double progress) : base(name)
+            {
+                this.Progress = progress;
+            }
+
+            public double Progress { get; }
+        }
+    }
+}

Daybreak/Services/Configuration/ConfigurationManager.cs

@@ -1,7 +1,9 @@
 using Daybreak.Configuration;
 using Daybreak.Exceptions;
+using Daybreak.Services.Logging;
 using Daybreak.Utils;
 using System;
+using System.Extensions;
 using System.IO;
 
 namespace Daybreak.Services.Configuration
@@ -11,9 +13,11 @@ namespace Daybreak.Services.Configuration
         private const string ConfigName = "Daybreak.config.json";
 
         private ApplicationConfiguration applicationConfiguration;
+        private readonly ILogger logger;
 
-        public ConfigurationManager()
+        public ConfigurationManager(ILogger logger)
         {
+            this.logger = logger.ThrowIfNull(nameof(logger));
             try
             {
                 var serializedConfig = File.ReadAllText(ConfigName);
@@ -21,7 +25,8 @@ namespace Daybreak.Services.Configuration
             }
             catch(Exception e)
             {
-                throw new FatalException("Failed to load application configuration. See inner exception for details", e);
+                this.logger.LogWarning($"No configuration detected. Loading default configuration. Details: {e}");
+                this.applicationConfiguration = new ApplicationConfiguration();
             }
         }
 

Daybreak/Services/Updater/ApplicationUpdater.cs

@@ -0,0 +1,145 @@
+using Daybreak.Models;
+using Daybreak.Services.Logging;
+using Daybreak.Utils;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Extensions;
+using System.IO;
+using System.Linq;
+using System.Net.Http;
+using System.Reflection;
+using System.Threading.Tasks;
+
+namespace Daybreak.Services.Updater
+{
+    public sealed class ApplicationUpdater : IApplicationUpdater
+    {
+        private const string ExtractAndRunPs1 = "ExtractAndRun.ps1";
+        private const string TempFile = "tempfile.zip";
+        private const string VersionTag = "{VERSION}";
+        private const string InputFileTag = "{INPUTFILE}";
+        private const string OutputPathTag = "{OUTPUTPATh}";
+        private const string Url = "https://github.com/AlexMacocian/Daybreak/releases/latest";
+        private const string DownloadUrl = $"https://github.com/AlexMacocian/Daybreak/releases/download/v{VersionTag}/Daybreakv{VersionTag}.zip";
+        private const string SetExecutionPolicy = $"Set-ExecutionPolicy RemoteSigned -Scope CurrentUser";
+        private const string DelayCommand = "Start-Sleep -m 3000";
+        private const string ExtractCommandTemplate = $"Expand-Archive -Path '{InputFileTag}' -DestinationPath '{OutputPathTag}' -Force";
+        private const string RunClientCommand = @".\Daybreak.exe";
+        private const string RemoveTempFile = $"Remove-item {TempFile}";
+        private const string RemovePs1 = $"Remove-item {ExtractAndRunPs1}";
+
+        private readonly ILogger logger;
+        private readonly HttpClient httpClient = new();
+
+        public string CurrentVersion => Assembly.GetExecutingAssembly().GetName().Version.ToString();
+
+        public ApplicationUpdater(ILogger logger)
+        {
+            this.logger = logger.ThrowIfNull(nameof(logger));
+        }
+
+        public async Task<bool> DownloadUpdate(UpdateStatus updateStatus)
+        {
+            updateStatus.CurrentStep = UpdateStatus.CheckingLatestVersion;
+            var latestVersion = (await this.GetLatestVersion()).ExtractValue();
+            if (latestVersion is null)
+            {
+                this.logger.LogWarning("Failed to retrieve latest version. Aborting update");
+                return false;
+            }
+
+            using var downloadLatestResponse = await this.httpClient.GetAsync(
+                DownloadUrl.Replace(VersionTag, latestVersion));
+
+            if (downloadLatestResponse.IsSuccessStatusCode is false)
+            {
+                this.logger.LogWarning("Failed to download latest version. Aborting udpate");
+                return false;
+            }
+
+            this.logger.LogInformation("Beginning update download");
+            var downloadStream = await downloadLatestResponse.Content.ReadAsStreamAsync();
+            var fileStream = File.OpenWrite(TempFile);
+            var downloadSize = (double)downloadStream.Length;
+            var buffer = new byte[1024];
+            var length = 0;
+            double downloaded = 0;
+            var tickTime = DateTime.Now;
+            while (downloadStream.CanRead && (length = await downloadStream.ReadAsync(buffer)) > 0)
+            {
+                downloaded += length;
+                await fileStream.WriteAsync(buffer, 0, length);
+                if ((DateTime.Now - tickTime).TotalMilliseconds > 50)
+                {
+                    tickTime = DateTime.Now;
+                    updateStatus.CurrentStep = UpdateStatus.Downloading(downloaded / downloadSize);
+                }
+            }
+
+            updateStatus.CurrentStep = UpdateStatus.Downloading(1);
+            updateStatus.CurrentStep = UpdateStatus.DownloadFinished;
+            fileStream.Close();
+            this.logger.LogInformation("Downloaded update");
+            return true;
+        }
+
+        public async Task<bool> UpdateAvailable()
+        {
+            var version = string.Join('.', this.CurrentVersion.Split('.').Take(3));
+            var maybeLatestVersion = await this.GetLatestVersion();
+            return maybeLatestVersion.Switch(
+                onSome: latestVersion => string.Compare(version, latestVersion, true) < 0,
+                onNone: () => 
+                {
+                    this.logger.LogWarning("Failed to retrieve latest version");
+                    return false;
+                }).ExtractValue();
+        }
+
+        public void FinalizeUpdate()
+        {
+            File.WriteAllLines(ExtractAndRunPs1, new List<string>()
+            {
+                SetExecutionPolicy,
+                DelayCommand,
+                ExtractCommandTemplate
+                    .Replace(InputFileTag, Path.GetFullPath(TempFile))
+                    .Replace(OutputPathTag, Directory.GetCurrentDirectory()),
+                RemoveTempFile,
+                RemovePs1,
+                RunClientCommand
+            });
+            var process = new Process()
+            {
+                StartInfo = new ProcessStartInfo
+                {
+                    FileName = "powershell.exe",
+                    Arguments = $@"{Directory.GetCurrentDirectory()}\{ExtractAndRunPs1}",
+                    UseShellExecute = false,
+                    RedirectStandardError = true,
+                    RedirectStandardInput = true,
+                    RedirectStandardOutput = true,
+                    WindowStyle = ProcessWindowStyle.Maximized,
+                    WorkingDirectory = Directory.GetCurrentDirectory()
+                },
+            };
+            if (process.Start() is false)
+            {
+                throw new InvalidOperationException("Failed to create and start powershell script");
+            }
+        }
+
+        private async Task<Optional<string>> GetLatestVersion()
+        {
+            using var response = await this.httpClient.GetAsync(Url);
+            if (response.IsSuccessStatusCode)
+            {
+                var versionTag = response.RequestMessage.RequestUri.ToString().Split('/').Last().TrimStart('v');
+                return versionTag;
+            }
+
+            return Optional.None<string>();
+        }
+    }
+}

Daybreak/Services/Updater/IApplicationUpdater.cs

@@ -0,0 +1,13 @@
+using Daybreak.Models;
+using System.Threading.Tasks;
+
+namespace Daybreak.Services.Updater
+{
+    public interface IApplicationUpdater
+    {
+        string CurrentVersion { get; }
+        void FinalizeUpdate();
+        Task<bool> UpdateAvailable();
+        Task<bool> DownloadUpdate(UpdateStatus updateStatus);
+    }
+}

Daybreak/Views/AskUpdateView.xaml

@@ -0,0 +1,21 @@
+<UserControl x:Class="Daybreak.Views.AskUpdateView"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
+             xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
+             xmlns:local="clr-namespace:Daybreak.Views"
+             mc:Ignorable="d"
+             xmlns:controls="clr-namespace:Daybreak.Controls"
+             d:DesignHeight="450" d:DesignWidth="800">
+    <Grid VerticalAlignment="Center" HorizontalAlignment="Center" Width="400" Height="200"
+          Background="White">
+        <TextBlock Text="An update has been detected. Do you wish to update?" FontSize="20" TextWrapping="Wrap"
+                   Foreground="Black"></TextBlock>
+        <controls:OpaqueButton Text="No" Foreground="Black" TransparentBackground="Gray" BackgroundOpacity="0.2" Width="50" Height="30"
+                               FontSize="16" HorizontalAlignment="Center" Margin="0, 0, 80, 0"
+                               Clicked="NoButton_Clicked"></controls:OpaqueButton>
+        <controls:OpaqueButton Text="Yes" Foreground="Black" TransparentBackground="Gray" BackgroundOpacity="0.2" Width="50" Height="30"
+                               FontSize="16" HorizontalAlignment="Center" Margin="80, 0, 0, 0"
+                               Clicked="YesButton_Clicked"></controls:OpaqueButton>
+    </Grid>
+</UserControl>

Daybreak/Views/AskUpdateView.xaml.cs

@@ -0,0 +1,42 @@
+using Daybreak.Services.Logging;
+using Daybreak.Services.Updater;
+using Daybreak.Services.ViewManagement;
+using Daybreak.Utils;
+using System.Extensions;
+using System.Windows.Controls;
+
+namespace Daybreak.Views
+{
+    /// <summary>
+    /// Interaction logic for AskUpdateView.xaml
+    /// </summary>
+    public partial class AskUpdateView : UserControl
+    {
+        private readonly IApplicationUpdater applicationUpdater;
+        private readonly ILogger logger;
+        private readonly IViewManager viewManager;
+
+        public AskUpdateView(
+            IApplicationUpdater applicationUpdater,
+            ILogger logger,
+            IViewManager viewManager)
+        {
+            this.applicationUpdater = applicationUpdater.ThrowIfNull(nameof(applicationUpdater));
+            this.logger = logger.ThrowIfNull(nameof(logger));
+            this.viewManager = viewManager.ThrowIfNull(nameof(viewManager));
+            this.InitializeComponent();
+        }
+
+        private void NoButton_Clicked(object sender, System.EventArgs e)
+        {
+            this.logger.LogInformation("User declined update");
+            this.viewManager.ShowView<MainView>();
+        }
+
+        private void YesButton_Clicked(object sender, System.EventArgs e)
+        {
+            this.logger.LogInformation("User accepted update");
+            this.viewManager.ShowView<UpdateView>();
+        }
+    }
+}

Daybreak/Views/UpdateView.xaml

@@ -0,0 +1,22 @@
+<UserControl x:Class="Daybreak.Views.UpdateView"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
+             xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
+             xmlns:local="clr-namespace:Daybreak.Views"
+             mc:Ignorable="d"
+             x:Name="_this"
+             xmlns:controls="clr-namespace:Daybreak.Controls"
+             Loaded="UpdateView_Loaded"
+             d:DesignHeight="450" d:DesignWidth="800">
+    <Grid VerticalAlignment="Center" HorizontalAlignment="Center" Background="White" MinHeight="200" MinWidth="400">
+        <StackPanel VerticalAlignment="Center">
+            <TextBlock Text="{Binding ElementName=_this, Path=Description, Mode=OneWay}" Margin="10, 0, 10, 10" Foreground="Black"
+                       TextWrapping="Wrap"></TextBlock>
+            <ProgressBar Minimum="0" Maximum="100" Value="{Binding ElementName=_this, Path=ProgressValue, Mode=OneWay}" Width="300" Height="20"></ProgressBar>
+            <controls:OpaqueButton Text="Ok" BackgroundOpacity="0.2" TransparentBackground="Gray" HorizontalAlignment="Center" Margin="10" Width="30" Height="20"
+                                   IsEnabled="{Binding ElementName=_this, Path=ContinueButtonEnabled, Mode=OneWay}"
+                                   Clicked="OpaqueButton_Clicked" Foreground="Black"></controls:OpaqueButton>
+        </StackPanel>
+    </Grid>
+</UserControl>

Daybreak/Views/UpdateView.xaml.cs

@@ -0,0 +1,102 @@
+using Daybreak.Models;
+using Daybreak.Services.Logging;
+using Daybreak.Services.Updater;
+using Daybreak.Services.ViewManagement;
+using Daybreak.Utils;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Extensions;
+
+namespace Daybreak.Views
+{
+    /// <summary>
+    /// Interaction logic for UpdateView.xaml
+    /// </summary>
+    public partial class UpdateView : UserControl
+    {
+        public readonly static DependencyProperty DescriptionProperty =
+            DependencyPropertyExtensions.Register<UpdateView, string>(nameof(Description));
+        public readonly static DependencyProperty ProgressValueProperty =
+            DependencyPropertyExtensions.Register<UpdateView, double>(nameof(ProgressValue));
+        public readonly static DependencyProperty ContinueButtonEnabledProperty =
+            DependencyPropertyExtensions.Register<UpdateView, bool>(nameof(ContinueButtonEnabled));
+
+        private readonly ILogger logger;
+        private readonly IViewManager viewManager;
+        private readonly IApplicationUpdater applicationUpdater;
+        private readonly UpdateStatus updateStatus = new();
+
+        private bool success = false;
+
+        public string Description
+        {
+            get => this.GetTypedValue<string>(DescriptionProperty);
+            set => this.SetValue(DescriptionProperty, value);
+        }
+        public double ProgressValue
+        {
+            get => this.GetTypedValue<double>(ProgressValueProperty);
+            set => this.SetValue(ProgressValueProperty, value);
+        }
+        public bool ContinueButtonEnabled
+        {
+            get => this.GetTypedValue<bool>(ContinueButtonEnabledProperty);
+            set => this.SetValue(ContinueButtonEnabledProperty, value);
+        }
+
+        public UpdateView(
+            IApplicationUpdater applicationUpdater,
+            ILogger logger,
+            IViewManager viewManager)
+        {
+            this.applicationUpdater = applicationUpdater;
+            this.logger = logger;
+            this.viewManager = viewManager;
+            this.updateStatus.PropertyChanged += UpdateStatus_PropertyChanged;
+            this.InitializeComponent();
+        }
+
+        private void UpdateStatus_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
+        {
+            this.Dispatcher.Invoke(() =>
+            {
+                if (this.updateStatus.CurrentStep is UpdateStatus.DownloadUpdateStep downloadUpdateStep)
+                {
+                    this.ProgressValue = downloadUpdateStep.Progress * 100;
+                }
+
+                this.Description = this.updateStatus.CurrentStep.Name;
+            });
+        }
+
+        private async void UpdateView_Loaded(object sender, RoutedEventArgs e)
+        {
+            this.logger.LogInformation("Starting update procedure");
+            var success = await applicationUpdater.DownloadUpdate(updateStatus).ConfigureAwait(true);
+            if (success is false)
+            {
+                this.logger.LogError("Update procedure failed");
+            }
+            else
+            {
+                this.success= true;
+                this.logger.LogInformation("Downloaded update");
+            }
+
+            this.ContinueButtonEnabled = true;
+        }
+
+        private void OpaqueButton_Clicked(object sender, System.EventArgs e)
+        {
+            if (this.success)
+            {
+                this.applicationUpdater.FinalizeUpdate();
+                Application.Current.Shutdown();
+            }
+            else
+            {
+                this.viewManager.ShowView<MainView>();
+            }
+        }
+    }
+}

README.md

@@ -4,6 +4,7 @@ Requires standalone version https://developer.microsoft.com/microsoft-edge/webvi
 
 ![Alt Text](https://media1.giphy.com/media/Z32o0OZ5pZHDOIodzD/giphy.gif)
 ![Alt Text](https://media0.giphy.com/media/aQ8Wl7lsuhT0AblCPI/giphy.gif)
+![Alt Text](https://media2.giphy.com/media/s06PtxgeAAZtoJhTx6/giphy.gif)
 
 ## Features
 Automatically detect if guildwars is running or not. Includes the ability to launch guildwars from the client.