Merge pull request #13 from FiniteReality/feature/user-info

Expose APIs for specifying user information in a platform agnostic way

Directory.Build.props

@@ -48,7 +48,7 @@
     <PackageOutputPath Condition="'$(PlatformName)' == 'AnyCPU'">$(BaseArtifactsPath)pkg/$(Configuration)</PackageOutputPath>
     <PackageOutputPath Condition="'$(PlatformName)' != 'AnyCPU'">$(BaseArtifactsPath)pkg/$(Configuration)</PackageOutputPath>
     <Product>Finite.Commands</Product>
-    <VersionPrefix>0.3.0</VersionPrefix>
+    <VersionPrefix>0.3.1</VersionPrefix>
     <VersionSuffix>alpha</VersionSuffix>
     <VersionSuffix Condition="'$(PullRequestNumber)' != ''">pr$(PullRequestNumber)</VersionSuffix>
   </PropertyGroup>

samples/Console/Authentication/PlatformUserMiddleware.cs

@@ -0,0 +1,68 @@
+using System;
+using System.Linq;
+using System.Security.Claims;
+using System.Security.Principal;
+using System.Threading;
+using System.Threading.Tasks;
+using Finite.Commands;
+using Microsoft.Extensions.Logging;
+
+namespace ConsoleCommands.Authentication
+{
+    internal class PlatformUserMiddleware : ICommandMiddleware
+    {
+        private static readonly Random Rng = new Random();
+        private readonly ILogger _logger;
+
+        public PlatformUserMiddleware(ILogger<PlatformUserMiddleware> logger)
+        {
+            _logger = logger;
+        }
+
+        public ValueTask<ICommandResult> ExecuteAsync(CommandMiddleware next,
+            CommandContext context, CancellationToken cancellationToken)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            if (OperatingSystem.IsWindows())
+            {
+                var identity = WindowsIdentity.GetCurrent();
+
+                context.User.AddIdentity(identity);
+            }
+            else
+            {
+                context.User.AddIdentity(
+                    new ClaimsIdentity(
+                        new[]
+                        {
+                            new Claim(ClaimTypes.Name, Environment.UserName),
+                        }
+                    ));
+            }
+
+            if (Rng.NextDouble() > 0.5)
+            {
+                _logger.LogDebug("Adding cool role");
+                context.User.AddIdentity(
+                    new ClaimsIdentity(
+                        new[]
+                        {
+                            new Claim(ClaimTypes.Role, "Cool")
+                        }
+                    ));
+            }
+
+            var nameClaim = context.User
+                .FindFirst(x => x.Type == ClaimTypes.Name);
+
+            if (nameClaim != null)
+                _logger.LogInformation("Loaded user identity as {name}",
+                    nameClaim.Value);
+            else
+                _logger.LogWarning("Unable to load user identity");
+
+            return next();
+        }
+    }
+}

samples/Console/Program.cs

@@ -1,10 +1,10 @@
 using System;
 using System.Threading;
 using System.Threading.Tasks;
+using ConsoleCommands.Authentication;
 using Finite.Commands;
 using Finite.Commands.Parsing;
 using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.DependencyInjection.Extensions;
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
 
@@ -25,11 +25,14 @@ private static void ConfigureServices(HostBuilderContext context,
             // (PR was not merged for .NET 5.0)
             _ = services.Configure<HostOptions>(x => x.ShutdownTimeout = TimeSpan.Zero);
 
+            _ = services.AddSingleton<PlatformUserMiddleware>();
+
             _ = services.AddCommands()
                 .AddPositionalCommandParser()
                 .AddAttributedCommands(x => x.Assemblies.Add(
                     typeof(Program).Assembly.Location))
-                .Use(TestMiddlewareAsync);
+                .Use(TestMiddlewareAsync)
+                .Use<PlatformUserMiddleware>();
 
             _ = services.AddHostedService<LineReaderService>();
         }

samples/Console/TestCommands/HelloWorldCommand.cs

@@ -31,6 +31,15 @@ public ValueTask<ICommandResult> HelloWorldCommand(
                 coolParameter,
                 coolerParameter);
 
+            if (Context.User.IsInRole("Cool"))
+            {
+                _logger.LogInformation("The user is very cool!");
+            }
+            else
+            {
+                _logger.LogInformation("The user is not cool.");
+            }
+
             return new ValueTask<ICommandResult>(new NoContentCommandResult());
         }
     }

src/Abstractions/CommandContext.cs

@@ -1,6 +1,6 @@
 using System;
 using System.Collections.Generic;
-using System.Threading;
+using System.Security.Claims;
 
 namespace Finite.Commands
 {
@@ -26,6 +26,11 @@ public abstract class CommandContext
         /// </summary>
         public abstract IDictionary<string, object?> Parameters { get; set; }
 
+        /// <summary>
+        /// Gets or sets the user for this cmomand.
+        /// </summary>
+        public abstract ClaimsPrincipal User { get; set; }
+
         /// <summary>
         /// Gets or sets the command to execute.
         /// </summary>

src/Core/CommandsBuilderMiddlewareExtensions.cs

@@ -0,0 +1,45 @@
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection.Extensions;
+
+namespace Finite.Commands
+{
+    /// <summary>
+    /// Extension methods for adding middleware to
+    /// an <see cref="ICommandsBuilder"/>.
+    /// </summary>
+    public static class CommandsBuilderMiddlewareExtensions
+    {
+        /// <summary>
+        /// Adds a middleware object to the command pipeline.
+        /// </summary>
+        /// <param name="builder">
+        /// The commands builder to add middleware to.
+        /// </param>
+        /// <typeparam name="TMiddleware">
+        /// The type of middleware to add to the command pipeline.
+        /// </typeparam>
+        /// <returns>
+        /// The builder.
+        /// </returns>
+        public static ICommandsBuilder Use<TMiddleware>(
+            this ICommandsBuilder builder)
+            where TMiddleware : ICommandMiddleware
+        {
+
+            return builder.Use(
+                static (n, c, ct) => ExecuteMiddleware(n, c, ct));
+
+            static ValueTask<ICommandResult> ExecuteMiddleware(
+                CommandMiddleware next, CommandContext context,
+                CancellationToken cancellationToken)
+            {
+                var middleware = context.Services
+                    .GetRequiredService<TMiddleware>();
+
+                return middleware.ExecuteAsync(next, context, cancellationToken);
+            }
+        }
+    }
+}

src/Core/ICommandMiddleware.cs

@@ -0,0 +1,31 @@
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Finite.Commands
+{
+    /// <summary>
+    /// Defines an interface which can be used to define middleware using a
+    /// type.
+    /// </summary>
+    public interface ICommandMiddleware
+    {
+        /// <summary>
+        /// Executes the middleware.
+        /// </summary>
+        /// <param name="next">
+        /// A callback used to transfer control in the middleware pipeline.
+        /// </param>
+        /// <param name="context">
+        /// The command context to execute.
+        /// </param>
+        /// <param name="cancellationToken">
+        /// A cancellation token, indicating cancellation of processing.
+        /// </param>
+        /// <returns>
+        /// A task that represents the completion of command processing.
+        /// </returns>
+        public ValueTask<ICommandResult> ExecuteAsync(
+            CommandMiddleware next, CommandContext context,
+            CancellationToken cancellationToken);
+    }
+}

src/Core/ICommandsBuilder.cs

@@ -6,7 +6,7 @@
 namespace Finite.Commands
 {
     /// <summary>
-    /// An interface for configuring commands services.
+    /// Defines an interface for configuring commands services.
     /// </summary>
     public interface ICommandsBuilder
     {
@@ -17,7 +17,7 @@ public interface ICommandsBuilder
         IServiceCollection Services { get; }
 
         /// <summary>
-        /// Adds the middleware to the command pipeline.
+        /// Adds middleware to the command pipeline.
         /// </summary>
         /// <param name="middleware">
         /// The middleware.

src/Core/Internal/DefaultCommandContext.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Security.Claims;
 using Microsoft.Extensions.DependencyInjection;
 
 namespace Finite.Commands
@@ -12,6 +13,10 @@ internal sealed class DefaultCommandContext : CommandContext
             = new Dictionary<object, object?>();
         public override IDictionary<string, object?> Parameters { get; set; }
             = new Dictionary<string, object?>();
+
+        public override ClaimsPrincipal User { get; set; }
+            = new ClaimsPrincipal(new ClaimsIdentity());
+
         public override ICommand Command { get; set; } = null!;
 
         public override IServiceProvider Services