more useful shared functions

Author: StuartFerguson

Shared/Authorisation/AuthorizationExtensions.cs

@@ -0,0 +1,78 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.Extensions.DependencyInjection;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Security.Claims;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Shared.Authorisation
+{
+    public static class AuthorizationExtensions {
+        public static IServiceCollection AddClientCredentialsHandler(this IServiceCollection services) {
+            services.AddSingleton<IAuthorizationHandler, ClientCredentialsHandler>();
+            return services;
+        }
+
+        public static IServiceCollection AddClientCredentialsOnlyPolicy(this IServiceCollection services) {
+            services.AddAuthorization(options => {
+                options.AddPolicy("ClientCredentialsOnly", policy => 
+                    policy.Requirements.Add(new ClientCredentialsRequirement()));
+            });
+
+            return services;
+        }
+
+        public static IServiceCollection AddPasswordTokenHandler(this IServiceCollection services)
+        {
+            services.AddSingleton<IAuthorizationHandler, PasswordTokenHandler>();
+            return services;
+        }
+
+        public static IServiceCollection AddPasswordTokenPolicy(this IServiceCollection services)
+        {
+            services.AddAuthorization(options =>
+            {
+                options.AddPolicy("PasswordToken", policy =>
+                    policy.Requirements.Add(new PasswordTokenRequirement()));
+            });
+
+            return services;
+        }
+
+
+        private sealed class PasswordTokenRequirement : IAuthorizationRequirement;
+
+        private sealed class ClientCredentialsRequirement : IAuthorizationRequirement;
+
+        private sealed class PasswordTokenHandler : AuthorizationHandler<PasswordTokenRequirement> {
+            protected override Task HandleRequirementAsync(AuthorizationHandlerContext context,
+                                                           PasswordTokenRequirement requirement) {
+                // Your logic from IsPasswordToken()
+                Claim? userIdClaim = context.User.Claims.SingleOrDefault(c => c.Type == ClaimTypes.NameIdentifier);
+
+                if (userIdClaim != null) {
+                    context.Succeed(requirement);
+                }
+
+                return Task.CompletedTask;
+            }
+        }
+
+        private sealed class ClientCredentialsHandler : AuthorizationHandler<ClientCredentialsRequirement> {
+            protected override Task HandleRequirementAsync(AuthorizationHandlerContext context,
+                                                           ClientCredentialsRequirement requirement) {
+                // A client credentials token *does not* include a NameIdentifier (user) claim.
+                bool isUserToken = context.User.HasClaim(c => c.Type == ClaimTypes.NameIdentifier);
+
+                if (!isUserToken) {
+                    context.Succeed(requirement); // Valid client credentials token
+                }
+
+                return Task.CompletedTask;
+            }
+        }
+
+    }
+}

Shared/Extensions/EndpointConventionBuilderExtensions.cs

@@ -1,13 +1,28 @@
-using Microsoft.AspNetCore.Builder;
+using System;
+using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Http;
 
 namespace Shared.Extensions;
 
 public static class EndpointConventionBuilderExtensions
 {
-    public static RouteHandlerBuilder WithStandardProduces<TSuccess, TError>(this RouteHandlerBuilder builder)
+    public static RouteHandlerBuilder WithStandardProduces<TSuccess, TError>(this RouteHandlerBuilder builder, Int32 successCode = StatusCodes.Status200OK)
     {
-        builder.Produces<TSuccess>(StatusCodes.Status200OK)
+        builder.Produces<TSuccess>(successCode)
+            .Produces<TError>(StatusCodes.Status400BadRequest)
+            .Produces<TError>(StatusCodes.Status404NotFound)
+            .Produces(StatusCodes.Status401Unauthorized)
+            .Produces<TError>(StatusCodes.Status409Conflict)
+            .Produces<TError>(StatusCodes.Status500InternalServerError)
+            .Produces(StatusCodes.Status403Forbidden)
+            .Produces<TError>(StatusCodes.Status501NotImplemented);
+
+        return builder;
+    }
+
+    public static RouteHandlerBuilder WithStandardProduces<TError>(this RouteHandlerBuilder builder, Int32 successCode = StatusCodes.Status200OK)
+    {
+        builder.Produces(successCode)
             .Produces<TError>(StatusCodes.Status400BadRequest)
             .Produces<TError>(StatusCodes.Status404NotFound)
             .Produces(StatusCodes.Status401Unauthorized)

Shared/General/SnakeCaseNamingPolicy.cs

@@ -0,0 +1,22 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Text.Json;
+using System.Threading.Tasks;
+
+namespace Shared.General
+{
+    public class SnakeCaseNamingPolicy : JsonNamingPolicy
+    {
+        public override string ConvertName(string name)
+        {
+            // simple PascalCase to snake_case
+            return string.Concat(
+                name.Select((c, i) =>
+                    i > 0 && char.IsUpper(c) ? "_" + char.ToLower(c) : char.ToLower(c).ToString()
+                )
+            );
+        }
+    }
+}