refactor: AuthController-Methoden optimieren und Login-Logik verbessern

- AuthController aktualisiert, um eine klarere Struktur zu implementieren.
- Login-Methode vereinfacht, um die Benutzerauthentifizierung direkt zu behandeln.
- Neue LoginById-Methode für den Benutzerlogin über ID eingeführt.
- Fehlerprotokollierung und -behandlung in den Login-Methoden verbessert.
- Überflüssigen Code entfernt und Lesbarkeit verbessert.
- TODO für weitere Integration mit UserManager hinzugefügt.

WorkFlow.API/Attributes/ApiKeyAuthAttribute.cs

@@ -3,6 +3,7 @@ using WorkFlow.API.Filters;
 
 namespace WorkFlow.API.Attributes
 {
+    //TODO: move APIKeyAuthAttribute to Core.API
     public class APIKeyAuthAttribute : ServiceFilterAttribute
     {
         public APIKeyAuthAttribute()

WorkFlow.API/Controllers/AuthController.cs

@@ -14,17 +14,12 @@ using WorkFlow.API.Attributes;
 
 namespace WorkFlow.API.Controllers
 {
+    //TODO: implement up-to-date AuthController in UserManager
     [APIKeyAuth]
     [Route("api/[controller]")]
     [ApiController]
-    public class AuthController(IUserService userService, IGroupOfUserService gouService, IDirectorySearchService directorySearchService, IStringLocalizer<Resource> localizer, ILogger<AuthController> logger) : ControllerBase
+    public class AuthController(IUserService userService, IDirectorySearchService dirSearchService, IStringLocalizer<Resource> localizer, ILogger<AuthController> logger) : ControllerBase
     {
-        private readonly IUserService _userService = userService;
-        private readonly IGroupOfUserService _gouService = gouService;
-        private readonly IDirectorySearchService _dirSearchService = directorySearchService;
-        private readonly IStringLocalizer<Resource> _localizer = localizer;
-        private readonly ILogger<AuthController> _logger = logger;
-
         [AllowAnonymous]
         [HttpGet("check")]
         public IActionResult CheckAuthentication()
@@ -35,76 +30,81 @@ namespace WorkFlow.API.Controllers
             }
             catch(Exception ex)
             {
-                _logger.LogError(ex, "{Message}", ex.Message);
+                logger.LogError(ex, "{Message}", ex.Message);
                 return StatusCode(StatusCodes.Status500InternalServerError);
             }
         }
 
+        [NonAction]
+        public async Task<IActionResult> Login(UserReadDto user)
+        {
+            // Create claimsIdentity
+            var claimsIdentity = new ClaimsIdentity(user.ToClaimList(), CookieAuthenticationDefaults.AuthenticationScheme);
+
+            // Create authProperties
+            var authProperties = new AuthenticationProperties
+            {
+                IsPersistent = true,
+                AllowRefresh = true,
+                ExpiresUtc = DateTime.UtcNow.AddMinutes(60)
+            };
+
+            // Sign in
+            await HttpContext.SignInAsync(
+                CookieAuthenticationDefaults.AuthenticationScheme,
+                new ClaimsPrincipal(claimsIdentity),
+                authProperties);
+
+            return Ok();
+        }
+
         [AllowAnonymous]
         [HttpPost("login")]
         public async Task<IActionResult> Login([FromBody] Login login)
         {
             try
             {
-                var username = string.Empty;
+                return dirSearchService.ValidateCredentials(login.Username, login.Password)
-                DataResult<UserReadDto>? uRes = null;
+                    ? await userService.ReadByUsernameAsync(login.Username).ThenAsync(
-
+                        SuccessAsync: Login,
-                if(login.Username is not null && login.UserId is not null)
+                        Fail: IActionResult (msg, ntc) =>
-                    return BadRequest("Invalid request: either 'UserId' or 'Username' must be provided, but not both.");
+                        {
-                else if(login.Username is not null)
+                            logger.LogNotice(ntc);
-                    username = login.Username;
+                            logger.LogError("User could not be found, although verified by directory-search-service. It needs to be imported by UserManager. User name is {username}.", login.Username);
-                else if(login.UserId is int userId)
+                            return StatusCode(StatusCodes.Status500InternalServerError);
-                {
+                        })
-                    uRes = await _userService.ReadByIdAsync(userId);
+                    : Unauthorized(localizer[WFKey.UserNotFoundOrWrongPassword].Value);
-                    if (!uRes.IsSuccess || uRes.Data is null)
-                    {
-                        return Unauthorized(uRes);
-                    }
-                }
-                else
-                    return BadRequest("Invalid request: either 'UserId' or 'Username' must be provided, but not both.");
-
-                bool isValid = _dirSearchService.ValidateCredentials(username, login.Password);
-
-                if (!isValid)
-                    return Unauthorized(Result.Fail().Message(_localizer[Key.UserNotFound]));
-
-                var gouMsg = await _gouService.HasGroup(username, "PM_USER", caseSensitive: false);
-                if (!gouMsg.IsSuccess)
-                    return Unauthorized(Result.Fail().Message(_localizer[Key.UnauthorizedUser]));
-
-                //find the user
-                uRes ??= await _userService.ReadByUsernameAsync(username);
-                if (!uRes.IsSuccess || uRes.Data is null)
-                {
-                    _logger.LogNotice(uRes.Notices);
-                    return Unauthorized();
-                }
-
-                UserReadDto user = uRes.Data;
-
-                // Create claimsIdentity
-                var claimsIdentity = new ClaimsIdentity(user.ToClaimList(), CookieAuthenticationDefaults.AuthenticationScheme);
-
-                // Create authProperties
-                var authProperties = new AuthenticationProperties
-                {
-                    IsPersistent = true,
-                    AllowRefresh = true,
-                    ExpiresUtc = DateTime.UtcNow.AddMinutes(60)
-                };
-
-                // Sign in
-                await HttpContext.SignInAsync(
-                    CookieAuthenticationDefaults.AuthenticationScheme,
-                    new ClaimsPrincipal(claimsIdentity),
-                    authProperties);
-
-                return Ok();
             }
             catch(Exception ex)
             {
-                _logger.LogError(ex, "{Message}", ex.Message);
+                logger.LogError(ex, "{Message}", ex.Message);
+                return StatusCode(StatusCodes.Status500InternalServerError);
+            }
+        }
+
+        [AllowAnonymous]
+        [HttpPost("login/{id}")]
+        public async Task<IActionResult> LoginById([FromRoute] int id, [FromQuery] string password)
+        {
+            try
+            {
+                return await userService.ReadByIdAsync(id).ThenAsync(
+                    SuccessAsync: async user
+                        => dirSearchService.ValidateCredentials(user.Username, password)
+                            ? await Login(user)
+                            : Unauthorized(localizer[WFKey.WrongPassword].Value),
+                    Fail: (msg, ntc) =>
+                    {
+                        if (ntc.HasFlag(Flag.NotFound))
+                            return Unauthorized(Key.UserNotFound);
+
+                        logger.LogNotice(ntc);
+                        return StatusCode(StatusCodes.Status500InternalServerError);
+                    });               
+            }
+            catch (Exception ex)
+            {
+                logger.LogError(ex, "{Message}", ex.Message);
                 return StatusCode(StatusCodes.Status500InternalServerError);
             }
         }
@@ -121,16 +121,16 @@ namespace WorkFlow.API.Controllers
                 if (string.IsNullOrEmpty(username))
                     return Unauthorized();
 
-                return await _userService.ReadByUsernameAsync(username)
+                return await userService.ReadByUsernameAsync(username)
                     .ThenAsync(Ok, IActionResult (m, n) =>
                     {
-                        _logger.LogNotice(n);
+                        logger.LogNotice(n);
-                        return NotFound(Result.Fail().Message(_localizer[Key.UserNotFound]));
+                        return NotFound(Result.Fail().Message(localizer[Key.UserNotFound].Value));
                     });
             }
             catch (Exception ex)
             {
-                _logger.LogError(ex, "{Message}", ex.Message);
+                logger.LogError(ex, "{Message}", ex.Message);
                 return StatusCode(StatusCodes.Status500InternalServerError);
             }
         }
@@ -146,7 +146,7 @@ namespace WorkFlow.API.Controllers
             }
             catch(Exception ex)
             {
-                _logger.LogError(ex, "{Message}", ex.Message);
+                logger.LogError(ex, "{Message}", ex.Message);
                 return StatusCode(StatusCodes.Status500InternalServerError);
             }
         }

WorkFlow.API/Extensions/DIExtensions.cs

@@ -1,4 +1,7 @@
-using WorkFlow.API.Filters;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection.Extensions;
+using Microsoft.Extensions.Options;
+using WorkFlow.API.Filters;
 using WorkFlow.API.Models;
 
 namespace WorkFlow.API.Extensions
@@ -8,7 +11,12 @@ namespace WorkFlow.API.Extensions
         public static IServiceCollection AddAPIKeyAuth(this IServiceCollection services, Func<string?, bool> isValidKey, string headerName = "X-API-Key")
             => services.AddSingleton<APIKeyAuthFilter>(provider => new(isValidKey: isValidKey, headerName: headerName));
 
-        public static IServiceCollection AddAPIKeyAuth(this IServiceCollection services, APIKeyAuthOptions options)
+        public static IServiceCollection AddAPIKeyAuth(this IServiceCollection services, APIKeyAuthOptions options, bool configureOptions = true)
-            => services.AddAPIKeyAuth(isValidKey: key => options.Key is null || options.Key == key, headerName: options.HeaderName);
+        {
+            if(configureOptions)
+                services.TryAddSingleton(Options.Create(options));
+
+            return services.AddAPIKeyAuth(isValidKey: key => options.Key is null || options.Key == key, headerName: options.HeaderName);
+        }
     }
 }

WorkFlow.API/Filters/APIKeyAuthHeaderOpFilter.cs

@@ -1,11 +1,12 @@
 using Microsoft.Extensions.Options;
+using Microsoft.OpenApi.Any;
 using Microsoft.OpenApi.Models;
 using Swashbuckle.AspNetCore.SwaggerGen;
 using WorkFlow.API.Models;
 
 namespace WorkFlow.API.Filters
 {
-    public class APIKeyAuthHeaderOpFilter(IOptions<APIKeyAuthOptions> options) : IOperationFilter
+    public class APIKeyAuthHeaderOpFilter(IOptions<APIKeyAuthOptions> options, IWebHostEnvironment environment) : IOperationFilter
     {
         private readonly APIKeyAuthOptions apiKeyAuthOptions = options.Value;
 
@@ -23,10 +24,13 @@ namespace WorkFlow.API.Filters
                 }
             };
 
-            if(apiKeyAuthOptions.SwaggerDescription is not null)
+            if(environment.IsDevelopment())
+                param.Schema.Default = new OpenApiString(apiKeyAuthOptions.Key);
+
+            if (apiKeyAuthOptions.SwaggerDescription is not null)
                 param.Description = apiKeyAuthOptions.SwaggerDescription;
 
-            operation.Parameters = [param];
+            operation.Parameters.Add(param);
         }
     }
 }

WorkFlow.API/Models/Login.cs

@@ -1,4 +1,4 @@
 namespace WorkFlow.API.Models
 {
-    public record Login(int? UserId, string? Username, string Password);
+    public record Login(string Username, string Password);
 }

WorkFlow.API/Program.cs

@@ -40,7 +40,7 @@ try
 
     bool disableAPIKeyAuth = config.GetValue<bool>("DisableAPIKeyAuth") && builder.IsDevOrDiP();
     if (disableAPIKeyAuth)
-        builder.Services.AddAPIKeyAuth(new());
+        builder.Services.AddAPIKeyAuth(new APIKeyAuthOptions());
     else        
         if (config.GetSection("APIKeyAuth").Get<APIKeyAuthOptions>() is APIKeyAuthOptions options)
             builder.Services.AddAPIKeyAuth(options);        

WorkFlow.API/WFKey.cs

@@ -0,0 +1,8 @@
+namespace WorkFlow.API
+{
+    public static class WFKey
+    {
+        public static readonly string WrongPassword = nameof(WrongPassword);
+        public static readonly string UserNotFoundOrWrongPassword = nameof(UserNotFoundOrWrongPassword);
+    }
+}