Merge pull request #275 from nblumhardt/app-instance-commands

`app list`, `appinstance (create|list|remove)`

Author: KodrAus

src/SeqCli/Cli/Command.cs

@@ -91,7 +91,7 @@ protected virtual async Task<int> Run(string[] unrecognized)
 
     protected virtual Task<int> Run() { return Task.FromResult(0); }
 
-    protected virtual void ShowUsageErrors(IEnumerable<string> errors)
+    protected static void ShowUsageErrors(IEnumerable<string> errors)
     {
         foreach (var error in errors)
         {

src/SeqCli/Cli/Commands/ApiKey/ListCommand.cs

@@ -47,13 +47,9 @@ protected override async Task<int> Run()
         var list = _entityIdentity.Id != null ?
             new[] { await connection.ApiKeys.FindAsync(_entityIdentity.Id) } :
             (await connection.ApiKeys.ListAsync())
-            .Where(ak => _entityIdentity.Title == null || _entityIdentity.Title == ak.Title)
-            .ToArray();
+            .Where(ak => _entityIdentity.Title == null || _entityIdentity.Title == ak.Title);
 
-        foreach (var apiKey in list)
-        {
-            _output.WriteEntity(apiKey);
-        }
+        _output.ListEntities(list);
 
         return 0;
     }

src/SeqCli/Cli/Commands/App/DefineCommand.cs

@@ -16,7 +16,6 @@
 using System.Threading.Tasks;
 using SeqCli.Apps;
 using SeqCli.Apps.Definitions;
-using SeqCli.Config;
 using SeqCli.Util;
 
 namespace SeqCli.Cli.Commands.App;

src/SeqCli/Cli/Commands/App/ListCommand.cs

@@ -0,0 +1,60 @@
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using SeqCli.Cli.Features;
+using SeqCli.Config;
+using SeqCli.Connection;
+
+namespace SeqCli.Cli.Commands.App;
+
+[Command("app", "list", "List installed app packages", Example="seqcli app list")]
+class ListCommand : Command
+{
+    readonly SeqConnectionFactory _connectionFactory;
+
+    string? _title, _id;
+    readonly ConnectionFeature _connection;
+    readonly OutputFormatFeature _output;
+
+    string? PackageId => string.IsNullOrWhiteSpace(_title) ? null : _title.Trim();
+    string? Id => string.IsNullOrWhiteSpace(_id) ? null : _id.Trim();
+
+    public ListCommand(SeqConnectionFactory connectionFactory, SeqCliConfig config)
+    {
+        if (config == null) throw new ArgumentNullException(nameof(config));
+        _connectionFactory = connectionFactory ?? throw new ArgumentNullException(nameof(connectionFactory));
+
+        Options.Add(
+            "package-id=",
+            "The package id of the app(s) to list",
+            t => _title = t);
+
+        Options.Add(
+            "i=|id=",
+            "The id of a single app to list",
+            t => _id = t);
+
+        _output = Enable(new OutputFormatFeature(config.Output));
+        _connection = Enable<ConnectionFeature>();
+    }
+    
+    protected override async Task<int> Run()
+    {
+        if (PackageId != null && Id != null)
+        {
+            ShowUsageErrors(new[] {"Only one of either `package-id` or `id` can be specified"});
+            return 1;
+        }
+
+        var connection = _connectionFactory.Connect(_connection);
+
+        var list = Id != null ?
+            new[] { await connection.Apps.FindAsync(Id) } :
+            (await connection.Apps.ListAsync())
+            .Where(ak => PackageId == null || PackageId == ak.Package.PackageId);
+
+        _output.ListEntities(list);
+            
+        return 0;
+    }
+}

src/SeqCli/Cli/Commands/AppInstance/CreateCommand.cs

@@ -0,0 +1,103 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Seq.Api.Model.AppInstances;
+using SeqCli.Cli.Features;
+using SeqCli.Config;
+using SeqCli.Connection;
+using SeqCli.Util;
+using Serilog;
+
+namespace SeqCli.Cli.Commands.AppInstance;
+
+[Command("appinstance", "create", "Create an instance of an installed app",
+    Example = "seqcli appinstance create -t 'Email Ops' --app hostedapp-314159 -p [email protected]")]
+class CreateCommand : Command
+{
+    readonly SeqConnectionFactory _connectionFactory;
+
+    readonly ConnectionFeature _connection;
+    readonly OutputFormatFeature _output;
+
+    string? _title, _appId;
+    readonly Dictionary<string, string> _settings = new();
+    readonly List<string> _overridable = new();
+
+    public CreateCommand(SeqConnectionFactory connectionFactory, SeqCliConfig config)
+    {
+        _connectionFactory = connectionFactory ?? throw new ArgumentNullException(nameof(connectionFactory));
+
+        Options.Add(
+            "t=|title=",
+            "A title for the app instance",
+            t => _title = ArgumentString.Normalize(t));
+
+        Options.Add(
+            "app=",
+            "The id of the installed app package to instantiate",
+            app => _appId = ArgumentString.Normalize(app));
+
+        Options.Add(
+            "p={=}|property={=}",
+            "Specify name/value settings for the app, e.g. `-p [email protected] -p Subject=\"Alert!\"`",
+            (n, v) =>
+            {
+                var name = n.Trim();
+                var valueText = v?.Trim();
+                _settings.Add(name, valueText ?? "");
+            });
+
+        Options.Add(
+            "overridable=",
+            "Specify setting names that may be overridden by users when invoking the app",
+            s => _overridable.Add(s));
+        
+        // The command doesn't yet implement "Stream incoming events".
+
+        _connection = Enable<ConnectionFeature>();
+        _output = Enable(new OutputFormatFeature(config.Output));
+    }
+
+    protected override async Task<int> Run()
+    {
+        var connection = _connectionFactory.Connect(_connection);
+        
+        AppInstanceEntity instance = await connection.AppInstances.TemplateAsync(_appId)!;
+
+        bool ValidateSettingName(string settingName)
+        {
+            if (!instance.Settings!.ContainsKey(settingName))
+            {
+                Log.Error("The app does not accept a setting with name {SettingName}; available settings are: {AvailableSettings}", settingName, instance.Settings.Keys.ToArray());
+                return false;
+            }
+
+            return true;
+        }
+
+        instance.Title = _title;
+
+        foreach (var setting in _settings)
+        {
+            if (!ValidateSettingName(setting.Key))
+                return 1;
+                
+            instance.Settings![setting.Key] = setting.Value;
+        }
+
+        foreach (var overridable in _overridable)
+        {
+            if (!ValidateSettingName(overridable))
+                return 1;
+            
+            instance.InvocationOverridableSettings!.Add(overridable);
+        }
+        
+        instance = await connection.AppInstances.AddAsync(instance);
+
+        _output.WriteEntity(instance);
+
+        return 0;
+    }
+}

src/SeqCli/Cli/Commands/AppInstance/ListCommand.cs

@@ -0,0 +1,42 @@
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using SeqCli.Cli.Features;
+using SeqCli.Config;
+using SeqCli.Connection;
+
+namespace SeqCli.Cli.Commands.AppInstance;
+
+[Command("appinstance", "list", "List instances of installed apps", Example="seqcli appinstance list")]
+class ListCommand : Command
+{
+    readonly SeqConnectionFactory _connectionFactory;
+
+    readonly EntityIdentityFeature _entityIdentity;
+    readonly ConnectionFeature _connection;
+    readonly OutputFormatFeature _output;
+
+    public ListCommand(SeqConnectionFactory connectionFactory, SeqCliConfig config)
+    {
+        if (config == null) throw new ArgumentNullException(nameof(config));
+        _connectionFactory = connectionFactory ?? throw new ArgumentNullException(nameof(connectionFactory));
+
+        _entityIdentity = Enable(new EntityIdentityFeature("app instance", "list"));
+        _output = Enable(new OutputFormatFeature(config.Output));
+        _connection = Enable<ConnectionFeature>();
+    }
+    
+    protected override async Task<int> Run()
+    {
+        var connection = _connectionFactory.Connect(_connection);
+
+        var list = _entityIdentity.Id != null ?
+            new[] { await connection.AppInstances.FindAsync(_entityIdentity.Id) } :
+            (await connection.AppInstances.ListAsync())
+            .Where(d => _entityIdentity.Title == null || _entityIdentity.Title == d.Title);
+
+        _output.ListEntities(list);
+
+        return 0;
+    }
+}

src/SeqCli/Cli/Commands/AppInstance/RemoveCommand.cs

@@ -0,0 +1,54 @@
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using SeqCli.Cli.Features;
+using SeqCli.Connection;
+using Serilog;
+
+namespace SeqCli.Cli.Commands.AppInstance;
+[Command("appinstance", "remove", "Remove an app instance from the server",
+    Example="seqcli appinstance remove -t 'Email Ops'")]
+
+class RemoveCommand : Command
+{
+    readonly SeqConnectionFactory _connectionFactory;
+
+    readonly EntityIdentityFeature _entityIdentity;
+    readonly ConnectionFeature _connection;
+
+    public RemoveCommand(SeqConnectionFactory connectionFactory)
+    {
+        _connectionFactory = connectionFactory ?? throw new ArgumentNullException(nameof(connectionFactory));
+
+        _entityIdentity = Enable(new EntityIdentityFeature("app instance", "remove"));
+        _connection = Enable<ConnectionFeature>();
+    }
+
+    protected override async Task<int> Run()
+    {
+        if (_entityIdentity.Title == null && _entityIdentity.Id == null)
+        {
+            Log.Error("A `title` or `id` must be specified");
+            return 1;
+        }
+
+        var connection = _connectionFactory.Connect(_connection);
+
+        var toRemove = _entityIdentity.Id != null ?
+            new[] {await connection.AppInstances.FindAsync(_entityIdentity.Id)} :
+            (await connection.AppInstances.ListAsync())
+            .Where(ak => _entityIdentity.Title == ak.Title) 
+            .ToArray();
+
+        if (!toRemove.Any())
+        {
+            Log.Error("No matching app instance was found");
+            return 1;
+        }
+
+        foreach (var appInstanceEntity in toRemove)
+            await connection.AppInstances.RemoveAsync(appInstanceEntity);
+
+        return 0;
+    }
+}

src/SeqCli/Cli/Commands/Dashboard/ListCommand.cs

@@ -49,13 +49,9 @@ protected override async Task<int> Run()
         var list = _entityIdentity.Id != null ?
             new[] { await connection.Dashboards.FindAsync(_entityIdentity.Id) } :
             (await connection.Dashboards.ListAsync(ownerId: _entityOwner.OwnerId, shared: _entityOwner.IncludeShared))
-            .Where(d => _entityIdentity.Title == null || _entityIdentity.Title == d.Title)
-            .ToArray();
+            .Where(d => _entityIdentity.Title == null || _entityIdentity.Title == d.Title);
 
-        foreach (var dashboardEntity in list)
-        {
-            _output.WriteEntity(dashboardEntity);
-        }
+        _output.ListEntities(list);
 
         return 0;
     }

src/SeqCli/Cli/Commands/Feed/ListCommand.cs

@@ -57,13 +57,9 @@ protected override async Task<int> Run()
         var list = _id != null ?
             new[] { await connection.Feeds.FindAsync(_id) } :
             (await connection.Feeds.ListAsync())
-            .Where(f => _name == null || _name == f.Name)
-            .ToArray();
+            .Where(f => _name == null || _name == f.Name);
 
-        foreach (var feed in list)
-        {
-            _output.WriteEntity(feed);
-        }
+        _output.ListEntities(list);
 
         return 0;
     }

src/SeqCli/Cli/Commands/HelpCommand.cs

@@ -179,13 +179,13 @@ void PrintHelp(string executableName)
             {
                 if (!printedGroups.Contains(avail.Metadata.Name))
                 {
-                    Printing.Define($"  {avail.Metadata.Name}", "<sub-command>", 13, Console.Out);
+                    Printing.Define($"  {avail.Metadata.Name}", "<sub-command>", Console.Out);
                     printedGroups.Add(avail.Metadata.Name);
                 }
             }
             else
             {
-                Printing.Define($"  {avail.Metadata.Name}", avail.Metadata.HelpText, 13, Console.Out);
+                Printing.Define($"  {avail.Metadata.Name}", avail.Metadata.HelpText, Console.Out);
             }
         }
 
@@ -201,7 +201,7 @@ void PrintHelp(string executableName, string topLevelCommand)
 
         foreach (var avail in _orderedCommands.Where(c => c.Metadata.Name == topLevelCommand))
         {
-            Printing.Define($"  {avail.Metadata.SubCommand}", avail.Metadata.HelpText, 13, Console.Out);
+            Printing.Define($"  {avail.Metadata.SubCommand}", avail.Metadata.HelpText, Console.Out);
         }
 
         Console.WriteLine();