chore: alle Projekte in das Verzeichnis src verschieben

src/WorkFlow.API/Attributes/APIKeyAuthAttribute.cs

@@ -0,0 +1,14 @@
+using Microsoft.AspNetCore.Mvc;
+using WorkFlow.API.Filters;
+
+namespace WorkFlow.API.Attributes
+{
+    //TODO: move APIKeyAuthAttribute to Core.API
+    public class APIKeyAuthAttribute : ServiceFilterAttribute
+    {
+        public APIKeyAuthAttribute()
+            : base(typeof(APIKeyAuthFilter))
+        {
+        }
+    }
+}

src/WorkFlow.API/Controllers/ConfigController.cs

@@ -0,0 +1,20 @@
+using DigitalData.Core.API;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using WorkFlow.API.Attributes;
+using WorkFlow.Application.Contracts;
+using WorkFlow.Application.DTO.Config;
+using WorkFlow.Domain.Entities;
+
+namespace WorkFlow.API.Controllers;
+
+[APIKeyAuth]
+[Route("api/[controller]")]
+[ApiController]
+[Authorize]
+public class ConfigController : CRUDControllerBaseWithErrorHandling<IConfigService, ConfigCreateDto, ConfigDto, ConfigUpdateDto, Config, int>
+{
+    public ConfigController(ILogger<ConfigController> logger, IConfigService service) : base(logger, service)
+    {
+    }
+}

src/WorkFlow.API/Controllers/ControllerExtensions.cs

@@ -0,0 +1,96 @@
+using Microsoft.AspNetCore.Mvc;
+using System.Security.Claims;
+using WorkFlow.API.Attributes;
+
+namespace WorkFlow.API.Controllers
+{
+    [APIKeyAuth]
+    public static class ControllerExtensions
+    {
+        public static bool TryGetUserId(this ControllerBase controller, out int? id)
+        {
+            var value = controller.User.FindFirstValue(ClaimTypes.NameIdentifier);
+
+            if (value is null)
+            {
+                id = default;
+                return false;
+            }
+
+            if(int.TryParse(value, out int id_int))
+            {
+                id = id_int;
+                return true;
+            }
+            else
+            {
+                id = null;
+                return false;
+            }
+        }
+
+        public static bool TryGetUsername(this ControllerBase controller, out string username)
+        {
+            var value = controller.User.FindFirstValue(ClaimTypes.Name);
+
+            if (value is null)
+            {
+                username = string.Empty;
+                return false;
+            }
+            else
+            {
+                username = value;
+                return true;
+            }
+        }
+
+        public static bool TryGetName(this ControllerBase controller, out string name)
+        {
+            var value = controller.User.FindFirstValue(ClaimTypes.Surname);
+
+            if (value is null)
+            {
+                name = string.Empty;
+                return false;
+            }
+            else
+            {
+                name = value;
+                return true;
+            }
+        }
+
+        public static bool TryGetPrename(this ControllerBase controller, out string prename)
+        {
+            var value = controller.User.FindFirstValue(ClaimTypes.GivenName);
+
+            if (value is null)
+            {
+                prename = string.Empty;
+                return false;
+            }
+            else
+            {
+                prename = value;
+                return true;
+            }
+        }
+
+        public static bool TryGetEmail(this ControllerBase controller, out string email)
+        {
+            var value = controller.User.FindFirstValue(ClaimTypes.Email);
+
+            if (value is null)
+            {
+                email = string.Empty;
+                return false;
+            }
+            else
+            {
+                email = value;
+                return true;
+            }
+        }
+    }
+}

src/WorkFlow.API/Controllers/PlaceholderAuthController.cs

@@ -0,0 +1,24 @@
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Authorization;
+using WorkFlow.API.Models;
+using WorkFlow.API.Attributes;
+
+namespace WorkFlow.API.Controllers;
+
+//TODO: implement up-to-date AuthController in UserManager
+[APIKeyAuth]
+[Route("api/Auth")]
+[ApiController]
+[Tags("Auth")]
+public class PlaceholderAuthController : ControllerBase
+{
+    [HttpPost]
+    public IActionResult CreateTokenViaBody([FromBody] Login login)
+    {
+        throw new NotImplementedException();
+    }
+
+    [HttpGet("check")]
+    [Authorize]
+    public IActionResult Check() => Ok();
+}

src/WorkFlow.API/Controllers/ProfileController.cs

@@ -0,0 +1,20 @@
+using DigitalData.Core.API;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using WorkFlow.API.Attributes;
+using WorkFlow.Application.Contracts;
+using WorkFlow.Application.DTO.Profile;
+using WorkFlow.Domain.Entities;
+
+namespace WorkFlow.API.Controllers;
+
+[APIKeyAuth]
+[Route("api/[controller]")]
+[ApiController]
+[Authorize]
+public class ProfileController : CRUDControllerBaseWithErrorHandling<IProfileService, ProfileCreateDto, ProfileDto, ProfileUpdateDto, Profile, int>
+{
+    public ProfileController(ILogger<ProfileController> logger, IProfileService service) : base(logger, service)
+    {
+    }
+}

src/WorkFlow.API/Controllers/ProfileControlsTFController.cs

@@ -0,0 +1,126 @@
+using DigitalData.Core.API;
+using DigitalData.Core.DTO;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using WorkFlow.API.Attributes;
+using WorkFlow.Application.Contracts;
+using WorkFlow.Application.DTO.ProfileControlsTF;
+using WorkFlow.Domain.Entities;
+
+namespace WorkFlow.API.Controllers;
+
+[APIKeyAuth]
+[Route("api/[controller]")]
+[ApiController]
+[Authorize]
+public class ProfileControlsTFController : CRUDControllerBase<IProfileControlsTFService, ProfileControlsTFCreateDto, ProfileControlsTFDto, ProfileControlsTFUpdateDto, ProfileControlsTF, int>
+{
+    private readonly ILogger<ProfileControlsTFController> logger;
+
+    public ProfileControlsTFController(ILogger<ProfileControlsTFController> logger, IProfileControlsTFService service) : base(logger, service)
+    {
+        this.logger = logger;
+    }
+
+    [NonAction]
+    public override Task<IActionResult> GetAll() => base.GetAll();
+
+    [NonAction]
+    public override Task<IActionResult> Update(ProfileControlsTFUpdateDto updateDto) => base.Update(updateDto);
+
+    [HttpGet]
+    public async Task<IActionResult> GetAsync(
+        bool withProfile = true, bool withUser = false,
+        int? profileId = null, int? objId = null, bool? profileActive = null)
+    {
+        try
+        {
+            if (!this.TryGetUserId(out int? id))
+            {
+                logger.LogError("Authorization failed: User ID claim not found.");
+                return StatusCode(StatusCodes.Status500InternalServerError, "Failed to retrieve user identity.");
+            }
+            else if (id is null)
+            {
+                logger.LogError("Invalid user ID: Retrieved ID is null or not an integer.");
+                return StatusCode(StatusCodes.Status500InternalServerError, "Invalid user ID.");
+            }
+
+            return await _service.ReadAsync(
+                withProfile: withProfile, withUser: withUser,
+                userId: id,
+                profileId: profileId, objId: objId, profileActive: profileActive)
+                .ThenAsync(
+                    Success: pctf => pctf.Any() ? Ok(pctf) : NotFound(),
+                    Fail: IActionResult (msg, ntc) =>
+                    {
+                        logger.LogNotice(ntc);
+                        return NotFound();
+                    });
+        }
+        catch (Exception ex)
+        {
+            logger.LogError(ex, "An unexpected error occurred while processing the request: {Message}", ex.Message);
+            return StatusCode(StatusCodes.Status500InternalServerError, "An internal server error occurred.");
+        }
+    }
+
+    [HttpPost]
+    public override async Task<IActionResult> Create([FromBody] ProfileControlsTFCreateDto createDto)
+    {
+        try
+        {
+            if (!this.TryGetUserId(out int? id))
+            {
+                logger.LogError("Authorization failed: User ID claim not found.");
+                return StatusCode(StatusCodes.Status500InternalServerError, "Failed to retrieve user identity.");
+            }
+            else if (id is null)
+            {
+                logger.LogError("Invalid user ID: Retrieved ID is null or not an integer.");
+                return StatusCode(StatusCodes.Status500InternalServerError, "Invalid user ID.");
+            }
+
+            if (createDto.UserId != id)
+                return Unauthorized();
+
+            return await base.Create(createDto);
+        }
+        catch (Exception ex)
+        {
+            logger.LogError(ex, "An unexpected error occurred while processing the request: {Message}", ex.Message);
+            return StatusCode(StatusCodes.Status500InternalServerError, "An internal server error occurred.");
+        } 
+    }
+
+    [HttpDelete]
+    public override async Task<IActionResult> Delete([FromRoute] int id)
+    {
+        try
+        {
+            if (!this.TryGetUserId(out int? userId))
+            {
+                logger.LogError("Authorization failed: User ID claim not found.");
+                return StatusCode(StatusCodes.Status500InternalServerError, "Failed to retrieve user identity.");
+            }
+            else if (userId is null)
+            {
+                logger.LogError("Invalid user ID: Retrieved ID is null or not an integer.");
+                return StatusCode(StatusCodes.Status500InternalServerError, "Invalid user ID.");
+            }
+
+            return await _service.ReadByIdAsync(id).ThenAsync(
+                SuccessAsync: async pctf => pctf.UserId == userId ? await base.Delete(id) : Unauthorized(),
+                Fail: IActionResult (msg, ntc) =>
+                {
+                    _logger.LogNotice(ntc);
+                    return ntc.HasFlag(Flag.NotFound) ? NotFound() : StatusCode(StatusCodes.Status500InternalServerError);
+                });
+        }
+        catch (Exception ex)
+        {
+            logger.LogError(ex, "An unexpected error occurred while processing the request: {Message}", ex.Message);
+            return StatusCode(StatusCodes.Status500InternalServerError, "An internal server error occurred.");
+        }
+    }
+}

src/WorkFlow.API/Controllers/ProfileObjStateController.cs

@@ -0,0 +1,127 @@
+using DigitalData.Core.API;
+using DigitalData.Core.DTO;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using WorkFlow.API.Attributes;
+using WorkFlow.Application.Contracts;
+using WorkFlow.Application.DTO.ProfileObjState;
+using WorkFlow.Domain.Entities;
+
+namespace WorkFlow.API.Controllers
+{
+    [APIKeyAuth]
+    [Route("api/[controller]")]
+    [ApiController]
+    [Authorize]
+    public class ProfileObjStateController : CRUDControllerBaseWithErrorHandling<IProfileObjStateService, ProfileObjStateCreateDto, ProfileObjStateDto, ProfileObjStateUpdateDto, ProfileObjState, int>
+    {
+        private readonly ILogger<ProfileObjStateController> logger;
+
+        public ProfileObjStateController(ILogger<ProfileObjStateController> logger, IProfileObjStateService service) : base(logger, service)
+        {
+            this.logger = logger;
+        }
+
+        [NonAction]
+        public override Task<IActionResult> GetAll() => base.GetAll();
+
+        [NonAction]
+        public override Task<IActionResult> Update(ProfileObjStateUpdateDto updateDto) => base.Update(updateDto);
+
+        [HttpGet]
+        public async Task<IActionResult> GetAsync(
+            bool withProfile = true, bool withUser = true, bool withState = true,
+            int? profileId = null, int? objId = null, bool? profileActive = null)
+        {
+            try
+            {
+                if (!this.TryGetUserId(out int? id))
+                {
+                    logger.LogError("Authorization failed: User ID claim not found.");
+                    return StatusCode(StatusCodes.Status500InternalServerError, "Failed to retrieve user identity.");
+                }
+                else if (id is null)
+                {
+                    logger.LogError("Invalid user ID: Retrieved ID is null or not an integer.");
+                    return StatusCode(StatusCodes.Status500InternalServerError, "Invalid user ID.");
+                }
+
+                return await _service.ReadAsync(
+                    withProfile: withProfile, withUser: withUser, withState,
+                    userId: id,
+                    profileId: profileId, objId: objId, profileActive: profileActive)
+                    .ThenAsync(
+                        Success: pctf => pctf.Any() ? Ok(pctf) : NotFound(),
+                        Fail: IActionResult (msg, ntc) =>
+                        {
+                            logger.LogNotice(ntc);
+                            return NotFound();
+                        });
+            }
+            catch (Exception ex)
+            {
+                logger.LogError(ex, "An unexpected error occurred while processing the request: {Message}", ex.Message);
+                return StatusCode(StatusCodes.Status500InternalServerError, "An internal server error occurred.");
+            }
+        }
+
+        [HttpPost]
+        public override async Task<IActionResult> Create([FromBody] ProfileObjStateCreateDto createDto)
+        {
+            try
+            {
+                if (!this.TryGetUserId(out int? id))
+                {
+                    logger.LogError("Authorization failed: User ID claim not found.");
+                    return StatusCode(StatusCodes.Status500InternalServerError, "Failed to retrieve user identity.");
+                }
+                else if (id is null)
+                {
+                    logger.LogError("Invalid user ID: Retrieved ID is null or not an integer.");
+                    return StatusCode(StatusCodes.Status500InternalServerError, "Invalid user ID.");
+                }
+
+                if (createDto.UserId != id)
+                    return Unauthorized();
+
+                return await base.Create(createDto);
+            }
+            catch (Exception ex)
+            {
+                logger.LogError(ex, "An unexpected error occurred while processing the request: {Message}", ex.Message);
+                return StatusCode(StatusCodes.Status500InternalServerError, "An internal server error occurred.");
+            }
+        }
+
+        [HttpDelete]
+        public override async Task<IActionResult> Delete([FromRoute] int id)
+        {
+            try
+            {
+                if (!this.TryGetUserId(out int? userId))
+                {
+                    logger.LogError("Authorization failed: User ID claim not found.");
+                    return StatusCode(StatusCodes.Status500InternalServerError, "Failed to retrieve user identity.");
+                }
+                else if (userId is null)
+                {
+                    logger.LogError("Invalid user ID: Retrieved ID is null or not an integer.");
+                    return StatusCode(StatusCodes.Status500InternalServerError, "Invalid user ID.");
+                }
+
+                return await _service.ReadByIdAsync(id).ThenAsync(
+                    SuccessAsync: async pctf => pctf.UserId == userId ? await base.Delete(id) : Unauthorized(),
+                    Fail: IActionResult (msg, ntc) =>
+                    {
+                        _logger.LogNotice(ntc);
+                        return ntc.HasFlag(Flag.NotFound) ? NotFound() : StatusCode(StatusCodes.Status500InternalServerError);
+                    });
+            }
+            catch (Exception ex)
+            {
+                logger.LogError(ex, "An unexpected error occurred while processing the request: {Message}", ex.Message);
+                return StatusCode(StatusCodes.Status500InternalServerError, "An internal server error occurred.");
+            }
+        }
+    }
+}

src/WorkFlow.API/Controllers/StateController.cs

@@ -0,0 +1,20 @@
+using DigitalData.Core.API;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using WorkFlow.API.Attributes;
+using WorkFlow.Application.Contracts;
+using WorkFlow.Application.DTO.State;
+using WorkFlow.Domain.Entities;
+
+namespace WorkFlow.API.Controllers;
+
+[APIKeyAuth]
+[Route("api/[controller]")]
+[ApiController]
+[Authorize]
+public class StateController : CRUDControllerBaseWithErrorHandling<IStateService, StateCreateDto, StateDto, StateUpdateDto, State, int>
+{
+    public StateController(ILogger<StateController> logger, IStateService service) : base(logger, service)
+    {
+    }
+}

src/WorkFlow.API/Controllers/UserController.cs

@@ -0,0 +1,54 @@
+using DigitalData.Core.DTO;
+using DigitalData.UserManager.Application.Contracts;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using WorkFlow.API.Attributes;
+
+namespace WorkFlow.API.Controllers;
+
+[APIKeyAuth]
+[Route("api/[controller]")]
+[ApiController]
+[Authorize]
+public class UserController : ControllerBase
+{
+    private readonly ILogger<UserController> logger;
+    private readonly IUserService userService;
+
+    public UserController(ILogger<UserController> logger, IUserService userService)
+    {
+        this.logger = logger;
+        this.userService = userService;
+    }
+
+    [HttpGet]
+    public async Task<IActionResult> GetAsync()
+    {
+        try
+        {
+            if (!this.TryGetUserId(out int? id))
+            {
+                logger.LogError("Authorization failed: User ID claim not found.");
+                return StatusCode(StatusCodes.Status500InternalServerError, "Failed to retrieve user identity.");
+            }
+            else if(id is int id_int)
+                return await userService.ReadByIdAsync(id_int).ThenAsync(
+                    Success: Ok,
+                    Fail: IActionResult (msg, ntc) =>
+                    {
+                        logger.LogNotice(ntc);
+                        return NotFound();
+                    });
+            else
+            {
+                logger.LogError("Invalid user ID: Retrieved ID is null or not an integer.");
+                return StatusCode(StatusCodes.Status500InternalServerError, "Invalid user ID.");
+            }
+        }
+        catch (Exception ex)
+        {
+            logger.LogError(ex, "An unexpected error occurred while processing the request: {Message}", ex.Message);
+            return StatusCode(StatusCodes.Status500InternalServerError, "An internal server error occurred.");
+        }
+    }
+}

src/WorkFlow.API/Extensions/DIExtensions.cs

@@ -0,0 +1,22 @@
+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
+{
+    public static class DIExtensions
+    {
+        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, bool configureOptions = true)
+        {
+            if(configureOptions)
+                services.TryAddSingleton(Options.Create(options));
+
+            return services.AddAPIKeyAuth(isValidKey: key => options.Key is null || options.Key == key, headerName: options.HeaderName);
+        }
+    }
+}

src/WorkFlow.API/Filters/APIKeyAuthFilter.cs

@@ -0,0 +1,22 @@
+using Microsoft.AspNetCore.Mvc.Filters;
+using Microsoft.AspNetCore.Mvc;
+
+namespace WorkFlow.API.Filters;
+
+public class APIKeyAuthFilter : IAuthorizationFilter
+{
+    private readonly Func<string?, bool> isValidKey;
+    private readonly string headerName;
+
+    public APIKeyAuthFilter(Func<string?, bool> isValidKey, string headerName = "X-API-Key")
+    {
+        this.isValidKey = isValidKey;
+        this.headerName = headerName;
+    }
+
+    public void OnAuthorization(AuthorizationFilterContext context)
+    {
+        if (!isValidKey(context.HttpContext.Request.Headers[headerName]))
+            context.Result = new UnauthorizedResult();
+    }
+}

src/WorkFlow.API/Filters/APIKeyAuthHeaderOpFilter.cs

@@ -0,0 +1,42 @@
+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 : IOperationFilter
+{
+    private readonly APIKeyAuthOptions apiKeyAuthOptions;
+    private readonly IWebHostEnvironment environment;
+
+    public APIKeyAuthHeaderOpFilter(IOptions<APIKeyAuthOptions> options, IWebHostEnvironment environment)
+    {
+        this.environment = environment;
+        apiKeyAuthOptions = options.Value;
+    }
+
+    public void Apply(OpenApiOperation operation, OperationFilterContext context)
+    {
+        var param = new OpenApiParameter
+        {
+            Name = apiKeyAuthOptions.HeaderName,
+            In = ParameterLocation.Header,
+            Required = true,
+            AllowEmptyValue = false,
+            Schema = new OpenApiSchema
+            {
+                Type = "string"
+            }
+        };
+
+        if(environment.IsDevelopment())
+            param.Schema.Default = new OpenApiString(apiKeyAuthOptions.Key);
+
+        if (apiKeyAuthOptions.SwaggerDescription is not null)
+            param.Description = apiKeyAuthOptions.SwaggerDescription;
+
+        operation.Parameters.Add(param);
+    }
+}

src/WorkFlow.API/Jenkinsfile

@@ -0,0 +1,10 @@
+pipeline {
+    agent any
+    stages {
+        stage('Build') {
+            steps {
+                sh 'dotnet build'
+            }
+        }
+    }
+}

src/WorkFlow.API/LazyServiceProvider.cs

@@ -0,0 +1,18 @@
+namespace WorkFlow.API;
+
+public class LazyServiceProvider : IServiceProvider
+{
+    private Lazy<IServiceProvider>? _serviceProvider;
+
+    public Func<IServiceProvider> Factory 
+    {
+        set => _serviceProvider = new(value);
+    }
+
+    public object? GetService(Type serviceType)
+    {
+        if (_serviceProvider is null)
+            throw new InvalidOperationException("GetService cannot be called before _serviceProvider is set.");
+        return _serviceProvider.Value.GetService(serviceType);
+    }
+}

src/WorkFlow.API/Models/APIKeyAuthOptions.cs

@@ -0,0 +1,11 @@
+namespace WorkFlow.API.Models
+{
+    public class APIKeyAuthOptions
+    {
+        public string? Key { get; init; } = null;
+
+        public string HeaderName { get; init; } = "X-API-Key";
+
+        public string? SwaggerDescription { get; init; } = null;
+    }
+}

src/WorkFlow.API/Models/AuthTokenKeys.cs

@@ -0,0 +1,12 @@
+namespace WorkFlow.API.Models;
+
+public class AuthTokenKeys
+{
+    public string Cookie { get; init; } = "AuthToken";
+
+    public string QueryString { get; init; } = "AuthToken";
+
+    public string Issuer { get; init; } = "auth.digitaldata.works";
+
+    public string Audience { get; init; } = "work-flow.digitaldata.works";
+}

src/WorkFlow.API/Models/Login.cs

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

src/WorkFlow.API/Models/ModelExtensions.cs

@@ -0,0 +1,19 @@
+using DigitalData.UserManager.Application.DTOs.User;
+using System.Security.Claims;
+
+namespace WorkFlow.API.Models
+{
+    public static class ModelExtensions
+    {
+        public static List<Claim> ToClaimList(this UserReadDto user) => new()
+        {
+            new (ClaimTypes.NameIdentifier, user.Id.ToString()),
+            new (ClaimTypes.Name, user.Username),
+            new (ClaimTypes.Surname, user.Name ?? ""),
+            new (ClaimTypes.GivenName, user.Prename ?? ""),
+            new (ClaimTypes.Email, user.Email ?? "")
+        };
+
+        public static Dictionary<string, object> ToClaimDictionary(this UserReadDto user) => user.ToClaimList().ToDictionary(claim => claim.Type, claim => (object) claim.Value);
+    }
+}

src/WorkFlow.API/Program.cs

@@ -0,0 +1,161 @@
+using WorkFlow.Application;
+using DigitalData.UserManager.Application;
+using Microsoft.EntityFrameworkCore;
+using WorkFlow.Infrastructure;
+using DigitalData.Core.API;
+using DigitalData.Core.Application;
+using DigitalData.UserManager.Application.DTOs.User;
+using Microsoft.IdentityModel.Tokens;
+using WorkFlow.API.Models;
+using NLog;
+using NLog.Web;
+using WorkFlow.API.Extensions;
+using WorkFlow.API.Filters;
+using Microsoft.OpenApi.Models;
+using DigitalData.Auth.Client;
+using Microsoft.AspNetCore.Authentication.JwtBearer;
+using WorkFlow.API;
+using Microsoft.Extensions.Options;
+using DigitalData.Core.Abstractions.Security;
+
+var logger = LogManager.Setup().LoadConfigurationFromAppSettings().GetCurrentClassLogger();
+logger.Info("Logging initialized.");
+
+try
+{
+    var builder = WebApplication.CreateBuilder(args);
+    var config = builder.Configuration;
+
+    // Add NLogger
+    builder.Logging.ClearProviders();
+    builder.Host.UseNLog();
+
+    // Add services to the container
+    var cnn_str = config.GetConnectionString("Default") ?? throw new("Default connection string not found.");
+    builder.Services.AddDbContext<WFDBContext>(options => options.UseSqlServer(cnn_str).EnableDetailedErrors());
+    builder.Services.AddWorkFlow().AddUserManager<WFDBContext>();
+    builder.Services.AddCookieBasedLocalizer();
+    builder.Services.AddDirectorySearchService(config.GetSection("DirectorySearchOptions"));
+    builder.Services.AddJWTService<UserReadDto>(user => new SecurityTokenDescriptor()
+    {
+        Claims = user.ToClaimList().ToDictionary(claim => claim.Type, claim => claim.Value as object)
+    });
+
+    bool disableAPIKeyAuth = config.GetValue<bool>("DisableAPIKeyAuth") && builder.IsDevOrDiP();
+    if (disableAPIKeyAuth)
+        builder.Services.AddAPIKeyAuth(new APIKeyAuthOptions());
+    else
+        if (config.GetSection("APIKeyAuth").Get<APIKeyAuthOptions>() is APIKeyAuthOptions options)
+        builder.Services.AddAPIKeyAuth(options);
+    else
+        throw new("The API Key Authorization configuration is not available in the app settings, even though the app is not in development or DiP mode and API Key Authorization is not disabled.");
+
+    var lazyProvider = new LazyServiceProvider();
+
+    builder.Services.AddAuthHubClient(config.GetSection("AuthClientParams"));
+
+    builder.Services.AddControllers();
+
+    var authTokenKeys = config.GetSection(nameof(AuthTokenKeys)).Get<AuthTokenKeys>() ?? new();
+
+    builder.Services.AddAuthentication(options =>
+    {
+        options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
+        options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
+    })
+            .AddJwtBearer(opt =>
+        {
+            opt.TokenValidationParameters = new TokenValidationParameters
+            {
+                ValidateIssuerSigningKey = true,
+                IssuerSigningKeyResolver = (token, securityToken, identifier, parameters) =>
+                {
+                    var clientParams = lazyProvider.GetRequiredService<IOptions<ClientParams>>()?.Value;
+                    var publicKey = clientParams!.PublicKeys.Get(authTokenKeys.Issuer, authTokenKeys.Audience);
+                    return new List<SecurityKey>() { publicKey.SecurityKey };
+                },
+                ValidateIssuer = true,
+                ValidIssuer = authTokenKeys.Issuer,
+                ValidateAudience = true,
+                ValidAudience = authTokenKeys.Audience,
+            };
+
+            opt.Events = new JwtBearerEvents
+            {
+                OnMessageReceived = context =>
+                {
+                    // if there is no token read related cookie or query string
+                    if (context.Token is null)   // if there is no token
+                    {
+                        if (context.Request.Cookies.TryGetValue(authTokenKeys.Cookie, out var cookieToken) && cookieToken is not null)
+                            context.Token = cookieToken;
+                        else if (context.Request.Query.TryGetValue(authTokenKeys.QueryString, out var queryStrToken))
+                            context.Token = queryStrToken;
+                    }
+                    return Task.CompletedTask;
+                }
+            };
+        });
+
+    builder.Services.AddEndpointsApiExplorer();
+    builder.Services.AddSwaggerGen(setupAct =>
+    {
+        setupAct.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme
+        {
+            Description = "JWT Authorization header using the Bearer scheme. Example: \"Bearer {token}\"",
+            Name = "Authorization",
+            In = ParameterLocation.Header,
+            Type = SecuritySchemeType.Http,
+            Scheme = "Bearer"
+        });
+
+        setupAct.AddSecurityRequirement(new OpenApiSecurityRequirement
+        {
+            {
+                new OpenApiSecurityScheme
+                {
+                    Reference = new OpenApiReference
+                    {
+                        Type = ReferenceType.SecurityScheme,
+                        Id = "Bearer"
+                    }
+                },
+                Array.Empty<string>()
+            }
+        });
+
+        if (!disableAPIKeyAuth)
+            setupAct.OperationFilter<APIKeyAuthHeaderOpFilter>();
+
+        if (config.GetSection("OpenApiInfo").Get<OpenApiInfo>() is OpenApiInfo openApiInfo)
+            setupAct.SwaggerDoc(openApiInfo?.Version ?? "v1", openApiInfo);
+    });
+
+    var app = builder.Build();
+
+    lazyProvider.Factory = () => app.Services;
+
+    // Configure the HTTP request pipeline.
+    if (app.IsDevOrDiP() && app.Configuration.GetValue<bool>("EnableSwagger"))
+    {
+        app.UseSwagger();
+        app.UseSwaggerUI();
+    }
+
+    app.UseHttpsRedirection();
+
+    app.UseAuthentication();
+
+    app.UseAuthorization();
+
+    app.UseCookieBasedLocalizer("de-DE");
+
+    app.MapControllers();
+
+    app.Run();
+}
+catch (Exception ex)
+{
+    logger.Error(ex, "Stopped program because of exception.");
+    throw;
+}

src/WorkFlow.API/Properties/launchSettings.json

@@ -0,0 +1,41 @@
+{
+  "$schema": "http://json.schemastore.org/launchsettings.json",
+  "iisSettings": {
+    "windowsAuthentication": false,
+    "anonymousAuthentication": true,
+    "iisExpress": {
+      "applicationUrl": "http://localhost:56180",
+      "sslPort": 44397
+    }
+  },
+  "profiles": {
+    "http": {
+      "commandName": "Project",
+      "dotnetRunMessages": true,
+      "launchBrowser": false,
+      "launchUrl": "swagger",
+      "applicationUrl": "http://localhost:5130",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    },
+    "https": {
+      "commandName": "Project",
+      "dotnetRunMessages": true,
+      "launchBrowser": false,
+      "launchUrl": "swagger",
+      "applicationUrl": "https://localhost:7120;http://localhost:5130",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    },
+    "IIS Express": {
+      "commandName": "IISExpress",
+      "launchBrowser": false,
+      "launchUrl": "swagger",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    }
+  }
+}

src/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);
+    }
+}

src/WorkFlow.API/WorkFlow.API.csproj

@@ -0,0 +1,35 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+
+  <PropertyGroup>
+    <TargetFrameworks>net7.0;net8.0</TargetFrameworks>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <PackageId>WorkFlow.API</PackageId>
+    <Version>1.1.0</Version>
+    <Company>Digital Data GmbH</Company>
+    <Product>WorkFlow.API</Product>
+    <Title>WorkFlow.API</Title>
+    <AssemblyVersion>1.1.0</AssemblyVersion>
+    <FileVersion>1.1.0</FileVersion>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <_WebToolingArtifacts Remove="Properties\PublishProfiles\IISProfile - Copy.pubxml" />
+    <_WebToolingArtifacts Remove="Properties\PublishProfiles\IISProfileNet7.pubxml" />
+    <_WebToolingArtifacts Remove="Properties\PublishProfiles\IISProfileNet8.pubxml" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="DigitalData.Auth.Client" Version="1.3.3" />
+    <PackageReference Include="DigitalData.Core.API" Version="2.1.1" />
+    <PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="7.0.20" />
+    <PackageReference Include="NLog" Version="5.3.4" />
+    <PackageReference Include="NLog.Web.AspNetCore" Version="5.3.14" />
+    <PackageReference Include="Swashbuckle.AspNetCore" Version="6.4.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\WorkFlow.Application\WorkFlow.Application.csproj" />
+  </ItemGroup>
+
+</Project>

src/WorkFlow.API/appsettings.Development.json

@@ -0,0 +1,8 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft.AspNetCore": "Warning"
+    }
+  }
+}

src/WorkFlow.API/appsettings.json

@@ -0,0 +1,91 @@
+{
+  "DiPMode": true,
+  "EnableSwagger": true,
+  "DisableAPIKeyAuth": false,
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft.AspNetCore": "Warning"
+    }
+  },
+  "NLog": {
+    "throwConfigExceptions": true,
+    "variables": {
+      "logDirectory": "E:\\LogFiles\\Digital Data\\workFlow.API",
+      "logFileNamePrefix": "${shortdate}-workFlow.API"
+    },
+    "targets": {
+      "infoLogs": {
+        "type": "File",
+        "fileName": "${logDirectory}\\${logFileNamePrefix}-Info.log",
+        "maxArchiveDays": 30
+      },
+      "errorLogs": {
+        "type": "File",
+        "fileName": "${logDirectory}\\${logFileNamePrefix}-Error.log",
+        "maxArchiveDays": 30
+      },
+      "criticalLogs": {
+        "type": "File",
+        "fileName": "${logDirectory}\\${logFileNamePrefix}-Critical.log",
+        "maxArchiveDays": 30
+      }
+    },
+    // Trace, Debug, Info, Warn, Error and *Fatal*
+    "rules": [
+      {
+        "logger": "*",
+        "minLevel": "Info",
+        "maxLevel": "Warn",
+        "writeTo": "infoLogs"
+      },
+      {
+        "logger": "*",
+        "level": "Error",
+        "writeTo": "errorLogs"
+      },
+      {
+        "logger": "*",
+        "level": "Fatal",
+        "writeTo": "criticalLogs"
+      }
+    ]
+  },
+  "AllowedHosts": "*",
+  "ConnectionStrings": {
+    "Default": "Server=SDD-VMP04-SQL17\\DD_DEVELOP01;Database=DD_ECM;User Id=sa;Password=dd;Encrypt=false;TrustServerCertificate=True;"
+  },
+  "DirectorySearchOptions": {
+    "ServerName": "DD-VMP01-DC01",
+    "Root": "DC=dd-gan,DC=local,DC=digitaldata,DC=works",
+    "UserCacheExpirationDays": 1,
+    "CustomSearchFilters": {
+      "User": "(&(objectClass=user)(sAMAccountName=*))",
+      "Group": "(&(objectClass=group) (samAccountName=*))"
+    }
+  },
+  "APIKeyAuth": {
+    "Key": "ULbcOUiAXAoCXPviyCGtObZUGnrCHNgDmtNbQNpq5MOhB0EFQn18dObdQ93INNy8xIcnOPMJfEHqOotllELVrJ2R5AjqOfQszT2j00w215GanD3UiJGwFhwmdoNFsmNj",
+    "HeaderName": "X-API-Key",
+    "SwaggerDescription": "Required header for API key authentication. Enter a valid API key."
+  },
+  "OpenApiInfo": {
+    "Title": "WorkFlow API",
+    "Contact": {
+      "Email": "info-flow@digitaldata.works",
+      "Name": "Digital Data GmbH",
+      "Url": "https://digitaldata.works/"
+    }
+  },
+  "AuthClientParams": {
+    "Url": "https://localhost:7192/auth-hub",
+    "PublicKeys": [
+      {
+        "Issuer": "auth.digitaldata.works",
+        "Audience": "work-flow.digitaldata.works",
+        "Content": "-----BEGIN PUBLIC KEY-----MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA3QCd7dH/xOUITFZbitMa/xnh8a0LyL6ZBvSRAwkI9ceplTRSHJXoM1oB+xtjWE1kOuHVLe941Tm03szS4+/rHIm0Ejva/KKlv7sPFAHE/pWuoPS303vOHgI4HAFcuwywA8CghUWzaaK5LU/Hl8srWwxBHv5hKIUjJFJygeAIENvFOZ1gFbB3MPEC99PiPOwAmfl4tMQUmSsFyspl/RWVi7bTv26ZE+m3KPcWppmvmYjXlSitxRaySxnfFvpca/qWfd/uUUg2KWKtpAwWVkqr0qD9v3TyKSgHoGDsrFpwSx8qufUJSinmZ1u/0iKl6TXeHubYS4C4SUSVjOWXymI2ZQIDAQAB-----END PUBLIC KEY-----"
+      }
+    ],
+    "RetryDelay": "00:00:05"
+  }
+}