Prerequisites - Finalized UI logic surrounding install/remove

src/Artemis.Core/Plugins/Plugin.cs

@@ -25,6 +25,7 @@ namespace Artemis.Core
             Info = info;
             Directory = directory;
             Entity = pluginEntity ?? new PluginEntity {Id = Guid, IsEnabled = true};
+            Info.Plugin = this;
 
             _features = new List<PluginFeatureInfo>();
         }

src/Artemis.Core/Plugins/PluginFeatureInfo.cs

@@ -6,6 +6,7 @@ using Artemis.Core.DeviceProviders;
 using Artemis.Core.LayerBrushes;
 using Artemis.Core.LayerEffects;
 using Artemis.Core.Modules;
+using Artemis.Storage.Entities.Plugins;
 using Humanizer;
 using Newtonsoft.Json;
 
@@ -22,10 +23,11 @@ namespace Artemis.Core
         private PluginFeature? _instance;
         private string _name = null!;
 
-        internal PluginFeatureInfo(Plugin plugin, Type featureType, PluginFeatureAttribute? attribute)
+        internal PluginFeatureInfo(Plugin plugin, Type featureType, PluginFeatureEntity pluginFeatureEntity, PluginFeatureAttribute? attribute)
         {
             Plugin = plugin ?? throw new ArgumentNullException(nameof(plugin));
             FeatureType = featureType ?? throw new ArgumentNullException(nameof(featureType));
+            Entity = pluginFeatureEntity;
 
             Name = attribute?.Name ?? featureType.Name.Humanize(LetterCasing.Title);
             Description = attribute?.Description;
@@ -48,7 +50,7 @@ namespace Artemis.Core
             else
                 Icon = "Plugin";
         }
-
+        
         internal PluginFeatureInfo(Plugin plugin, PluginFeatureAttribute? attribute, PluginFeature instance)
         {
             if (instance == null) throw new ArgumentNullException(nameof(instance));
@@ -121,6 +123,11 @@ namespace Artemis.Core
         [JsonProperty]
         public bool AlwaysEnabled { get; }
 
+        /// <summary>
+        /// Gets a boolean indicating whether the feature is enabled in persistent storage
+        /// </summary>
+        public bool EnabledInStorage => Entity.IsEnabled;
+
         /// <summary>
         ///     Gets the feature this info is associated with
         /// </summary>
@@ -136,6 +143,8 @@ namespace Artemis.Core
         /// <inheritdoc />
         public bool ArePrerequisitesMet() => Prerequisites.All(p => p.IsMet());
 
+        internal PluginFeatureEntity Entity { get; }
+
         /// <inheritdoc />
         public override string ToString()
         {

src/Artemis.Core/Plugins/Prerequisites/PrerequisiteAction/DownloadFileAction.cs

@@ -0,0 +1,79 @@
+using System;
+using System.IO;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using Humanizer;
+
+namespace Artemis.Core
+{
+    /// <summary>
+    ///     Represents a plugin prerequisite action that downloads a file
+    /// </summary>
+    public class DownloadFileAction : PluginPrerequisiteAction
+    {
+        /// <summary>
+        ///     Creates a new instance of a copy folder action
+        /// </summary>
+        /// <param name="name">The name of the action</param>
+        /// <param name="source">The source URL to download</param>
+        /// <param name="target">The target file to save as (will be created if needed)</param>
+        public DownloadFileAction(string name, string source, string target) : base(name)
+        {
+            Source = source ?? throw new ArgumentNullException(nameof(source));
+            Target = target ?? throw new ArgumentNullException(nameof(target));
+
+            ShowProgressBar = true;
+        }
+
+        /// <summary>
+        ///     Gets the source URL to download
+        /// </summary>
+        public string Source { get; }
+
+        /// <summary>
+        ///     Gets the target file to save as (will be created if needed)
+        /// </summary>
+        public string Target { get; }
+
+        /// <inheritdoc />
+        public override async Task Execute(CancellationToken cancellationToken)
+        {
+            using HttpClient client = new();
+            await using FileStream destinationStream = File.Create(Target);
+
+            void ProgressOnProgressReported(object? sender, EventArgs e)
+            {
+                if (Progress.ProgressPerSecond != 0)
+                    Status = $"Downloading {Target} - {Progress.ProgressPerSecond.Bytes().Humanize("#.##")}/sec";
+                else
+                    Status = $"Downloading {Target}";
+            }
+
+            Progress.ProgressReported += ProgressOnProgressReported;
+
+            // Get the http headers first to examine the content length
+            using HttpResponseMessage response = await client.GetAsync(Target, HttpCompletionOption.ResponseHeadersRead, cancellationToken);
+            await using Stream download = await response.Content.ReadAsStreamAsync(cancellationToken);
+            long? contentLength = response.Content.Headers.ContentLength;
+
+            // Ignore progress reporting when no progress reporter was 
+            // passed or when the content length is unknown
+            if (!contentLength.HasValue)
+            {
+                ProgressIndeterminate = true;
+                await download.CopyToAsync(destinationStream, Progress, cancellationToken);
+            }
+            else
+            {
+                ProgressIndeterminate = false;
+                await download.CopyToAsync(contentLength.Value, destinationStream, Progress, cancellationToken);
+            }
+
+            Progress.ProgressReported -= ProgressOnProgressReported;
+
+            Progress.Report((1, 1));
+            Status = "Finished downloading";
+        }
+    }
+}