Bump version to 1.1.1 in project file

Updated DigitalData.Core.Exceptions.csproj to set <Version>, <AssemblyVersion>, and <FileVersion> to 1.1.1, replacing the previous 1.1.0 values. No other changes were made.

DigitalData.Core.API/BasicCRUDControllerBase.cs

@@ -1,4 +1,4 @@
-using DigitalData.Core.Application.Interfaces;
+using DigitalData.Core.Abstraction.Application;
 using Microsoft.AspNetCore.Mvc;
 
 namespace DigitalData.Core.API

DigitalData.Core.API/CRUDControllerBase.cs

@@ -1,6 +1,6 @@
-using DigitalData.Core.Application.Interfaces;
 using Microsoft.AspNetCore.Mvc;
-using DigitalData.Core.Application.DTO;
+using DigitalData.Core.Abstraction.Application;
+using DigitalData.Core.Abstraction.Application.DTO;
 
 namespace DigitalData.Core.API
 {
@@ -46,10 +46,10 @@ namespace DigitalData.Core.API
         [HttpPost]
         public virtual async Task<IActionResult> Create(TCreateDto createDto)
         {
-            return await _service.CreateAsync(createDto).ThenAsync<TId, IActionResult>(
-                Success: id =>
+            return await _service.CreateAsync(createDto).ThenAsync<TReadDto, IActionResult>(
+                Success: dto =>
                 {
-                    var createdResource = new { Id = id };
+                    var createdResource = new { Id = dto.GetId() };
                     var actionName = nameof(GetById);
                     var routeValues = new { id = createdResource.Id };
                     return CreatedAtAction(actionName, routeValues, createdResource);

DigitalData.Core.API/CRUDControllerBaseWithErrorHandling.cs

@@ -1,6 +1,6 @@
-using DigitalData.Core.Application.Interfaces;
 using Microsoft.AspNetCore.Mvc;
-using DigitalData.Core.Application.DTO;
+using DigitalData.Core.Abstraction.Application;
+using DigitalData.Core.Abstraction.Application.DTO;
 
 namespace DigitalData.Core.API
 {
@@ -49,10 +49,10 @@ namespace DigitalData.Core.API
         {
             try
             {
-                return await _service.CreateAsync(createDto).ThenAsync<TId, IActionResult>(
-                                Success: id =>
+                return await _service.CreateAsync(createDto).ThenAsync<TReadDto, IActionResult>(
+                                Success: dto =>
                                 {
-                                    var createdResource = new { Id = id };
+                                    var createdResource = new { Id = dto.GetId() };
                                     var actionName = nameof(GetById);
                                     var routeValues = new { id = createdResource.Id };
                                     return CreatedAtAction(actionName, routeValues, createdResource);

DigitalData.Core.API/ControllerExtensions.cs

@@ -1,4 +1,4 @@
-using DigitalData.Core.Application.DTO;
+using DigitalData.Core.Abstraction.Application.DTO;
 using Microsoft.AspNetCore.Mvc;
 using System.Text;
 

DigitalData.Core.API/DigitalData.Core.API.csproj

@@ -8,7 +8,7 @@
     <OutputType>Library</OutputType>
     <Description>This package provides a comprehensive set of API controllers and related utilities for the DigitalData.Core library. It includes generic CRUD controllers, localization extensions, middleware for security policies, and application model conventions.</Description>
     <PackageId>DigitalData.Core.API</PackageId>
-    <Version>2.1.1</Version>
+    <Version>2.2.1</Version>
     <Authors>Digital Data GmbH</Authors>
     <Company>Digital Data GmbH</Company>
     <Product>DigitalData.Core.API</Product>
@@ -16,8 +16,8 @@
     <RepositoryUrl>http://git.dd:3000/AppStd/WebCoreModules.git</RepositoryUrl>
     <PackageTags>digital data core api</PackageTags>
     <PackageIcon>core_icon.png</PackageIcon>
-    <AssemblyVersion>2.1.1</AssemblyVersion>
-    <FileVersion>2.1.1</FileVersion>
+    <AssemblyVersion>2.2.1</AssemblyVersion>
+    <FileVersion>2.2.1</FileVersion>
   </PropertyGroup>
 
   <ItemGroup>

DigitalData.Core.API/ReadControllerBase.cs

@@ -1,6 +1,6 @@
-using DigitalData.Core.Application.Interfaces;
 using Microsoft.AspNetCore.Mvc;
-using DigitalData.Core.Application.DTO;
+using DigitalData.Core.Abstraction.Application;
+using DigitalData.Core.Abstraction.Application.DTO;
 
 namespace DigitalData.Core.API
 {

DigitalData.Core.API/ReadControllerBaseWithErrorHandling.cs

@@ -1,5 +1,5 @@
-using DigitalData.Core.Application.DTO;
-using DigitalData.Core.Application.Interfaces;
+using DigitalData.Core.Abstraction.Application;
+using DigitalData.Core.Abstraction.Application.DTO;
 using Microsoft.AspNetCore.Mvc;
 
 namespace DigitalData.Core.API

DigitalData.Core.Abstraction.Application/DTO/BaseDto.cs

@@ -0,0 +1,19 @@
+#if NET
+namespace DigitalData.Core.Abstraction.Application.DTO;
+
+/// <summary>
+/// Represents a base Data Transfer Object (DTO) with an identifier.
+/// </summary>
+/// <typeparam name="TId">The type of the identifier.</typeparam>
+/// <param name="Id">The identifier of the DTO.</param>
+[Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+public record BaseDTO<TId>(TId Id) where TId : notnull
+{
+	/// <summary>
+	/// Returns the hash code for this instance, based on the identifier.
+	/// This override ensures that the hash code is derived consistently from the identifier.
+	/// </summary>
+	/// <returns>A hash code for the current object, derived from the identifier.</returns>
+	public override int GetHashCode() => Id.GetHashCode();
+}
+#endif

DigitalData.Core.Abstraction.Application/DTO/CookieConsentSettings.cs

@@ -0,0 +1,75 @@
+#if NET
+namespace DigitalData.Core.Abstraction.Application.DTO;
+
+/// <summary>
+/// Represents settings related to user cookie consent dialogs. Designed to be serialized into JSON format for use with JavaScript frontend libraries,
+/// such as the bootstrap-cookie-consent-settings at the GitHub repository: https://github.com/shaack/bootstrap-cookie-consent-settings
+/// </summary>
+public class CookieConsentSettings
+{
+    /// <summary>
+    /// URL to the privacy policy page.
+    /// </summary>
+    public string? PrivacyPolicyUrl { get; set; }
+
+    /// <summary>
+    /// URL to the legal notice page.
+    /// </summary>
+    public string? LegalNoticeUrl { get; set; }
+
+    /// <summary>
+    /// URL to the content of the dialog box.
+    /// </summary>
+    public string? ContentURL { get; set; }
+
+    /// <summary>
+    /// CSS class for the 'Agree' button.
+    /// </summary>
+    public string? ButtonAgreeClass { get; set; }
+
+    /// <summary>
+    /// CSS class for the 'Don't Agree' button.
+    /// </summary>
+    public string? ButtonDontAgreeClass { get; set; }
+
+    /// <summary>
+    /// CSS class for the 'Save' button.
+    /// </summary>
+    public string? ButtonSaveClass { get; set; }
+
+    /// <summary>
+    /// Language in which the modal is displayed.
+    /// </summary>
+    public string? Lang { get; set; }
+
+    /// <summary>
+    /// Default language for the modal if the user's browser language is not supported.
+    /// </summary>
+    public string? DefaultLang { get; set; }
+
+    /// <summary>
+    /// Name of the cookie used to store the consent status.
+    /// </summary>
+    public string? CookieName { get; set; }
+
+    /// <summary>
+    /// Number of days the cookie will be stored.
+    /// </summary>
+    public int CookieStorageDays { get; set; }
+
+    /// <summary>
+    /// Identifier for the modal dialog element.
+    /// </summary>
+    public string? ModalId { get; set; }
+
+    /// <summary>
+    /// Indicates whether to also store the settings in the browser's localStorage.
+    /// </summary>
+    public bool AlsoUseLocalStorage { get; set; }
+
+    /// <summary>
+    /// List of categories for cookie consent.
+    /// </summary>
+    public List<string>? Categories { get; set; }
+}
+#endif

DigitalData.Core.Abstraction.Application/DTO/DIExtensions.cs

@@ -0,0 +1,36 @@
+#if NET
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using System.Configuration;
+
+namespace DigitalData.Core.Abstraction.Application.DTO;
+
+/// <summary>
+/// Provides extension methods for dependency injection.
+/// </summary>
+[Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+public static class DIExtensions
+{
+    /// <summary>
+    /// Adds the <see cref="CookieConsentSettings"/> to the service collection.
+    /// </summary>
+    /// <param name="services">The service collection to add the settings to.</param>
+    /// <returns>The updated service collection.</returns>
+    /// <exception cref="ConfigurationErrorsException">
+    /// Thrown if the 'CookieConsentSettings' section is missing or improperly configured in appsettings.json.
+    /// </exception>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public static IServiceCollection AddCookieConsentSettings(this IServiceCollection services)
+    {
+        services.AddSingleton(sp =>
+        {
+            var configuration = sp.GetRequiredService<IConfiguration>();
+            var settings = configuration.GetSection("CookieConsentSettings").Get<CookieConsentSettings>();
+            return settings is null
+                ? throw new ConfigurationErrorsException("The 'CookieConsentSettings' section is missing or improperly configured in appsettings.json.")
+                : settings;
+        });
+        return services;
+    }
+}
+#endif

DigitalData.Core.Abstraction.Application/DTO/DTOExtensions.cs

@@ -0,0 +1,395 @@
+#if NET
+using Microsoft.Extensions.Logging;
+using System.Text;
+
+namespace DigitalData.Core.Abstraction.Application.DTO;
+
+/// <summary>
+/// Provides extension methods for data transfer objects (DTOs).
+/// </summary>
+[Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+public static class DTOExtensions
+{
+    /// <summary>
+    /// Adds a single message to the result, if not null.
+    /// </summary>
+    /// <typeparam name="T">The type of the result.</typeparam>
+    /// <param name="result">The result to add the message to.</param>
+    /// <param name="message">The message to add.</param>
+    /// <returns>The updated result.</returns>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public static T Message<T>(this T result, string? message) where T : Result
+    {
+        if (message is not null)
+            result.Messages.Add(message);
+        return result;
+    }
+
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    internal static IEnumerable<T> FilterNull<T>(this IEnumerable<T?> list)
+    {
+        foreach (var item in list)
+            if (item is not null)
+                yield return item;
+    }
+
+    /// <summary>
+    /// Adds multiple messages to the result, after removing nulls.
+    /// </summary>
+    /// <typeparam name="T">The type of the result.</typeparam>
+    /// <param name="result">The result to add the messages to.</param>
+    /// <param name="messages">The messages to add.</param>
+    /// <returns>The updated result.</returns>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public static T Message<T>(this T result, params string?[] messages) where T : Result
+    {
+        result.Messages.AddRange(messages.FilterNull());
+        return result;
+    }
+
+    /// <summary>
+    /// Adds a collection of messages to the result.
+    /// </summary>
+    /// <typeparam name="T">The type of the result.</typeparam>
+    /// <param name="result">The result to add the messages to.</param>
+    /// <param name="messages">The collection of messages to add.</param>
+    /// <returns>The updated result.</returns>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public static T Message<T>(this T result, IEnumerable<string?> messages) where T : Result
+    {
+        result.Messages.AddRange(messages.FilterNull());
+        return result;
+    }
+
+    /// <summary>
+    /// Adds a notice to the result.
+    /// </summary>
+    /// <typeparam name="T">The type of the result.</typeparam>
+    /// <param name="result">The result to add the notice to.</param>
+    /// <param name="notice">The notice to add.</param>
+    /// <returns>The updated result.</returns>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public static T Notice<T>(this T result, Notice notice) where T : Result
+    {
+        result.Notices.Add(notice);
+        return result;
+    }
+
+    /// <summary>
+    /// Adds a collection of notices to the result.
+    /// </summary>
+    /// <typeparam name="T">The type of the result.</typeparam>
+    /// <param name="result">The result to add the notices to.</param>
+    /// <param name="notices">The collection of notices to add.</param>
+    /// <returns>The updated result.</returns>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public static T Notice<T>(this T result, IEnumerable<Notice> notices) where T : Result
+    {
+        result.Notices.AddRange(notices);
+        return result;
+    }
+
+    /// <summary>
+    /// Adds notices with a specific log level and flags to the result.
+    /// </summary>
+    /// <typeparam name="T">The type of the result.</typeparam>
+    /// <param name="result">The result to add the notices to.</param>
+    /// <param name="level">The log level of the notices.</param>
+    /// <param name="flags">The flags associated with the notices.</param>
+    /// <returns>The updated result.</returns>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public static T Notice<T>(this T result, LogLevel level, params Enum[] flags) where T : Result
+    {
+        var notices = flags.Select(flag => new Notice()
+        {
+            Flag = flag,
+            Level = level
+        });
+        result.Notices.AddRange(notices);
+        return result;
+    }
+
+    /// <summary>
+    /// Adds a notice with a specific log level, flag, and messages to the result.
+    /// </summary>
+    /// <typeparam name="T">The type of the result.</typeparam>
+    /// <param name="result">The result to add the notice to.</param>
+    /// <param name="level">The log level of the notice.</param>
+    /// <param name="flag">The flag associated with the notice.</param>
+    /// <param name="messages">The messages to add to the notice.</param>
+    /// <returns>The updated result.</returns>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public static T Notice<T>(this T result, LogLevel level, Enum flag, params string?[] messages) where T : Result
+    {
+        result.Notices.Add(new Notice()
+        {
+            Flag = flag,
+            Level = level,
+            Messages = messages.FilterNull().ToList()
+        });
+        return result;
+    }
+
+    /// <summary>
+    /// Adds a notice with a specific log level and messages to the result.
+    /// </summary>
+    /// <typeparam name="T">The type of the result.</typeparam>
+    /// <param name="result">The result to add the notice to.</param>
+    /// <param name="level">The log level of the notice.</param>
+    /// <param name="messages">The messages to add to the notice.</param>
+    /// <returns>The updated result.</returns>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public static T Notice<T>(this T result, LogLevel level, params string[] messages) where T : Result
+    {
+        result.Notices.Add(new Notice()
+        {
+            Flag = null,
+            Level = level,
+            Messages = messages.FilterNull().ToList()
+        });
+        return result;
+    }
+
+    /// <summary>
+    /// Checks if any notice has the specified flag.
+    /// </summary>
+    /// <param name="notices">The collection of notices to check.</param>
+    /// <param name="flag">The flag to check for.</param>
+    /// <returns>True if any notice has the specified flag; otherwise, false.</returns>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public static bool HasFlag(this IEnumerable<Notice> notices, Enum flag) => notices.Any(n => n.Flag?.ToString() == flag.ToString());
+
+    /// <summary>
+    /// Checks if any notice has any of the specified flags.
+    /// </summary>
+    /// <param name="notices">The collection of notices to check.</param>
+    /// <param name="flags">The flags to check for.</param>
+    /// <returns>True if any notice has any of the specified flags; otherwise, false.</returns>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public static bool HasAnyFlag(this IEnumerable<Notice> notices, params Enum[] flags) => flags.Any(f => notices.HasFlag(f));
+
+    /// <summary>
+    /// Executes a function based on the success or failure of the task result, 
+    /// without using result data.
+    /// </summary>
+    /// <typeparam name="I">The type of the return value.</typeparam>
+    /// <param name="tResult">The task returning a result to evaluate.</param>
+    /// <param name="Success">The function to execute if the result is successful.</param>
+    /// <param name="Fail">The function to execute if the result is a failure.</param>
+    /// <returns>The result of the executed function.</returns>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public static I? Then<I>(this Result result, Func<I> Success)
+    {
+        return result.IsSuccess ? Success() : default;
+    }
+
+    /// <summary>
+    /// Executes a function based on the success or failure of the task result,
+    /// using the data in the result.
+    /// </summary>
+    /// <typeparam name="T">The type of the data in the result.</typeparam>
+    /// <typeparam name="I">The type of the return value.</typeparam>
+    /// <param name="tResult">The task returning a data result to evaluate.</param>
+    /// <param name="Success">The function to execute if the data result is successful.</param>
+    /// <param name="Fail">The function to execute if the data result is a failure.</param>
+    /// <returns>The result of the executed function.</returns>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public static async Task<I?> ThenAsync<I>(this Result result, Func<Task<I>> SuccessAsync)
+    {
+        return result.IsSuccess ? await SuccessAsync() : default;
+    }
+
+    /// <summary>
+    /// Executes a function based on the success or failure of the result.
+    /// </summary>
+    /// <typeparam name="I">The type of the return value.</typeparam>
+    /// <param name="result">The result to evaluate.</param>
+    /// <param name="Success">The function to execute if the result is successful.</param>
+    /// <param name="Fail">The function to execute if the result is a failure.</param>
+    /// <returns>The result of the executed function.</returns>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public static I Then<I>(this Result result, Func<I> Success, Func<List<string>, List<Notice>, I> Fail)
+    {
+        return result.IsSuccess ? Success() : Fail(result.Messages, result.Notices);
+    }
+
+    /// <summary>
+    /// Asynchronously executes a function based on the success or failure of the result.
+    /// </summary>
+    /// <typeparam name="I">The type of the return value.</typeparam>
+    /// <param name="result">The result to evaluate.</param>
+    /// <param name="SuccessAsync">The asynchronous function to execute if the result is successful.</param>
+    /// <param name="Fail">The function to execute if the result is a failure.</param>
+    /// <returns>The result of the executed function.</returns>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public static async Task<I> ThenAsync<I>(this Result result, Func<Task<I>> SuccessAsync, Func<List<string>, List<Notice>, I> Fail)
+    {
+        return result.IsSuccess ? await SuccessAsync() : Fail(result.Messages, result.Notices);
+    }
+
+    /// <summary>
+    /// Executes a function based on the success or failure of the data result.
+    /// </summary>
+    /// <typeparam name="T">The type of the data in the result.</typeparam>
+    /// <typeparam name="I">The type of the return value.</typeparam>
+    /// <param name="result">The data result to evaluate.</param>
+    /// <param name="Success">The function to execute if the data result is successful.</param>
+    /// <param name="Fail">The function to execute if the data result is a failure.</param>
+    /// <returns>The result of the executed function.</returns>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public static I Then<T, I>(this DataResult<T> result, Func<T, I> Success, Func<List<string>, List<Notice>, I> Fail)
+    {
+        return result.IsSuccess ? Success(result.Data) : Fail(result.Messages, result.Notices);
+    }
+
+    /// <summary>
+    /// Asynchronously executes a function based on the success or failure of the data result.
+    /// </summary>
+    /// <typeparam name="T">The type of the data in the result.</typeparam>
+    /// <typeparam name="I">The type of the return value.</typeparam>
+    /// <param name="result">The data result to evaluate.</param>
+    /// <param name="SuccessAsync">The asynchronous function to execute if the data result is successful.</param>
+    /// <param name="Fail">The function to execute if the data result is a failure.</param>
+    /// <returns>The result of the executed function.</returns>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public static async Task<I> ThenAsync<T, I>(this DataResult<T> result, Func<T, Task<I>> SuccessAsync, Func<List<string>, List<Notice>, I> Fail)
+    {
+        return result.IsSuccess ? await SuccessAsync(result.Data) : Fail(result.Messages, result.Notices);
+    }
+
+    /// <summary>
+    /// Asynchronously executes a function based on the success or failure of a task returning a result.
+    /// </summary>
+    /// <typeparam name="I">The type of the return value.</typeparam>
+    /// <param name="tResult">The task returning a result to evaluate.</param>
+    /// <param name="Success">The function to execute if the result is successful.</param>
+    /// <param name="Fail">The function to execute if the result is a failure.</param>
+    /// <returns>The result of the executed function.</returns>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public static async Task<I> ThenAsync<I>(this Task<Result> tResult, Func<I> Success, Func<List<string>, List<Notice>, I> Fail)
+    {
+        Result result = await tResult;
+        return result.IsSuccess ? Success() : Fail(result.Messages, result.Notices);
+    }
+
+    /// <summary>
+    /// Asynchronously executes a function based on the success or failure of a task returning a result.
+    /// </summary>
+    /// <typeparam name="I">The type of the return value.</typeparam>
+    /// <param name="tResult">The task returning a result to evaluate.</param>
+    /// <param name="SuccessAsync">The asynchronous function to execute if the result is successful.</param>
+    /// <param name="Fail">The function to execute if the result is a failure.</param>
+    /// <returns>The result of the executed function.</returns>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public static async Task<I> ThenAsync<I>(this Task<Result> tResult, Func<Task<I>> SuccessAsync, Func<List<string>, List<Notice>, I> Fail)
+    {
+        Result result = await tResult;
+        return result.IsSuccess ? await SuccessAsync() : Fail(result.Messages, result.Notices);
+    }
+
+    /// <summary>
+    /// Asynchronously executes a function based on the success or failure of a task returning a data result.
+    /// </summary>
+    /// <typeparam name="T">The type of the data in the result.</typeparam>
+    /// <typeparam name="I">The type of the return value.</typeparam>
+    /// <param name="tResult">The task returning a data result to evaluate.</param>
+    /// <param name="Success">The function to execute if the data result is successful.</param>
+    /// <param name="Fail">The function to execute if the data result is a failure.</param>
+    /// <returns>The result of the executed function.</returns>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public static async Task<I> ThenAsync<T, I>(this Task<DataResult<T>> tResult, Func<T, I> Success, Func<List<string>, List<Notice>, I> Fail)
+    {
+        DataResult<T> result = await tResult;
+        return result.IsSuccess ? Success(result.Data) : Fail(result.Messages, result.Notices);
+    }
+
+    /// <summary>
+    /// Asynchronously executes a function based on the success or failure of a task returning a data result.
+    /// </summary>
+    /// <typeparam name="T">The type of the data in the result.</typeparam>
+    /// <typeparam name="I">The type of the return value.</typeparam>
+    /// <param name="tResult">The task returning a data result to evaluate.</param>
+    /// <param name="SuccessAsync">The asynchronous function to execute if the data result is successful.</param>
+    /// <param name="Fail">The function to execute if the data result is a failure.</param>
+    /// <returns>The result of the executed function.</returns>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public static async Task<I> ThenAsync<T, I>(this Task<DataResult<T>> tResult, Func<T, Task<I>> SuccessAsync, Func<List<string>, List<Notice>, I> Fail)
+    {
+        DataResult<T> result = await tResult;
+        return result.IsSuccess ? await SuccessAsync(result.Data) : Fail(result.Messages, result.Notices);
+    }
+
+    /// <summary>
+    /// Joins the values into a single string with optional start, separator, and end strings.
+    /// </summary>
+    /// <typeparam name="T">The type of the values.</typeparam>
+    /// <param name="values">The values to join.</param>
+    /// <param name="start">The starting string.</param>
+    /// <param name="separator">The separator string.</param>
+    /// <param name="end">The ending string.</param>
+    /// <returns>The joined string.</returns>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public static string Join<T>(this IEnumerable<T> values, string start = "", string seperator = ". ", string end = ".")
+        => new StringBuilder(start).Append(string.Join(seperator, values)).Append(end).ToString();
+
+    /// <summary>
+    /// Logs the notices using the specified logger.
+    /// </summary>
+    /// <param name="logger">The logger to use.</param>
+    /// <param name="notices">The collection of notices to log.</param>
+    /// <param name="start">The starting string for each notice.</param>
+    /// <param name="separator">The separator string for messages in each notice.</param>
+    /// <param name="end">The ending string for each notice.</param>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public static void LogNotice(this ILogger logger, IEnumerable<Notice> notices, string start = ": ", string seperator = ". ", string end = ".\n")
+    {
+        foreach (LogLevel level in Enum.GetValues(typeof(LogLevel)))
+        {
+            var logNotices = notices.Where(n => n.Level == level);
+
+            if (!logNotices.Any())
+                continue;
+
+            var sb = new StringBuilder();
+            foreach (Notice notice in logNotices)
+            {
+                if (notice.Flag is not null)
+                    sb.Append(notice.Flag);
+
+                if (notice.Messages.Any())
+                    sb.Append(start).Append(string.Join(seperator, notice.Messages)).AppendLine(end);
+                else sb.Append(end);
+            }
+            logger.Log(level, sb.ToString());
+        }
+    }
+
+    /// <summary>
+    /// Logs the notices from a result using the specified logger.
+    /// </summary>
+    /// <param name="logger">The logger to use.</param>
+    /// <param name="result">The result containing the notices to log.</param>
+    /// <param name="start">The starting string for each notice.</param>
+    /// <param name="separator">The separator string for messages in each notice.</param>
+    /// <param name="end">The ending string for each notice.</param>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public static void LogNotice(this ILogger logger, Result result, string start = ": ", string seperator = ". ", string end = ".\n")
+        => logger.LogNotice(notices: result.Notices, start: start, seperator: seperator, end: end);
+
+    /// <summary>
+    /// Determines if the data result is right (true).
+    /// </summary>
+    /// <param name="bResult">The data result to evaluate.</param>
+    /// <returns>True if the data result is true; otherwise, false.</returns>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public static bool IsRight(this DataResult<bool> bResult) => bResult.Data;
+
+    /// <summary>
+    /// Determines if the data result is wrong (false).
+    /// </summary>
+    /// <param name="bResult">The data result to evaluate.</param>
+    /// <returns>True if the data result is false; otherwise, false.</returns>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public static bool IsWrong(this DataResult<bool> bResult) => !bResult.Data;
+}
+#endif

DigitalData.Core.Abstraction.Application/DTO/DataResult.cs

@@ -0,0 +1,30 @@
+#if NET
+using System.Text.Json.Serialization;
+
+namespace DigitalData.Core.Abstraction.Application.DTO;
+
+/// <summary>
+/// Represents a result of an operation that includes data, inheriting from <see cref="Result"/>.
+/// </summary>
+/// <typeparam name="T">The type of the data included in the result.</typeparam>
+[Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+public class DataResult<T> : Result
+{
+    /// <summary>
+    /// Gets or sets the data included in the result. This property is required.
+    /// It will be ignored during JSON serialization if the value is null.
+    /// </summary>
+    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public required T Data { get; set; }
+
+    /// <summary>
+    /// Converts the current <see cref="DataResult{T}"/> to a failed <see cref="DataResult{I}"/>,
+    /// preserving the messages and notices.
+    /// </summary>
+    /// <typeparam name="I">The type of the data in the new failed result.</typeparam>
+    /// <returns>A failed <see cref="DataResult{I}"/> with the current messages and notices.</returns>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public DataResult<I> ToFail<I>() => Fail<I>().Message(Messages).Notice(Notices);
+}
+#endif

DigitalData.Core.Abstraction.Application/DTO/Flag.cs

@@ -0,0 +1,52 @@
+#if NET
+namespace DigitalData.Core.Abstraction.Application.DTO;
+
+/// <summary>
+/// Defines flags that indicate specific types of status or conditions in a service operation.
+/// These flags help in categorizing and identifying specific circumstances or issues that may arise during execution.
+/// </summary>
+[Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+public enum Flag
+{
+    /// <summary>
+    /// Indicates a security breach or vulnerability has been detected during the service operation.
+    /// </summary>
+    SecurityBreach,
+
+    /// <summary>
+    /// Indicates a potential issue with data integrity during the service operation.
+    /// This flag is used when data may have been altered, corrupted, or is otherwise unreliable,
+    /// which could impact the accuracy or trustworthiness of the operation's results.
+    /// </summary>
+    DataIntegrityIssue,
+
+    /// <summary>
+    /// Indicates that either a security breach, a data integrity issue, or both have been detected during the service operation.
+    /// This flag is used when it is not sure whether the problem is security or data integrity. In this case, data integrity should be checked first.
+    /// </summary>
+    SecurityBreachOrDataIntegrity,
+
+    /// <summary>
+    /// Indicates a possible security breach during the service operation.
+    /// </summary>
+    PossibleSecurityBreach,
+
+    /// <summary>
+    /// Indicates a possible issue with data integrity during the service operation.
+    /// This flag is used when there is a suspicion of data alteration, corruption, or unreliability.
+    /// </summary>
+    PossibleDataIntegrityIssue,
+
+    /// <summary>
+    /// Indicates that either a possible security breach, a possible data integrity issue, or both have been detected during the service operation.
+    /// This flag is used when it is uncertain whether the issue is related to security, data integrity, or both.
+    /// </summary>
+    PossibleSecurityBreachOrDataIntegrity,
+
+    /// <summary>
+    /// Indicates that the requested resource or operation could not be found.
+    /// This flag is used when the specified item or condition does not exist or is unavailable.
+    /// </summary>
+    NotFound
+}
+#endif

DigitalData.Core.Abstraction.Application/DTO/Notice.cs

@@ -0,0 +1,30 @@
+#if NET
+using Microsoft.Extensions.Logging;
+
+namespace DigitalData.Core.Abstraction.Application.DTO;
+
+/// <summary>
+/// Represents a notice for logging purposes, containing a flag, log level, and associated messages.
+/// </summary>
+[Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+public class Notice
+{
+    /// <summary>
+    /// Gets or sets an optional flag associated with the notice.
+    /// </summary>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public Enum? Flag { get; init; } = null;
+
+    /// <summary>
+    /// Gets or sets the log level for the notice.
+    /// </summary>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public LogLevel Level { get; init; } = LogLevel.None;
+
+    /// <summary>
+    /// Gets a list of messages associated with the notice.
+    /// </summary>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public List<string> Messages { get; init; } = new();
+}
+#endif

DigitalData.Core.Abstraction.Application/DTO/Result.cs

@@ -0,0 +1,110 @@
+#if NET
+using System.Text.Json.Serialization;
+
+namespace DigitalData.Core.Abstraction.Application.DTO;
+
+/// <summary>
+/// Represents the result of an operation, containing information about its success or failure,
+/// messages for the client, and notices for logging.
+/// </summary>
+[Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+public class Result
+{
+    /// <summary>
+    /// Gets or sets a value indicating whether the operation was successful.
+    /// </summary>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public bool IsSuccess { get; set; } = false;
+
+    /// <summary>
+    /// Gets a value indicating whether the operation failed.
+    /// </summary>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public bool IsFailed => !IsSuccess;
+
+    /// <summary>
+    /// Gets a list of messages intended for the client.
+    /// </summary>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public List<string> Messages { get; init; } = new();
+
+    /// <summary>
+    /// Gets a list of notices intended for logging purposes. This property is ignored during JSON serialization.
+    /// </summary>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    [JsonIgnore]
+    public List<Notice> Notices = new();
+
+    /// <summary>
+    /// Creates a <see cref="DataResult{T}"/> with the specified data.
+    /// </summary>
+    /// <typeparam name="T">The type of the data.</typeparam>
+    /// <param name="data">The data to include in the result.</param>
+    /// <returns>A new <see cref="DataResult{T}"/> instance.</returns>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public DataResult<T> Data<T>(T data) => new()
+    {
+        IsSuccess = IsSuccess,
+        Messages = Messages,
+        Notices = Notices,
+        Data = data
+    };
+
+    /// <summary>
+    /// Checks if any notice has the specified flag.
+    /// </summary>
+    /// <param name="flag">The flag to check.</param>
+    /// <returns>True if any notice has the specified flag; otherwise, false.</returns>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public bool HasFlag(Enum flag) => Notices.Any(n => n.Flag?.ToString() == flag.ToString());
+
+    /// <summary>
+    /// Checks if any notice has any of the specified flags.
+    /// </summary>
+    /// <param name="flags">The flags to check.</param>
+    /// <returns>True if any notice has any of the specified flags; otherwise, false.</returns>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public bool HasAnyFlag(params Enum[] flags) => flags.Any(HasFlag);
+
+    /// <summary>
+    /// Creates a new successful <see cref="Result"/>.
+    /// </summary>
+    /// <returns>A new successful <see cref="Result"/>.</returns>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public static Result Success() => new() { IsSuccess = true };
+
+    /// <summary>
+    /// Creates a new failed <see cref="Result"/>.
+    /// </summary>
+    /// <returns>A new failed <see cref="Result"/>.</returns>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public static Result Fail() => new() { IsSuccess = false };
+
+    /// <summary>
+    /// Creates a new successful <see cref="DataResult{T}"/> with the specified data.
+    /// </summary>
+    /// <typeparam name="T">The type of the data.</typeparam>
+    /// <param name="data">The data to include in the result.</param>
+    /// <returns>A new successful <see cref="DataResult{T}"/> with the specified data.</returns>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public static DataResult<T> Success<T>(T data) => new()
+    {
+        IsSuccess = true,
+        Data = data
+    };
+
+    /// <summary>
+    /// Creates a new failed <see cref="DataResult{T}"/> with no data.
+    /// </summary>
+    /// <typeparam name="T">The type of the data.</typeparam>
+    /// <returns>A new failed <see cref="DataResult{T}"/> with no data.</returns>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+#pragma warning disable CS8601 // Possible null reference assignment.
+    public static DataResult<T> Fail<T>() => new()
+    {
+        IsSuccess = false,
+        Data = default
+    };
+#pragma warning restore CS8601 // Possible null reference assignment.
+}
+#endif

DigitalData.Core.Abstraction.Application/DigitalData.Core.Abstraction.Application.csproj

@@ -0,0 +1,83 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFrameworks>net462;net7.0;net8.0;net9.0</TargetFrameworks>
+    <GeneratePackageOnBuild>True</GeneratePackageOnBuild>
+	  <Description>This package defines the abstraction layer for the DigitalData.Core.Application module, providing interfaces and contracts for application services, repositories, and infrastructure components in alignment with Clean Architecture principles.</Description>
+	  <PackageId>DigitalData.Core.Abstraction.Application</PackageId>
+    <Authors>Digital Data GmbH</Authors>
+    <Company>Digital Data GmbH</Company>
+    <Product>DigitalData.Core.Abstraction.Application</Product>
+    <Copyright>Copyright 2025</Copyright>
+    <PackageIcon>core_icon.png</PackageIcon>
+    <RepositoryUrl>http://git.dd:3000/AppStd/WebCoreModules.git</RepositoryUrl>
+    <PackageTags>digital data core application clean architecture abstraction</PackageTags>
+    <Version>1.6.0</Version>
+    <AssemblyVersion>1.6.0</AssemblyVersion>
+    <FileVersion>1.6.0</FileVersion>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <None Include="..\Assets\core_icon.png">
+      <Pack>True</Pack>
+      <PackagePath>\</PackagePath>
+    </None>
+  </ItemGroup>
+
+  <!-- disable for net462 -->
+  <PropertyGroup Condition="'$(TargetFramework)' == 'net462'">
+	<Nullable>disable</Nullable>
+	<ImplicitUsings>disable</ImplicitUsings>
+	<LangVersion>7.3</LangVersion>
+  </PropertyGroup>
+
+  <!-- enable for net7 and more -->
+  <PropertyGroup Condition="'$(TargetFramework)' == 'net7.0' Or '$(TargetFramework)' == 'net8.0' Or '$(TargetFramework)' == 'net9.0'">
+	<Nullable>enable</Nullable>
+	<ImplicitUsings>enable</ImplicitUsings>
+	<LangVersion>latest</LangVersion>
+  </PropertyGroup>
+	
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.Configuration" Version="7.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Localization.Abstractions" Version="7.0.16" />
+    <PackageReference Include="Microsoft.Extensions.Logging" Version="7.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Options.ConfigurationExtensions" Version="7.0.0" />
+    <PackageReference Include="System.DirectoryServices.AccountManagement" Version="7.0.1" />
+    <PackageReference Include="System.IdentityModel.Tokens.Jwt" Version="7.5.1" />
+    <PackageReference Include="System.Security.Cryptography.Cng" Version="5.0.0" />
+  </ItemGroup>
+
+  <ItemGroup Condition="'$(TargetFramework)' == 'net462'">
+	<PackageReference Include="AutoMapper" Version="10.1.1" />
+	<PackageReference Include="Microsoft.Extensions.Caching.Memory" Version="7.0.0" />
+	<PackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="7.0.0" />
+	<PackageReference Include="Microsoft.EntityFrameworkCore.Abstractions" Version="3.1.32" />
+  </ItemGroup>
+
+  <ItemGroup Condition="'$(TargetFramework)' == 'net7.0'">
+	<PackageReference Include="AutoMapper" Version="13.0.1" />
+	<PackageReference Include="Microsoft.Extensions.Caching.Memory" Version="7.0.0" />
+	<PackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="7.0.0" />
+	<PackageReference Include="Microsoft.EntityFrameworkCore.Abstractions" Version="7.0.20" />
+  </ItemGroup>
+
+  <ItemGroup Condition="'$(TargetFramework)' == 'net8.0'">
+	<PackageReference Include="AutoMapper" Version="14.0.0" />
+	<PackageReference Include="Microsoft.Extensions.Caching.Memory" Version="8.0.1" />
+	<PackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="8.0.0" />
+	<PackageReference Include="Microsoft.EntityFrameworkCore.Abstractions" Version="8.0.15" />
+  </ItemGroup>
+
+  <ItemGroup Condition="'$(TargetFramework)' == 'net9.0'">
+	<PackageReference Include="AutoMapper" Version="14.0.0" />
+	<PackageReference Include="Microsoft.Extensions.Caching.Memory" Version="9.0.5" />
+	<PackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="9.0.5" />
+	<PackageReference Include="Microsoft.EntityFrameworkCore.Abstractions" Version="9.0.5" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\DigitalData.Core.Abstractions\DigitalData.Core.Abstractions.csproj" />
+  </ItemGroup>
+	
+</Project>

DigitalData.Core.Abstraction.Application/EntityExtensions.cs

@@ -1,4 +1,5 @@
-namespace DigitalData.Core.Application;
+#if NET
+namespace DigitalData.Core.Abstraction.Application;
 
 /// <summary>
 /// Provides extension methods for retrieving the value of an 'Id' property from objects.
@@ -28,7 +29,7 @@ public static class EntityExtensions
     /// <exception cref="InvalidOperationException">
     /// Thrown if the object does not have a readable 'Id' property of type <typeparamref name="TId"/>.
     /// </exception>
-    public static TId? GetId<TId>(this object? obj)
+    public static TId GetId<TId>(this object? obj)
         => obj.GetIdOrDefault<TId>()
         ?? throw new InvalidOperationException($"The object of type '{obj?.GetType().FullName ?? "null"}' does not have a readable 'Id' property of type '{typeof(TId).FullName}'.");
 
@@ -91,4 +92,5 @@ public static class EntityExtensions
 #pragma warning restore CS8601
         return id is not null;
     }
-}
+}
+#endif

DigitalData.Core.Abstraction.Application/IBasicCRUDService.cs

@@ -1,4 +1,5 @@
-namespace DigitalData.Core.Application.Interfaces
+#if NET
+namespace DigitalData.Core.Abstraction.Application
 {
     /// <summary>
     /// Implements a simplified CRUD service interface that uses a single Data Transfer Object (DTO) type for all CRUD operations,
@@ -18,4 +19,5 @@
         where TDto : class where TEntity : class
     {
     }
-}
+}
+#endif

DigitalData.Core.Abstraction.Application/ICRUDService.cs

@@ -0,0 +1,26 @@
+#if NET
+using DigitalData.Core.Abstraction.Application.DTO;
+
+namespace DigitalData.Core.Abstraction.Application;
+
+[Obsolete("Use MediatR")]
+public interface ICRUDService<TCreateDto, TReadDto, TEntity, TId> : IReadService<TReadDto, TEntity, TId>
+    where TCreateDto : class where TReadDto : class where TEntity : class
+{
+    /// <summary>
+    /// Asynchronously creates a new entity based on the provided <paramref name="createDto"/> and returns the identifier of the created entity wrapped in a <see cref="DataResult{TId}"/>.
+    /// The <see cref="DataResult{TId}"/> contains the identifier of the newly created entity on success or an error message on failure.
+    /// </summary>
+    /// <param name="createDto">The data transfer object containing the information for the new entity.</param>
+    /// <returns>A task representing the asynchronous operation, with a <see cref="DataResult{TId}"/> containing the identifier of the created entity or an error message.</returns>
+    Task<DataResult<TReadDto>> CreateAsync(TCreateDto createDto);
+
+    /// <summary>
+    /// Updates an existing entity based on the provided updateDTO and returns the result wrapped in an IServiceMessage,
+    /// indicating the success or failure of the operation, including the error messages on failure.
+    /// </summary>
+    /// <param name="updateDto">The updateDTO with updated values for the entity.</param>
+    /// <returns>An Result indicating the outcome of the update operation, with an appropriate message.</returns>
+    Task<Result> UpdateAsync<TUpdateDto>(TUpdateDto updateDto);
+}
+#endif

DigitalData.Core.Abstraction.Application/IDirectorySearchService.cs

@@ -0,0 +1,96 @@
+#if NET
+using DigitalData.Core.Abstraction.Application.DTO;
+using System.DirectoryServices;
+
+namespace DigitalData.Core.Abstraction.Application;
+
+[Obsolete("Use DigitalData.ActiveDirectory")]
+public interface IDirectorySearchService
+{
+    public string ServerName { get; }
+
+    public string Root { get; }
+
+    string SearchRootPath { get; }
+
+    Dictionary<string, string> CustomSearchFilters { get; }
+
+    /// <summary>
+    /// Creates the connections to the server and returns a Boolean value that specifies
+    /// whether the specified username and password are valid.
+    /// </summary>
+    /// <param name="userName">The username that is validated on the server. See the Remarks section
+    /// for more information on the format of userName.</param>
+    /// <param name="password">The password that is validated on the server.</param>
+    /// <returns>True if the credentials are valid; otherwise, false.</returns>
+    bool ValidateCredentials(string userName, string password);
+
+    /// <summary>
+    /// Creates the connections to the server asynchronously and returns a Boolean value that specifies
+    /// whether the specified username and password are valid.
+    /// </summary>
+    /// <param name="userName">The username that is validated on the server. See the Remarks section
+    /// for more information on the format of userName.</param>
+    /// <param name="password">The password that is validated on the server.</param>
+    /// <returns>True if the credentials are valid; otherwise, false.</returns>
+    Task<bool> ValidateCredentialsAsync(string userName, string password);
+
+    /// <summary>
+    /// Finds all directory entries matching the specified filter.
+    /// </summary>
+    /// <param name="searchRoot">The search root.</param>
+    /// <param name="filter">The search filter.</param>
+    /// <param name="searchScope">The search scope.</param>
+    /// <param name="sizeLimit">The size limit.</param>
+    /// <param name="properties">The properties to load.</param>
+    /// <returns>A <see cref="DataResult{T}"/> containing the results.</returns>
+    DataResult<IEnumerable<ResultPropertyCollection>> FindAll(DirectoryEntry searchRoot, string filter, SearchScope searchScope = SearchScope.Subtree, int sizeLimit = 5000, params string[] properties);
+
+    /// <summary>
+    /// Finds all directory entries matching the specified filter asynchronously.
+    /// </summary>
+    /// <param name="searchRoot">The search root.</param>
+    /// <param name="filter">The search filter.</param>
+    /// <param name="searchScope">The search scope.</param>
+    /// <param name="sizeLimit">The size limit.</param>
+    /// <param name="properties">The properties to load.</param>
+    /// <returns>A <see cref="DataResult{T}"/> containing the results.</returns>
+    Task<DataResult<IEnumerable<ResultPropertyCollection>>> FindAllAsync(DirectoryEntry searchRoot, string filter, SearchScope searchScope = SearchScope.Subtree, int sizeLimit = 5000, params string[] properties);
+
+    /// <summary>
+    /// Finds all directory entries matching the specified filter, using the user cache.
+    /// </summary>
+    /// <param name="username">The username.</param>
+    /// <param name="filter">The search filter.</param>
+    /// <param name="searchScope">The search scope.</param>
+    /// <param name="sizeLimit">The size limit.</param>
+    /// <param name="properties">The properties to load.</param>
+    /// <returns>A <see cref="DataResult{T}"/> containing the results.</returns>
+    DataResult<IEnumerable<ResultPropertyCollection>> FindAllByUserCache(string username, string filter, SearchScope searchScope = SearchScope.Subtree, int sizeLimit = 5000, params string[] properties);
+
+    /// <summary>
+    /// Finds all directory entries matching the specified filter asynchronously, using the user cache.
+    /// </summary>
+    /// <param name="username">The username.</param>
+    /// <param name="filter">The search filter.</param>
+    /// <param name="searchScope">The search scope.</param>
+    /// <param name="sizeLimit">The size limit.</param>
+    /// <param name="properties">The properties to load.</param>
+    /// <returns>A <see cref="DataResult{T}"/> containing the results.</returns>
+    Task<DataResult<IEnumerable<ResultPropertyCollection>>> FindAllByUserCacheAsync(string username, string filter, SearchScope searchScope = SearchScope.Subtree, int sizeLimit = 5000, params string[] properties);
+
+    /// <summary>
+    /// Sets the search root in the cache.
+    /// </summary>
+    /// <param name="username">The directory entry username.</param>
+    /// <param name="password">The directory entry password.</param>
+    void SetSearchRootCache(string username, string password);
+
+    /// <summary>
+    /// Gets the search root from the cache.
+    /// </summary>
+    /// <param name="username">The directory entry username.</param>
+    /// <returns>The cached <see cref="DirectoryEntry"/> if found; otherwise, null.</returns>
+    DirectoryEntry? GetSearchRootCache(string username);
+}
+#endif

DigitalData.Core.Abstraction.Application/IJWTService.cs

@@ -0,0 +1,42 @@
+#if NET
+using Microsoft.IdentityModel.Tokens;
+using System.IdentityModel.Tokens.Jwt;
+using System.Security.Cryptography;
+
+namespace DigitalData.Core.Abstraction.Application;
+
+/// <summary>
+/// Defines the operations for JWT service handling claims of type <typeparamref name="TClaimValue"/>.
+/// </summary>
+public interface IJWTService<TClaimValue>
+{
+    /// <summary>
+    /// Generates a symmetric security key with the specified byte size.
+    /// </summary>
+    /// <param name="byteSize">The size of the security key in bytes. Default is 32 bytes.</param>
+    /// <returns>A new instance of <see cref="SymmetricSecurityKey"/>.</returns>
+    public static SymmetricSecurityKey GenerateSecurityKey(int byteSize = 32)
+    {
+        using var rng = RandomNumberGenerator.Create();
+        var randomBytes = new byte[byteSize];
+        rng.GetBytes(randomBytes);
+        var securityKey = new SymmetricSecurityKey(randomBytes);
+
+        return securityKey;
+    }
+
+    /// <summary>
+    /// Generates a token based on the specified claim value.
+    /// </summary>
+    /// <param name="claimValue">The claim value to encode in the token.</param>
+    /// <returns>A JWT as a string.</returns>
+    string GenerateToken(TClaimValue claimValue);
+
+    /// <summary>
+    /// Reads and validates a security token from a string representation.
+    /// </summary>
+    /// <param name="token">The JWT to read.</param>
+    /// <returns>A <see cref="JwtSecurityToken"/> if the token is valid; otherwise, null.</returns>
+    JwtSecurityToken? ReadSecurityToken(string token);
+}
+#endif

DigitalData.Core.Abstraction.Application/IReadService.cs

@@ -0,0 +1,40 @@
+#if NET
+using DigitalData.Core.Abstraction.Application.DTO;
+
+namespace DigitalData.Core.Abstraction.Application;
+
+[Obsolete("Use MediatR")]
+public interface IReadService<TReadDto, TEntity, TId>
+    where TReadDto : class where TEntity : class
+{
+    /// <summary>
+    /// Retrieves an entity by its identifier and returns its readDTO representation wrapped in an IServiceResult,
+    /// including the readDTO on success or null and an error message on failure.
+    /// </summary>
+    /// <param name="id">The identifier of the entity to retrieve.</param>
+    /// <returns>An DataResult containing the readDTO representing the found entity or null, with an appropriate message.</returns>
+    Task<DataResult<TReadDto>> ReadByIdAsync(TId id);
+
+    /// <summary>
+    /// Retrieves all entities and returns their readDTO representations wrapped in an IServiceResult,
+    /// including a collection of readDTOs on success or an error message on failure.
+    /// </summary>
+    /// <returns>An DataResult containing a collection of readDTOs representing all entities or an error message.</returns>
+    Task<DataResult<IEnumerable<TReadDto>>> ReadAllAsync();
+
+    /// <summary>
+    /// Deletes an entity by its identifier and returns the result wrapped in an IServiceMessage,
+    /// indicating the success or failure of the operation, including the error messages on failure.
+    /// </summary>
+    /// <param name="id">The identifier of the entity to delete.</param>
+    /// <returns>An Result indicating the outcome of the delete operation, with an appropriate message.</returns>
+    Task<Result> DeleteAsyncById(TId id);
+
+    /// <summary>
+    /// Asynchronously checks if an entity with the specified identifier exists within the data store.
+    /// </summary>
+    /// <param name="id">The identifier of the entity to check.</param>
+    /// <returns>A task that represents the asynchronous operation. The task result contains a boolean value indicating whether the entity exists.</returns>
+    Task<bool> HasEntity(TId id);
+}
+#endif

DigitalData.Core.Abstraction.Application/Repository/ICRUDRepository.cs

@@ -1,4 +1,5 @@
-namespace DigitalData.Core.Application.Interfaces.Repository
+#if NET
+namespace DigitalData.Core.Abstraction.Application.Repository
 {
     /// <summary>
     /// Defines the contract for CRUD operations on a repository for entities of type TEntity.
@@ -60,4 +61,5 @@
         /// </remarks>
         Task<int> CountAsync(TId id);
     }
-}
+}
+#endif

DigitalData.Core.Abstraction.Application/Repository/IEntityMapper.cs

@@ -1,4 +1,7 @@
-namespace DigitalData.Core.Application.Interfaces.Repository
+#if NETFRAMEWORK
+using System.Collections.Generic;
+#endif
+namespace DigitalData.Core.Abstraction.Application.Repository
 {
     /// <summary>
     /// Defines methods for mapping between entities and Data Transfer Objects (DTOs).

DigitalData.Core.Abstraction.Application/Repository/IRepository.cs

@@ -0,0 +1,140 @@
+using System.Linq.Expressions;
+using Microsoft.EntityFrameworkCore.Query;
+#if NETFRAMEWORK
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Linq;
+#endif
+
+namespace DigitalData.Core.Abstraction.Application.Repository
+{
+    public interface IRepository
+    {
+#if NET
+    public
+#endif
+        Task<int> ExecuteQueryRawAsync([NotParameterized] string sql, IEnumerable<object> parameters, CancellationToken cancel = default);
+
+#if NET
+    public
+#endif
+        Task<int> ExecuteQueryInterpolatedAsync(FormattableString sql, CancellationToken cancel = default);
+
+#if NET
+    public
+#endif
+        int ExecuteQueryRaw([NotParameterized] string sql, params object[] parameters);
+
+#if NET
+    public
+#endif
+        int ExecuteQueryInterpolated(FormattableString sql);
+    }
+
+    public interface IRepository<TEntity>
+    {
+        #region Create
+#if NET
+    public
+#endif
+        Task<TEntity> CreateAsync(TEntity entity, CancellationToken cancel = default);
+
+#if NET
+    public
+#endif
+        Task<IEnumerable<TEntity>> CreateAsync(IEnumerable<TEntity> entities, CancellationToken cancel = default);
+
+#if NET
+    public
+#endif
+        Task<TEntity> CreateAsync<TDto>(TDto dto, CancellationToken cancel = default);
+
+#if NET
+    public
+#endif
+        Task<IEnumerable<TEntity>> CreateAsync<TDto>(IEnumerable<TDto> dtos, CancellationToken cancel = default);
+        #endregion Create
+
+        #region Read
+#if NET
+    public
+#endif
+        IQueryable<TEntity> Query { get; }
+
+#if NET
+    public
+#endif
+        IQueryable<TEntity> QueryRaw([NotParameterized] string sql, params object[] parameters);
+
+#if NET
+    public
+#endif
+        IQueryable<TEntity> QueryInterpolated([NotParameterized] FormattableString sql);
+
+#if NET
+    public
+#endif
+        IQueryable<TEntity> Where(Expression<Func<TEntity, bool>> expression);
+
+#if NET
+    public
+#endif
+        IEnumerable<TEntity> GetAll();
+
+#if NET
+    public
+#endif
+        Task<IEnumerable<TEntity>> GetAllAsync(CancellationToken cancel = default);
+        #endregion Read
+
+        #region Update
+#if NET
+    public
+#endif
+        Task UpdateAsync<TDto>(TDto dto, Expression<Func<TEntity, bool>> expression, CancellationToken cancel = default);
+
+#if NET
+    public
+#endif
+        Task UpdateAsync<TDto>(TDto dto, Func<IQueryable<TEntity>, IQueryable<TEntity>> query, CancellationToken cancel = default);
+
+#if NET
+    public
+#endif
+        Task UpdateAsync(Action<TEntity> modification, Func<IQueryable<TEntity>, IQueryable<TEntity>> query, CancellationToken cancel = default);
+
+#if NET
+    public
+#endif
+        Task UpdateAsync(Action<TEntity> modification, Expression<Func<TEntity, bool>> expression, CancellationToken cancel = default);
+        #endregion Update
+
+        #region Delete
+#if NET
+    public
+#endif
+        Task DeleteAsync(Expression<Func<TEntity, bool>> expression, CancellationToken cancel = default);
+
+#if NET
+    public
+#endif
+        Task DeleteAsync(Func<IQueryable<TEntity>, IQueryable<TEntity>> query, CancellationToken cancel = default);
+        #endregion Delete
+
+        #region Obsolete
+        [Obsolete("Use CreateAsync, UpdateAsync or DeleteAsync")]
+#if NET
+    public
+#endif
+        IQueryable<TEntity> Read();
+
+        [Obsolete("Use IRepository<TEntity>.Where")]
+#if NET
+    public
+#endif
+        IQueryable<TEntity> ReadOnly();
+        #endregion
+    }
+}

DigitalData.Core.Abstraction.Application/Repository/ServiceProviderExtensions.cs

@@ -0,0 +1,15 @@
+using Microsoft.Extensions.DependencyInjection;
+#if NETFRAMEWORK
+using System;
+#endif
+
+namespace DigitalData.Core.Abstraction.Application.Repository
+{
+    public static class ServiceProviderExtensions
+    {
+        public static IRepository<TEntity> Repository<TEntity>(this IServiceProvider serviceProvider)
+        {
+            return serviceProvider.GetRequiredService<IRepository<TEntity>>();
+        }
+    }
+}

DigitalData.Core.Abstractions/ConfigurationExtension.cs

@@ -1,4 +1,5 @@
-using Microsoft.Extensions.Configuration;
+#if NET
+using Microsoft.Extensions.Configuration;
 
 namespace DigitalData.Core.Abstractions;
 
@@ -27,3 +28,4 @@ public static class ConfigurationExtension
             : configuration.GetSection(key).Get<T>())
         ?? new T();
 }
+#endif

DigitalData.Core.Abstractions/DeferredServiceProvider.cs

@@ -1,4 +1,5 @@
-namespace DigitalData.Core.Abstractions;
+#if NET
+namespace DigitalData.Core.Abstractions;
 
 /// <summary>
 /// A deferred implementation of <see cref="IServiceProvider"/> that allows the <see cref="IServiceProvider"/> instance 
@@ -38,3 +39,4 @@ public class DeferredServiceProvider : IServiceProvider
         return _serviceProvider.Value.GetService(serviceType);
     }
 }
+#endif

DigitalData.Core.Abstractions/DigitalData.Core.Abstractions.csproj

@@ -1,9 +1,8 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
 	<PropertyGroup>
-		<TargetFrameworks>net7.0;net8.0;net9.0</TargetFrameworks>
+		<TargetFrameworks>net462;net7.0;net8.0;net9.0</TargetFrameworks>
 		<ImplicitUsings>enable</ImplicitUsings>
-		<Nullable>enable</Nullable>
 		<!-- NuGet Package Metadata -->
 		<PackageId>DigitalData.Core.Abstractions</PackageId>
 		<Authors>Digital Data GmbH</Authors>
@@ -17,31 +16,53 @@
 		<RepositoryUrl>http://git.dd:3000/AppStd/WebCoreModules.git</RepositoryUrl>
 		<PackAsTool>False</PackAsTool>
 		<PackageIcon>core_icon.png</PackageIcon>
-		<Version>4.0.0</Version>
-		<AssemblyVersion>4.0.0</AssemblyVersion>
-		<FileVersion>4.0.0</FileVersion>
+		<Version>4.3.0</Version>
+		<AssemblyVersion>4.3.0</AssemblyVersion>
+		<FileVersion>4.3.0</FileVersion>
 	</PropertyGroup>
 
 	<ItemGroup>
-	  <None Include="..\..\nuget-package-icons\core_icon.png">
-	    <Pack>True</Pack>
-	    <PackagePath>\</PackagePath>
-	  </None>
+		<None Include="..\Assets\core_icon.png">
+			<Pack>True</Pack>
+			<PackagePath>\</PackagePath>
+		</None>
 	</ItemGroup>
 
+	<!-- disable for net462 -->
+	<PropertyGroup Condition="'$(TargetFramework)' == 'net462'">
+		<Nullable>disable</Nullable>
+		<ImplicitUsings>disable</ImplicitUsings>
+		<LangVersion>7.3</LangVersion>
+	</PropertyGroup>
+
+	<!-- enable for net7 and more -->
+	<PropertyGroup Condition="'$(TargetFramework)' == 'net7.0' Or '$(TargetFramework)' == 'net8.0' Or '$(TargetFramework)' == 'net9.0'">
+		<Nullable>enable</Nullable>
+		<ImplicitUsings>enable</ImplicitUsings>
+		<LangVersion>latest</LangVersion>
+	</PropertyGroup>
+
+	<ItemGroup Condition="'$(TargetFramework)' == 'net462'">
+	  <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="7.0.0" />
+	  <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="7.0.0" />
+	</ItemGroup>
+	
     <ItemGroup Condition="'$(TargetFramework)' == 'net7.0'">
       <PackageReference Include="Microsoft.Extensions.Caching.Memory" Version="7.0.0" />
       <PackageReference Include="Microsoft.Extensions.Configuration.Binder" Version="7.0.4" />
+      <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="7.0.0" />
     </ItemGroup>
 	
     <ItemGroup Condition="'$(TargetFramework)' == 'net8.0'">
-    <PackageReference Include="Microsoft.Extensions.Caching.Memory" Version="8.0.1" />
-    <PackageReference Include="Microsoft.Extensions.Configuration.Binder" Version="8.0.2" />
+      <PackageReference Include="Microsoft.Extensions.Caching.Memory" Version="8.0.1" />
+      <PackageReference Include="Microsoft.Extensions.Configuration.Binder" Version="9.0.5" />
+      <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="8.0.1" />
     </ItemGroup>
 	
     <ItemGroup Condition="'$(TargetFramework)' == 'net9.0'">
       <PackageReference Include="Microsoft.Extensions.Caching.Memory" Version="9.0.5" />
       <PackageReference Include="Microsoft.Extensions.Configuration.Binder" Version="9.0.5" />
+      <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="9.0.5" />
     </ItemGroup>
 
 </Project>

DigitalData.Core.Abstractions/Factory.cs

@@ -0,0 +1,142 @@
+using Microsoft.Extensions.DependencyInjection;
+using System.Collections;
+#if NETFRAMEWORK
+using System;
+using System.Collections.Generic;
+#endif
+
+namespace DigitalData.Core.Abstractions
+{
+    public class Factory : IServiceProvider, IServiceCollection
+    {
+        public static readonly Factory Shared = new Factory();
+
+        private readonly IServiceCollection _serviceCollection = new ServiceCollection();
+        private readonly Lazy<IServiceProvider> _lazyServiceProvider;
+
+        private bool IsBuilt => _lazyServiceProvider.IsValueCreated;
+
+        private PostBuildBehavior _pbBehavior = PostBuildBehavior.ThrowException;
+
+        public Factory BehaveOnPostBuild(PostBuildBehavior postBuildBehavior)
+        {
+            _pbBehavior = postBuildBehavior;
+            return this;
+        }
+
+        public Factory()
+        {
+            _lazyServiceProvider = new Lazy<IServiceProvider>(() => _serviceCollection.BuildServiceProvider());
+        }
+
+        #region Service Provider
+        public object
+#if NET
+            ?
+#endif
+            GetService(Type serviceType)
+        {
+            return _lazyServiceProvider.Value.GetService(serviceType);
+        }
+
+        public IServiceScopeFactory ScopeFactory => this.GetRequiredService<IServiceScopeFactory>();
+        #endregion
+
+        #region Service Collection
+        public int Count => _serviceCollection.Count;
+
+        public bool IsReadOnly => _serviceCollection.IsReadOnly;
+
+        public ServiceDescriptor this[int index]
+        {
+            get => _serviceCollection[index];
+            set
+            {
+                if (EnsureBuilt())
+                    return;
+                _serviceCollection[index] = value;
+            }
+        }
+
+        public int IndexOf(ServiceDescriptor item)
+        {
+            return _serviceCollection.IndexOf(item);
+        }
+
+        public void Insert(int index, ServiceDescriptor item)
+        {
+            if (EnsureBuilt())
+                return;
+            _serviceCollection.Insert(index, item);
+        }
+
+        public void RemoveAt(int index)
+        {
+            if (EnsureBuilt())
+                return;
+            _serviceCollection.RemoveAt(index);
+        }
+
+        public void Add(ServiceDescriptor item)
+        {
+            if (EnsureBuilt())
+                return;
+            _serviceCollection.Add(item);
+        }
+
+        public void Clear()
+        {
+            if (EnsureBuilt())
+                return;
+            _serviceCollection.Clear();
+        }
+
+        public bool Contains(ServiceDescriptor item)
+        {
+            return _serviceCollection.Contains(item);
+        }
+
+        public void CopyTo(ServiceDescriptor[] array, int arrayIndex)
+        {
+            _serviceCollection.CopyTo(array, arrayIndex);
+        }
+
+        public bool Remove(ServiceDescriptor item)
+        {
+            if (EnsureBuilt())
+                return false;
+            return _serviceCollection.Remove(item);
+        }
+
+        public IEnumerator<ServiceDescriptor> GetEnumerator()
+        {
+            return _serviceCollection.GetEnumerator();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return (_serviceCollection as IEnumerable).GetEnumerator();
+        }
+        #endregion
+
+        #region Helpers
+        private bool EnsureBuilt()
+        {
+            if (IsBuilt)
+            {
+                return _pbBehavior == PostBuildBehavior.ThrowException
+                    ? throw new InvalidOperationException("Service provider has already been built. No further service modifications are allowed.")
+                    : true;
+            }
+            else
+                return false;
+        }
+        #endregion
+    }
+
+    public enum PostBuildBehavior
+    {
+        ThrowException,
+        Ignore
+    }
+}

DigitalData.Core.Abstractions/Interfaces/IDto.cs

@@ -0,0 +1,18 @@
+namespace DigitalData.Core.Abstractions.Interfaces
+#if NET
+    ;
+#elif NETFRAMEWORK
+    {
+#endif
+
+/// <summary>
+/// Ensures that extension methods are handled securely
+/// </summary>
+/// <typeparam name="Entity"></typeparam>
+public interface IDto<Entity> where Entity : IEntity
+{
+}
+
+#if NETFRAMEWORK
+    }
+#endif

DigitalData.Core.Abstractions/Interfaces/IEntity.cs

@@ -0,0 +1,17 @@
+namespace DigitalData.Core.Abstractions.Interfaces
+#if NET
+    ;
+#elif NETFRAMEWORK
+    {
+#endif
+
+/// <summary>
+/// Ensures that extension methods are handled securely
+/// </summary>
+public interface IEntity
+{
+}
+
+#if NETFRAMEWORK
+    }
+#endif

DigitalData.Core.Abstractions/ServiceProviderExtensions.cs

@@ -1,4 +1,5 @@
-using Microsoft.Extensions.DependencyInjection;
+#if NET
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Options;
 
 namespace DigitalData.Core.Abstractions;
@@ -29,3 +30,4 @@ public static class ServiceProviderExtensions
     public static TOptions GetRequiredOptions<TOptions>(this IServiceProvider service) where TOptions : class
         => service.GetRequiredService<IOptions<TOptions>>().Value;
 }
+#endif

DigitalData.Core.Application/BasicCRUDService.cs

@@ -1,6 +1,6 @@
 using AutoMapper;
-using DigitalData.Core.Application.Interfaces;
-using DigitalData.Core.Application.Interfaces.Repository;
+using DigitalData.Core.Abstraction.Application;
+using DigitalData.Core.Abstraction.Application.Repository;
 
 namespace DigitalData.Core.Application
 {

DigitalData.Core.Application/CRUDService.cs

@@ -1,8 +1,8 @@
 using AutoMapper;
 using Microsoft.Extensions.Logging;
-using DigitalData.Core.Application.Interfaces.Repository;
-using DigitalData.Core.Application.Interfaces;
-using DigitalData.Core.Application.DTO;
+using DigitalData.Core.Abstraction.Application.DTO;
+using DigitalData.Core.Abstraction.Application.Repository;
+using DigitalData.Core.Abstraction.Application;
 
 namespace DigitalData.Core.Application
 {
@@ -33,11 +33,12 @@ namespace DigitalData.Core.Application
         /// </summary>
         /// <param name="createDto">The DTO to create an entity from.</param>
         /// <returns>A service result indicating success or failure, including the entity DTO.</returns>
-        public virtual async Task<DataResult<TId>> CreateAsync(TCreateDto createDto)
+        public virtual async Task<DataResult<TReadDto>> CreateAsync(TCreateDto createDto)
         {
             var entity = _mapper.Map<TEntity>(createDto);
             var createdEntity = await _repository.CreateAsync(entity);
-            return createdEntity is null ? Result.Fail<TId>() : Result.Success(createdEntity.GetIdOrDefault<TId>());
+            var dto = _mapper.Map<TReadDto>(createdEntity);
+            return createdEntity is null ? Result.Fail<TReadDto>() : Result.Success(dto);
         }
 
         /// <summary>
@@ -47,7 +48,7 @@ namespace DigitalData.Core.Application
         /// <returns>A service message indicating success or failure.</returns>
         public virtual async Task<Result> UpdateAsync<TUpdateDto>(TUpdateDto updateDto)
         {
-            var currentEntitiy = await _repository.ReadByIdAsync(updateDto.GetIdOrDefault<TId>());
+            var currentEntitiy = await _repository.ReadByIdAsync(updateDto.GetId<TId>());
 
             if (currentEntitiy is null)
                 return Result.Fail().Notice(LogLevel.Warning, Flag.NotFound, $"{updateDto.GetIdOrDefault<TId>()} is not found in update process of {GetType()} entity.");

DigitalData.Core.Application/DIExtensions.cs

@@ -1,4 +1,4 @@
-using DigitalData.Core.Application.Interfaces;
+using DigitalData.Core.Abstraction.Application;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Options;

DigitalData.Core.Application/DTO/BaseDto.cs

@@ -1,17 +0,0 @@
-namespace DigitalData.Core.Application.DTO
-{
-	/// <summary>
-	/// Represents a base Data Transfer Object (DTO) with an identifier.
-	/// </summary>
-	/// <typeparam name="TId">The type of the identifier.</typeparam>
-	/// <param name="Id">The identifier of the DTO.</param>
-	public record BaseDTO<TId>(TId Id) where TId : notnull
-	{
-		/// <summary>
-		/// Returns the hash code for this instance, based on the identifier.
-		/// This override ensures that the hash code is derived consistently from the identifier.
-		/// </summary>
-		/// <returns>A hash code for the current object, derived from the identifier.</returns>
-		public override int GetHashCode() => Id.GetHashCode();
-	}
-}

DigitalData.Core.Application/DTO/CookieConsentSettings.cs

@@ -1,74 +0,0 @@
-namespace DigitalData.Core.Application.DTO
-{
-    /// <summary>
-    /// Represents settings related to user cookie consent dialogs. Designed to be serialized into JSON format for use with JavaScript frontend libraries,
-    /// such as the bootstrap-cookie-consent-settings at the GitHub repository: https://github.com/shaack/bootstrap-cookie-consent-settings
-    /// </summary>
-    public class CookieConsentSettings
-    {
-        /// <summary>
-        /// URL to the privacy policy page.
-        /// </summary>
-        public string? PrivacyPolicyUrl { get; set; }
-
-        /// <summary>
-        /// URL to the legal notice page.
-        /// </summary>
-        public string? LegalNoticeUrl { get; set; }
-
-        /// <summary>
-        /// URL to the content of the dialog box.
-        /// </summary>
-        public string? ContentURL { get; set; }
-
-        /// <summary>
-        /// CSS class for the 'Agree' button.
-        /// </summary>
-        public string? ButtonAgreeClass { get; set; }
-
-        /// <summary>
-        /// CSS class for the 'Don't Agree' button.
-        /// </summary>
-        public string? ButtonDontAgreeClass { get; set; }
-
-        /// <summary>
-        /// CSS class for the 'Save' button.
-        /// </summary>
-        public string? ButtonSaveClass { get; set; }
-
-        /// <summary>
-        /// Language in which the modal is displayed.
-        /// </summary>
-        public string? Lang { get; set; }
-
-        /// <summary>
-        /// Default language for the modal if the user's browser language is not supported.
-        /// </summary>
-        public string? DefaultLang { get; set; }
-
-        /// <summary>
-        /// Name of the cookie used to store the consent status.
-        /// </summary>
-        public string? CookieName { get; set; }
-
-        /// <summary>
-        /// Number of days the cookie will be stored.
-        /// </summary>
-        public int CookieStorageDays { get; set; }
-
-        /// <summary>
-        /// Identifier for the modal dialog element.
-        /// </summary>
-        public string? ModalId { get; set; }
-
-        /// <summary>
-        /// Indicates whether to also store the settings in the browser's localStorage.
-        /// </summary>
-        public bool AlsoUseLocalStorage { get; set; }
-
-        /// <summary>
-        /// List of categories for cookie consent.
-        /// </summary>
-        public List<string>? Categories { get; set; }
-    }
-}

DigitalData.Core.Application/DTO/DIExtensions.cs

@@ -1,33 +0,0 @@
-using Microsoft.Extensions.Configuration;
-using Microsoft.Extensions.DependencyInjection;
-using System.Configuration;
-
-namespace DigitalData.Core.Application.DTO
-{
-    /// <summary>
-    /// Provides extension methods for dependency injection.
-    /// </summary>
-    public static class DIExtensions
-    {
-        /// <summary>
-        /// Adds the <see cref="CookieConsentSettings"/> to the service collection.
-        /// </summary>
-        /// <param name="services">The service collection to add the settings to.</param>
-        /// <returns>The updated service collection.</returns>
-        /// <exception cref="ConfigurationErrorsException">
-        /// Thrown if the 'CookieConsentSettings' section is missing or improperly configured in appsettings.json.
-        /// </exception>
-        public static IServiceCollection AddCookieConsentSettings(this IServiceCollection services)
-        {
-            services.AddSingleton(sp =>
-            {
-                var configuration = sp.GetRequiredService<IConfiguration>();
-                var settings = configuration.GetSection("CookieConsentSettings").Get<CookieConsentSettings>();
-                return settings is null
-                    ? throw new ConfigurationErrorsException("The 'CookieConsentSettings' section is missing or improperly configured in appsettings.json.")
-                    : settings;
-            });
-            return services;
-        }
-    }
-}

DigitalData.Core.Application/DTO/DTOExtensions.cs

@@ -1,367 +0,0 @@
-using Microsoft.Extensions.Logging;
-using System.Text;
-
-namespace DigitalData.Core.Application.DTO
-{
-    /// <summary>
-    /// Provides extension methods for data transfer objects (DTOs).
-    /// </summary>
-    public static class DTOExtensions
-    {
-        /// <summary>
-        /// Adds a single message to the result, if not null.
-        /// </summary>
-        /// <typeparam name="T">The type of the result.</typeparam>
-        /// <param name="result">The result to add the message to.</param>
-        /// <param name="message">The message to add.</param>
-        /// <returns>The updated result.</returns>
-        public static T Message<T>(this T result, string? message) where T : Result
-        {
-            if(message is not null)
-                result.Messages.Add(message);
-            return result;
-        }
-
-        internal static IEnumerable<T> FilterNull<T>(this IEnumerable<T?> list)
-        {
-            foreach (var item in list)
-                if(item is not null)
-                    yield return item;
-        }
-
-        /// <summary>
-        /// Adds multiple messages to the result, after removing nulls.
-        /// </summary>
-        /// <typeparam name="T">The type of the result.</typeparam>
-        /// <param name="result">The result to add the messages to.</param>
-        /// <param name="messages">The messages to add.</param>
-        /// <returns>The updated result.</returns>
-        public static T Message<T>(this T result, params string?[] messages) where T : Result
-        {
-            result.Messages.AddRange(messages.FilterNull());
-            return result;
-        }
-
-        /// <summary>
-        /// Adds a collection of messages to the result.
-        /// </summary>
-        /// <typeparam name="T">The type of the result.</typeparam>
-        /// <param name="result">The result to add the messages to.</param>
-        /// <param name="messages">The collection of messages to add.</param>
-        /// <returns>The updated result.</returns>
-        public static T Message<T>(this T result, IEnumerable<string?> messages) where T : Result
-        {
-            result.Messages.AddRange(messages.FilterNull());
-            return result;
-        }
-
-        /// <summary>
-        /// Adds a notice to the result.
-        /// </summary>
-        /// <typeparam name="T">The type of the result.</typeparam>
-        /// <param name="result">The result to add the notice to.</param>
-        /// <param name="notice">The notice to add.</param>
-        /// <returns>The updated result.</returns>
-        public static T Notice<T>(this T result, Notice notice) where T : Result
-        {
-            result.Notices.Add(notice);
-            return result;
-        }
-
-        /// <summary>
-        /// Adds a collection of notices to the result.
-        /// </summary>
-        /// <typeparam name="T">The type of the result.</typeparam>
-        /// <param name="result">The result to add the notices to.</param>
-        /// <param name="notices">The collection of notices to add.</param>
-        /// <returns>The updated result.</returns>
-        public static T Notice<T>(this T result, IEnumerable<Notice> notices) where T : Result
-        {
-            result.Notices.AddRange(notices);
-            return result;
-        }
-
-        /// <summary>
-        /// Adds notices with a specific log level and flags to the result.
-        /// </summary>
-        /// <typeparam name="T">The type of the result.</typeparam>
-        /// <param name="result">The result to add the notices to.</param>
-        /// <param name="level">The log level of the notices.</param>
-        /// <param name="flags">The flags associated with the notices.</param>
-        /// <returns>The updated result.</returns>
-        public static T Notice<T>(this T result, LogLevel level, params Enum[] flags) where T : Result
-        {
-            var notices = flags.Select(flag => new Notice()
-            {
-                Flag = flag,
-                Level = level
-            });
-            result.Notices.AddRange(notices);
-            return result;
-        }
-
-        /// <summary>
-        /// Adds a notice with a specific log level, flag, and messages to the result.
-        /// </summary>
-        /// <typeparam name="T">The type of the result.</typeparam>
-        /// <param name="result">The result to add the notice to.</param>
-        /// <param name="level">The log level of the notice.</param>
-        /// <param name="flag">The flag associated with the notice.</param>
-        /// <param name="messages">The messages to add to the notice.</param>
-        /// <returns>The updated result.</returns>
-        public static T Notice<T>(this T result, LogLevel level, Enum flag, params string?[] messages) where T : Result
-        {
-            result.Notices.Add(new Notice()
-            {
-                Flag = flag,
-                Level = level,
-                Messages = messages.FilterNull().ToList()
-            });
-            return result;
-        }
-
-        /// <summary>
-        /// Adds a notice with a specific log level and messages to the result.
-        /// </summary>
-        /// <typeparam name="T">The type of the result.</typeparam>
-        /// <param name="result">The result to add the notice to.</param>
-        /// <param name="level">The log level of the notice.</param>
-        /// <param name="messages">The messages to add to the notice.</param>
-        /// <returns>The updated result.</returns>
-        public static T Notice<T>(this T result, LogLevel level, params string[] messages) where T : Result
-        {
-            result.Notices.Add(new Notice()
-            {
-                Flag = null,
-                Level = level,
-                Messages = messages.FilterNull().ToList()
-            });
-            return result;
-        }
-
-        /// <summary>
-        /// Checks if any notice has the specified flag.
-        /// </summary>
-        /// <param name="notices">The collection of notices to check.</param>
-        /// <param name="flag">The flag to check for.</param>
-        /// <returns>True if any notice has the specified flag; otherwise, false.</returns>
-        public static bool HasFlag(this IEnumerable<Notice> notices, Enum flag) => notices.Any(n => n.Flag?.ToString() == flag.ToString());
-
-        /// <summary>
-        /// Checks if any notice has any of the specified flags.
-        /// </summary>
-        /// <param name="notices">The collection of notices to check.</param>
-        /// <param name="flags">The flags to check for.</param>
-        /// <returns>True if any notice has any of the specified flags; otherwise, false.</returns>
-        public static bool HasAnyFlag(this IEnumerable<Notice> notices, params Enum[] flags) => flags.Any(f => notices.HasFlag(f));
-
-        /// <summary>
-        /// Executes a function based on the success or failure of the task result, 
-        /// without using result data.
-        /// </summary>
-        /// <typeparam name="I">The type of the return value.</typeparam>
-        /// <param name="tResult">The task returning a result to evaluate.</param>
-        /// <param name="Success">The function to execute if the result is successful.</param>
-        /// <param name="Fail">The function to execute if the result is a failure.</param>
-        /// <returns>The result of the executed function.</returns>
-        public static I? Then<I>(this Result result, Func<I> Success)
-        {
-            return result.IsSuccess ? Success() : default;
-        }
-
-        /// <summary>
-        /// Executes a function based on the success or failure of the task result,
-        /// using the data in the result.
-        /// </summary>
-        /// <typeparam name="T">The type of the data in the result.</typeparam>
-        /// <typeparam name="I">The type of the return value.</typeparam>
-        /// <param name="tResult">The task returning a data result to evaluate.</param>
-        /// <param name="Success">The function to execute if the data result is successful.</param>
-        /// <param name="Fail">The function to execute if the data result is a failure.</param>
-        /// <returns>The result of the executed function.</returns>
-        public static async Task<I?> ThenAsync<I>(this Result result, Func<Task<I>> SuccessAsync)
-        {
-            return result.IsSuccess ? await SuccessAsync() : default;
-        }
-
-        /// <summary>
-        /// Executes a function based on the success or failure of the result.
-        /// </summary>
-        /// <typeparam name="I">The type of the return value.</typeparam>
-        /// <param name="result">The result to evaluate.</param>
-        /// <param name="Success">The function to execute if the result is successful.</param>
-        /// <param name="Fail">The function to execute if the result is a failure.</param>
-        /// <returns>The result of the executed function.</returns>
-        public static I Then<I>(this Result result, Func<I> Success, Func<List<string>, List<Notice>, I> Fail)
-        {
-            return result.IsSuccess ? Success() : Fail(result.Messages, result.Notices);
-        }
-
-        /// <summary>
-        /// Asynchronously executes a function based on the success or failure of the result.
-        /// </summary>
-        /// <typeparam name="I">The type of the return value.</typeparam>
-        /// <param name="result">The result to evaluate.</param>
-        /// <param name="SuccessAsync">The asynchronous function to execute if the result is successful.</param>
-        /// <param name="Fail">The function to execute if the result is a failure.</param>
-        /// <returns>The result of the executed function.</returns>
-        public static async Task<I> ThenAsync<I>(this Result result, Func<Task<I>> SuccessAsync, Func<List<string>, List<Notice>, I> Fail)
-        {
-            return result.IsSuccess ? await SuccessAsync() : Fail(result.Messages, result.Notices);
-        }
-
-        /// <summary>
-        /// Executes a function based on the success or failure of the data result.
-        /// </summary>
-        /// <typeparam name="T">The type of the data in the result.</typeparam>
-        /// <typeparam name="I">The type of the return value.</typeparam>
-        /// <param name="result">The data result to evaluate.</param>
-        /// <param name="Success">The function to execute if the data result is successful.</param>
-        /// <param name="Fail">The function to execute if the data result is a failure.</param>
-        /// <returns>The result of the executed function.</returns>
-        public static I Then<T, I>(this DataResult<T> result, Func<T, I> Success, Func<List<string>, List<Notice>, I> Fail)
-        {
-            return result.IsSuccess ? Success(result.Data) : Fail(result.Messages, result.Notices);
-        }
-
-        /// <summary>
-        /// Asynchronously executes a function based on the success or failure of the data result.
-        /// </summary>
-        /// <typeparam name="T">The type of the data in the result.</typeparam>
-        /// <typeparam name="I">The type of the return value.</typeparam>
-        /// <param name="result">The data result to evaluate.</param>
-        /// <param name="SuccessAsync">The asynchronous function to execute if the data result is successful.</param>
-        /// <param name="Fail">The function to execute if the data result is a failure.</param>
-        /// <returns>The result of the executed function.</returns>
-        public static async Task<I> ThenAsync<T, I>(this DataResult<T> result, Func<T, Task<I>> SuccessAsync, Func<List<string>, List<Notice>, I> Fail)
-        {
-            return result.IsSuccess ? await SuccessAsync(result.Data) : Fail(result.Messages, result.Notices);
-        }
-
-        /// <summary>
-        /// Asynchronously executes a function based on the success or failure of a task returning a result.
-        /// </summary>
-        /// <typeparam name="I">The type of the return value.</typeparam>
-        /// <param name="tResult">The task returning a result to evaluate.</param>
-        /// <param name="Success">The function to execute if the result is successful.</param>
-        /// <param name="Fail">The function to execute if the result is a failure.</param>
-        /// <returns>The result of the executed function.</returns>
-        public static async Task<I> ThenAsync<I>(this Task<Result> tResult, Func<I> Success, Func<List<string>, List<Notice>, I> Fail)
-        {
-            Result result = await tResult;
-            return result.IsSuccess ? Success() : Fail(result.Messages, result.Notices);
-        }
-
-        /// <summary>
-        /// Asynchronously executes a function based on the success or failure of a task returning a result.
-        /// </summary>
-        /// <typeparam name="I">The type of the return value.</typeparam>
-        /// <param name="tResult">The task returning a result to evaluate.</param>
-        /// <param name="SuccessAsync">The asynchronous function to execute if the result is successful.</param>
-        /// <param name="Fail">The function to execute if the result is a failure.</param>
-        /// <returns>The result of the executed function.</returns>
-        public static async Task<I> ThenAsync<I>(this Task<Result> tResult, Func<Task<I>> SuccessAsync, Func<List<string>, List<Notice>, I> Fail)
-        {
-            Result result = await tResult;
-            return result.IsSuccess ? await SuccessAsync() : Fail(result.Messages, result.Notices);
-        }
-
-        /// <summary>
-        /// Asynchronously executes a function based on the success or failure of a task returning a data result.
-        /// </summary>
-        /// <typeparam name="T">The type of the data in the result.</typeparam>
-        /// <typeparam name="I">The type of the return value.</typeparam>
-        /// <param name="tResult">The task returning a data result to evaluate.</param>
-        /// <param name="Success">The function to execute if the data result is successful.</param>
-        /// <param name="Fail">The function to execute if the data result is a failure.</param>
-        /// <returns>The result of the executed function.</returns>
-        public static async Task<I> ThenAsync<T, I>(this Task<DataResult<T>> tResult, Func<T, I> Success, Func<List<string>, List<Notice>, I> Fail)
-        {
-            DataResult<T> result = await tResult;
-            return result.IsSuccess ? Success(result.Data) : Fail(result.Messages, result.Notices);
-        }
-
-        /// <summary>
-        /// Asynchronously executes a function based on the success or failure of a task returning a data result.
-        /// </summary>
-        /// <typeparam name="T">The type of the data in the result.</typeparam>
-        /// <typeparam name="I">The type of the return value.</typeparam>
-        /// <param name="tResult">The task returning a data result to evaluate.</param>
-        /// <param name="SuccessAsync">The asynchronous function to execute if the data result is successful.</param>
-        /// <param name="Fail">The function to execute if the data result is a failure.</param>
-        /// <returns>The result of the executed function.</returns>
-        public static async Task<I> ThenAsync<T, I>(this Task<DataResult<T>> tResult, Func<T, Task<I>> SuccessAsync, Func<List<string>, List<Notice>, I> Fail)
-        {
-            DataResult<T> result = await tResult;
-            return result.IsSuccess ? await SuccessAsync(result.Data) : Fail(result.Messages, result.Notices);
-        }
-
-        /// <summary>
-        /// Joins the values into a single string with optional start, separator, and end strings.
-        /// </summary>
-        /// <typeparam name="T">The type of the values.</typeparam>
-        /// <param name="values">The values to join.</param>
-        /// <param name="start">The starting string.</param>
-        /// <param name="separator">The separator string.</param>
-        /// <param name="end">The ending string.</param>
-        /// <returns>The joined string.</returns>
-        public static string Join<T>(this IEnumerable<T> values, string start = "", string seperator = ". ", string end = ".") 
-            => new StringBuilder(start).Append(string.Join(seperator, values)).Append(end).ToString();
-
-        /// <summary>
-        /// Logs the notices using the specified logger.
-        /// </summary>
-        /// <param name="logger">The logger to use.</param>
-        /// <param name="notices">The collection of notices to log.</param>
-        /// <param name="start">The starting string for each notice.</param>
-        /// <param name="separator">The separator string for messages in each notice.</param>
-        /// <param name="end">The ending string for each notice.</param>
-        public static void LogNotice(this ILogger logger, IEnumerable<Notice> notices, string start = ": ", string seperator = ". ", string end = ".\n")
-        {
-            foreach(LogLevel level in Enum.GetValues(typeof(LogLevel)))
-            {
-                var logNotices = notices.Where(n => n.Level == level);
-
-                if (!logNotices.Any())
-                    continue;
-
-                var sb = new StringBuilder();
-                foreach(Notice notice in logNotices)
-                {
-                    if (notice.Flag is not null)
-                        sb.Append(notice.Flag);
-
-                    if (notice.Messages.Any())
-                        sb.Append(start).Append(string.Join(seperator, notice.Messages)).AppendLine(end);
-                    else sb.Append(end);
-                }
-                logger.Log(level, sb.ToString());
-            }
-        }
-
-        /// <summary>
-        /// Logs the notices from a result using the specified logger.
-        /// </summary>
-        /// <param name="logger">The logger to use.</param>
-        /// <param name="result">The result containing the notices to log.</param>
-        /// <param name="start">The starting string for each notice.</param>
-        /// <param name="separator">The separator string for messages in each notice.</param>
-        /// <param name="end">The ending string for each notice.</param>
-        public static void LogNotice(this ILogger logger, Result result, string start = ": ", string seperator = ". ", string end = ".\n")
-            => logger.LogNotice(notices: result.Notices, start: start, seperator: seperator, end: end);
-
-        /// <summary>
-        /// Determines if the data result is right (true).
-        /// </summary>
-        /// <param name="bResult">The data result to evaluate.</param>
-        /// <returns>True if the data result is true; otherwise, false.</returns>
-        public static bool IsRight(this DataResult<bool> bResult) => bResult.Data;
-
-        /// <summary>
-        /// Determines if the data result is wrong (false).
-        /// </summary>
-        /// <param name="bResult">The data result to evaluate.</param>
-        /// <returns>True if the data result is false; otherwise, false.</returns>
-        public static bool IsWrong(this DataResult<bool> bResult) => !bResult.Data;
-    }
-}

DigitalData.Core.Application/DTO/DataResult.cs

@@ -1,26 +0,0 @@
-using System.Text.Json.Serialization;
-
-namespace DigitalData.Core.Application.DTO
-{
-    /// <summary>
-    /// Represents a result of an operation that includes data, inheriting from <see cref="Result"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the data included in the result.</typeparam>
-    public class DataResult<T> : Result
-    {
-        /// <summary>
-        /// Gets or sets the data included in the result. This property is required.
-        /// It will be ignored during JSON serialization if the value is null.
-        /// </summary>
-        [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
-        public required T Data { get; set; }
-
-        /// <summary>
-        /// Converts the current <see cref="DataResult{T}"/> to a failed <see cref="DataResult{I}"/>,
-        /// preserving the messages and notices.
-        /// </summary>
-        /// <typeparam name="I">The type of the data in the new failed result.</typeparam>
-        /// <returns>A failed <see cref="DataResult{I}"/> with the current messages and notices.</returns>
-        public DataResult<I> ToFail<I>() => Fail<I>().Message(Messages).Notice(Notices);
-    }
-}

DigitalData.Core.Application/DTO/Flag.cs

@@ -1,50 +0,0 @@
-namespace DigitalData.Core.Application.DTO
-{
-    /// <summary>
-    /// Defines flags that indicate specific types of status or conditions in a service operation.
-    /// These flags help in categorizing and identifying specific circumstances or issues that may arise during execution.
-    /// </summary>
-    public enum Flag
-    {
-        /// <summary>
-        /// Indicates a security breach or vulnerability has been detected during the service operation.
-        /// </summary>
-        SecurityBreach,
-
-        /// <summary>
-        /// Indicates a potential issue with data integrity during the service operation.
-        /// This flag is used when data may have been altered, corrupted, or is otherwise unreliable,
-        /// which could impact the accuracy or trustworthiness of the operation's results.
-        /// </summary>
-        DataIntegrityIssue,
-
-        /// <summary>
-        /// Indicates that either a security breach, a data integrity issue, or both have been detected during the service operation.
-        /// This flag is used when it is not sure whether the problem is security or data integrity. In this case, data integrity should be checked first.
-        /// </summary>
-        SecurityBreachOrDataIntegrity,
-
-        /// <summary>
-        /// Indicates a possible security breach during the service operation.
-        /// </summary>
-        PossibleSecurityBreach,
-
-        /// <summary>
-        /// Indicates a possible issue with data integrity during the service operation.
-        /// This flag is used when there is a suspicion of data alteration, corruption, or unreliability.
-        /// </summary>
-        PossibleDataIntegrityIssue,
-
-        /// <summary>
-        /// Indicates that either a possible security breach, a possible data integrity issue, or both have been detected during the service operation.
-        /// This flag is used when it is uncertain whether the issue is related to security, data integrity, or both.
-        /// </summary>
-        PossibleSecurityBreachOrDataIntegrity,
-
-        /// <summary>
-        /// Indicates that the requested resource or operation could not be found.
-        /// This flag is used when the specified item or condition does not exist or is unavailable.
-        /// </summary>
-        NotFound
-    }
-}

DigitalData.Core.Application/DTO/Notice.cs

@@ -1,25 +0,0 @@
-using Microsoft.Extensions.Logging;
-
-namespace DigitalData.Core.Application.DTO
-{
-    /// <summary>
-    /// Represents a notice for logging purposes, containing a flag, log level, and associated messages.
-    /// </summary>
-    public class Notice
-    {
-        /// <summary>
-        /// Gets or sets an optional flag associated with the notice.
-        /// </summary>
-        public Enum? Flag { get; init; } = null;
-
-        /// <summary>
-        /// Gets or sets the log level for the notice.
-        /// </summary>
-        public LogLevel Level { get; init; } = LogLevel.None;
-
-        /// <summary>
-        /// Gets a list of messages associated with the notice.
-        /// </summary>
-        public List<string> Messages { get; init; } = new();
-    }
-}

DigitalData.Core.Application/DTO/Result.cs

@@ -1,97 +0,0 @@
-using System.Text.Json.Serialization;
-
-namespace DigitalData.Core.Application.DTO
-{
-    /// <summary>
-    /// Represents the result of an operation, containing information about its success or failure,
-    /// messages for the client, and notices for logging.
-    /// </summary>
-    public class Result
-    {
-        /// <summary>
-        /// Gets or sets a value indicating whether the operation was successful.
-        /// </summary>
-        public bool IsSuccess { get; set; } = false;
-
-        /// <summary>
-        /// Gets a value indicating whether the operation failed.
-        /// </summary>
-        public bool IsFailed => !IsSuccess;
-
-        /// <summary>
-        /// Gets a list of messages intended for the client.
-        /// </summary>
-        public List<string> Messages { get; init; } = new();
-
-        /// <summary>
-        /// Gets a list of notices intended for logging purposes. This property is ignored during JSON serialization.
-        /// </summary>
-        [JsonIgnore]
-        public List<Notice> Notices = new();
-
-        /// <summary>
-        /// Creates a <see cref="DataResult{T}"/> with the specified data.
-        /// </summary>
-        /// <typeparam name="T">The type of the data.</typeparam>
-        /// <param name="data">The data to include in the result.</param>
-        /// <returns>A new <see cref="DataResult{T}"/> instance.</returns>
-        public DataResult<T> Data<T>(T data) => new()
-        {
-            IsSuccess = IsSuccess,
-            Messages = Messages,
-            Notices = Notices,
-            Data = data
-        };
-
-        /// <summary>
-        /// Checks if any notice has the specified flag.
-        /// </summary>
-        /// <param name="flag">The flag to check.</param>
-        /// <returns>True if any notice has the specified flag; otherwise, false.</returns>
-        public bool HasFlag(Enum flag) => Notices.Any(n => n.Flag?.ToString() == flag.ToString());
-
-        /// <summary>
-        /// Checks if any notice has any of the specified flags.
-        /// </summary>
-        /// <param name="flags">The flags to check.</param>
-        /// <returns>True if any notice has any of the specified flags; otherwise, false.</returns>
-        public bool HasAnyFlag(params Enum[] flags) => flags.Any(HasFlag);
-
-        /// <summary>
-        /// Creates a new successful <see cref="Result"/>.
-        /// </summary>
-        /// <returns>A new successful <see cref="Result"/>.</returns>
-        public static Result Success() => new() { IsSuccess = true };
-
-        /// <summary>
-        /// Creates a new failed <see cref="Result"/>.
-        /// </summary>
-        /// <returns>A new failed <see cref="Result"/>.</returns>
-        public static Result Fail() => new() { IsSuccess = false };
-
-        /// <summary>
-        /// Creates a new successful <see cref="DataResult{T}"/> with the specified data.
-        /// </summary>
-        /// <typeparam name="T">The type of the data.</typeparam>
-        /// <param name="data">The data to include in the result.</param>
-        /// <returns>A new successful <see cref="DataResult{T}"/> with the specified data.</returns>
-        public static DataResult<T> Success<T>(T data) => new()
-        {
-            IsSuccess = true,
-            Data = data
-        };
-
-        /// <summary>
-        /// Creates a new failed <see cref="DataResult{T}"/> with no data.
-        /// </summary>
-        /// <typeparam name="T">The type of the data.</typeparam>
-        /// <returns>A new failed <see cref="DataResult{T}"/> with no data.</returns>
-#pragma warning disable CS8601 // Possible null reference assignment.
-        public static DataResult<T> Fail<T>() => new()
-        {
-            IsSuccess = false,
-            Data = default
-        };
-#pragma warning restore CS8601 // Possible null reference assignment.
-    }
-}

DigitalData.Core.Application/DigitalData.Core.Application.csproj

@@ -14,9 +14,9 @@
     <PackageIcon>core_icon.png</PackageIcon>
     <RepositoryUrl>http://git.dd:3000/AppStd/WebCoreModules.git</RepositoryUrl>
     <PackageTags>digital data core application clean architecture</PackageTags>
-    <Version>3.3.0</Version>
-    <AssemblyVersion>3.3.0</AssemblyVersion>
-    <FileVersion>3.3.0</FileVersion>
+    <Version>3.4.0</Version>
+    <AssemblyVersion>3.4.0</AssemblyVersion>
+    <FileVersion>3.4.0</FileVersion>
   </PropertyGroup>
 
   <ItemGroup>
@@ -54,4 +54,8 @@
 	<PackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="9.0.5" />
   </ItemGroup>
 
+  <ItemGroup>
+    <ProjectReference Include="..\DigitalData.Core.Abstraction.Application\DigitalData.Core.Abstraction.Application.csproj" />
+  </ItemGroup>
+
 </Project>

DigitalData.Core.Application/DirectorySearchService.cs

@@ -3,8 +3,8 @@ using System.DirectoryServices;
 using Microsoft.Extensions.Caching.Memory;
 using System.DirectoryServices.AccountManagement;
 using Microsoft.Extensions.Options;
-using DigitalData.Core.Application.Interfaces;
-using DigitalData.Core.Application.DTO;
+using DigitalData.Core.Abstraction.Application.DTO;
+using DigitalData.Core.Abstraction.Application;
 
 namespace DigitalData.Core.Application
 {

DigitalData.Core.Application/Interfaces/ICRUDService.cs

@@ -1,26 +0,0 @@
-using DigitalData.Core.Application.DTO;
-
-namespace DigitalData.Core.Application.Interfaces
-{
-    [Obsolete("Use MediatR")]
-    public interface ICRUDService<TCreateDto, TReadDto, TEntity, TId> : IReadService<TReadDto, TEntity, TId>
-        where TCreateDto : class where TReadDto : class where TEntity : class
-    {
-        /// <summary>
-        /// Asynchronously creates a new entity based on the provided <paramref name="createDto"/> and returns the identifier of the created entity wrapped in a <see cref="DataResult{TId}"/>.
-        /// The <see cref="DataResult{TId}"/> contains the identifier of the newly created entity on success or an error message on failure.
-        /// </summary>
-        /// <param name="createDto">The data transfer object containing the information for the new entity.</param>
-        /// <returns>A task representing the asynchronous operation, with a <see cref="DataResult{TId}"/> containing the identifier of the created entity or an error message.</returns>
-        Task<DataResult<TId>> CreateAsync(TCreateDto createDto);
-
-
-        /// <summary>
-        /// Updates an existing entity based on the provided updateDTO and returns the result wrapped in an IServiceMessage,
-        /// indicating the success or failure of the operation, including the error messages on failure.
-        /// </summary>
-        /// <param name="updateDto">The updateDTO with updated values for the entity.</param>
-        /// <returns>An Result indicating the outcome of the update operation, with an appropriate message.</returns>
-        Task<Result> UpdateAsync<TUpdateDto>(TUpdateDto updateDto);
-    }
-}

DigitalData.Core.Application/Interfaces/IDirectorySearchService.cs

@@ -1,94 +0,0 @@
-using DigitalData.Core.Application.DTO;
-using System.DirectoryServices;
-
-namespace DigitalData.Core.Application.Interfaces
-{
-    public interface IDirectorySearchService
-    {
-        public string ServerName { get; }
-
-        public string Root { get; }
-
-        string SearchRootPath { get; }
-
-        Dictionary<string, string> CustomSearchFilters { get; }
-
-        /// <summary>
-        /// Creates the connections to the server and returns a Boolean value that specifies
-        /// whether the specified username and password are valid.
-        /// </summary>
-        /// <param name="userName">The username that is validated on the server. See the Remarks section
-        /// for more information on the format of userName.</param>
-        /// <param name="password">The password that is validated on the server.</param>
-        /// <returns>True if the credentials are valid; otherwise, false.</returns>
-        bool ValidateCredentials(string userName, string password);
-
-        /// <summary>
-        /// Creates the connections to the server asynchronously and returns a Boolean value that specifies
-        /// whether the specified username and password are valid.
-        /// </summary>
-        /// <param name="userName">The username that is validated on the server. See the Remarks section
-        /// for more information on the format of userName.</param>
-        /// <param name="password">The password that is validated on the server.</param>
-        /// <returns>True if the credentials are valid; otherwise, false.</returns>
-        Task<bool> ValidateCredentialsAsync(string userName, string password);
-
-        /// <summary>
-        /// Finds all directory entries matching the specified filter.
-        /// </summary>
-        /// <param name="searchRoot">The search root.</param>
-        /// <param name="filter">The search filter.</param>
-        /// <param name="searchScope">The search scope.</param>
-        /// <param name="sizeLimit">The size limit.</param>
-        /// <param name="properties">The properties to load.</param>
-        /// <returns>A <see cref="DataResult{T}"/> containing the results.</returns>
-        DataResult<IEnumerable<ResultPropertyCollection>> FindAll(DirectoryEntry searchRoot, string filter, SearchScope searchScope = SearchScope.Subtree, int sizeLimit = 5000, params string[] properties);
-
-        /// <summary>
-        /// Finds all directory entries matching the specified filter asynchronously.
-        /// </summary>
-        /// <param name="searchRoot">The search root.</param>
-        /// <param name="filter">The search filter.</param>
-        /// <param name="searchScope">The search scope.</param>
-        /// <param name="sizeLimit">The size limit.</param>
-        /// <param name="properties">The properties to load.</param>
-        /// <returns>A <see cref="DataResult{T}"/> containing the results.</returns>
-        Task<DataResult<IEnumerable<ResultPropertyCollection>>> FindAllAsync(DirectoryEntry searchRoot, string filter, SearchScope searchScope = SearchScope.Subtree, int sizeLimit = 5000, params string[] properties);
-
-        /// <summary>
-        /// Finds all directory entries matching the specified filter, using the user cache.
-        /// </summary>
-        /// <param name="username">The username.</param>
-        /// <param name="filter">The search filter.</param>
-        /// <param name="searchScope">The search scope.</param>
-        /// <param name="sizeLimit">The size limit.</param>
-        /// <param name="properties">The properties to load.</param>
-        /// <returns>A <see cref="DataResult{T}"/> containing the results.</returns>
-        DataResult<IEnumerable<ResultPropertyCollection>> FindAllByUserCache(string username, string filter, SearchScope searchScope = SearchScope.Subtree, int sizeLimit = 5000, params string[] properties);
-
-        /// <summary>
-        /// Finds all directory entries matching the specified filter asynchronously, using the user cache.
-        /// </summary>
-        /// <param name="username">The username.</param>
-        /// <param name="filter">The search filter.</param>
-        /// <param name="searchScope">The search scope.</param>
-        /// <param name="sizeLimit">The size limit.</param>
-        /// <param name="properties">The properties to load.</param>
-        /// <returns>A <see cref="DataResult{T}"/> containing the results.</returns>
-        Task<DataResult<IEnumerable<ResultPropertyCollection>>> FindAllByUserCacheAsync(string username, string filter, SearchScope searchScope = SearchScope.Subtree, int sizeLimit = 5000, params string[] properties);
-
-        /// <summary>
-        /// Sets the search root in the cache.
-        /// </summary>
-        /// <param name="username">The directory entry username.</param>
-        /// <param name="password">The directory entry password.</param>
-        void SetSearchRootCache(string username, string password);
-
-        /// <summary>
-        /// Gets the search root from the cache.
-        /// </summary>
-        /// <param name="username">The directory entry username.</param>
-        /// <returns>The cached <see cref="DirectoryEntry"/> if found; otherwise, null.</returns>
-        DirectoryEntry? GetSearchRootCache(string username);
-    }
-}

DigitalData.Core.Application/Interfaces/IJWTService.cs

@@ -1,41 +0,0 @@
-using Microsoft.IdentityModel.Tokens;
-using System.IdentityModel.Tokens.Jwt;
-using System.Security.Cryptography;
-
-namespace DigitalData.Core.Application.Interfaces
-{
-    /// <summary>
-    /// Defines the operations for JWT service handling claims of type <typeparamref name="TClaimValue"/>.
-    /// </summary>
-    public interface IJWTService<TClaimValue>
-    {
-        /// <summary>
-        /// Generates a symmetric security key with the specified byte size.
-        /// </summary>
-        /// <param name="byteSize">The size of the security key in bytes. Default is 32 bytes.</param>
-        /// <returns>A new instance of <see cref="SymmetricSecurityKey"/>.</returns>
-        public static SymmetricSecurityKey GenerateSecurityKey(int byteSize = 32)
-        {
-            using var rng = RandomNumberGenerator.Create();
-            var randomBytes = new byte[byteSize];
-            rng.GetBytes(randomBytes);
-            var securityKey = new SymmetricSecurityKey(randomBytes);
-
-            return securityKey;
-        }
-
-        /// <summary>
-        /// Generates a token based on the specified claim value.
-        /// </summary>
-        /// <param name="claimValue">The claim value to encode in the token.</param>
-        /// <returns>A JWT as a string.</returns>
-        string GenerateToken(TClaimValue claimValue);
-
-        /// <summary>
-        /// Reads and validates a security token from a string representation.
-        /// </summary>
-        /// <param name="token">The JWT to read.</param>
-        /// <returns>A <see cref="JwtSecurityToken"/> if the token is valid; otherwise, null.</returns>
-        JwtSecurityToken? ReadSecurityToken(string token);
-    }
-}

DigitalData.Core.Application/Interfaces/IReadService.cs

@@ -1,39 +0,0 @@
-using DigitalData.Core.Application.DTO;
-
-namespace DigitalData.Core.Application.Interfaces
-{
-    [Obsolete("Use MediatR")]
-    public interface IReadService<TReadDto, TEntity, TId>
-        where TReadDto : class where TEntity : class
-    {
-        /// <summary>
-        /// Retrieves an entity by its identifier and returns its readDTO representation wrapped in an IServiceResult,
-        /// including the readDTO on success or null and an error message on failure.
-        /// </summary>
-        /// <param name="id">The identifier of the entity to retrieve.</param>
-        /// <returns>An DataResult containing the readDTO representing the found entity or null, with an appropriate message.</returns>
-        Task<DataResult<TReadDto>> ReadByIdAsync(TId id);
-
-        /// <summary>
-        /// Retrieves all entities and returns their readDTO representations wrapped in an IServiceResult,
-        /// including a collection of readDTOs on success or an error message on failure.
-        /// </summary>
-        /// <returns>An DataResult containing a collection of readDTOs representing all entities or an error message.</returns>
-        Task<DataResult<IEnumerable<TReadDto>>> ReadAllAsync();
-        
-        /// <summary>
-        /// Deletes an entity by its identifier and returns the result wrapped in an IServiceMessage,
-        /// indicating the success or failure of the operation, including the error messages on failure.
-        /// </summary>
-        /// <param name="id">The identifier of the entity to delete.</param>
-        /// <returns>An Result indicating the outcome of the delete operation, with an appropriate message.</returns>
-        Task<Result> DeleteAsyncById(TId id);
-
-        /// <summary>
-        /// Asynchronously checks if an entity with the specified identifier exists within the data store.
-        /// </summary>
-        /// <param name="id">The identifier of the entity to check.</param>
-        /// <returns>A task that represents the asynchronous operation. The task result contains a boolean value indicating whether the entity exists.</returns>
-        Task<bool> HasEntity(TId id);
-    }
-}

DigitalData.Core.Application/Interfaces/Repository/Extensions.cs

@@ -1,34 +0,0 @@
-using System.Linq.Expressions;
-
-namespace DigitalData.Core.Application.Interfaces.Repository;
-
-public static class Extensions
-{
-    #region Create
-    public static Task<TEntity> CreateAsync<TEntity, TDto>(this IRepository<TEntity> repository, TDto dto, CancellationToken ct = default)
-    {
-        var entity = repository.Mapper.Map(dto);
-        return repository.CreateAsync(entity, ct);
-    }
-
-    public static Task<IEnumerable<TEntity>> CreateAsync<TEntity, TDto>(this IRepository<TEntity> repository, IEnumerable<TDto> dtos, CancellationToken ct = default)
-    {
-        var entities = dtos.Select(dto => repository.Mapper.Map(dto));
-        return repository.CreateAsync(entities, ct);
-    }
-    #endregion
-
-    #region Read
-    public static async Task<TEntity?> ReadFirstOrDefaultAsync<TEntity>(this IRepository<TEntity> repository, Expression<Func<TEntity, bool>>? expression = null)
-        => (await repository.ReadAllAsync(expression)).FirstOrDefault();
-
-    public static async Task<TEntity> ReadFirstAsync<TEntity>(this IRepository<TEntity> repository, Expression<Func<TEntity, bool>>? expression = null)
-        => (await repository.ReadAllAsync(expression)).First();
-
-    public static async Task<TEntity?> ReadSingleOrDefaultAsync<TEntity>(this IRepository<TEntity> repository, Expression<Func<TEntity, bool>>? expression = null)
-        => (await repository.ReadAllAsync(expression)).SingleOrDefault();
-
-    public static async Task<TEntity> ReadSingleAsync<TEntity>(this IRepository<TEntity> repository, Expression<Func<TEntity, bool>>? expression = null)
-        => (await repository.ReadAllAsync(expression)).Single();
-    #endregion
-}

DigitalData.Core.Application/Interfaces/Repository/IReadQuery.cs

@@ -1,85 +0,0 @@
-using System.Linq.Expressions;
-
-namespace DigitalData.Core.Application.Interfaces.Repository;
-
-/// <summary>
-/// Provides methods for executing common queries on a given entity type.
-/// This interface abstracts away the direct usage of ORM libraries (such as Entity Framework) for querying data
-/// and provides asynchronous and synchronous operations for querying a collection or single entity.
-/// </summary>
-/// <typeparam name="TEntity">The type of the entity being queried.</typeparam>
-public interface IReadQuery<TEntity>
-{
-    /// <summary>
-    /// Adds a filter to the query using the specified predicate expression.
-    /// This method allows chaining multiple filter conditions to refine the query results.
-    /// </summary>
-    /// <param name="expression">An expression that defines the filter condition for the entity.</param>
-    /// <returns>The current <see cref="IReadQuery{TEntity}"/> instance with the applied filter.</returns>
-    public IReadQuery<TEntity> Where(Expression<Func<TEntity, bool>> expression);
-
-    /// <summary>
-    /// Asynchronously retrieves the first entity or a default value if no entity is found.
-    /// </summary>
-    /// <param name="cancellation">A <see cref="CancellationToken"/> to observe while waiting for the task to complete.</param>
-    /// <returns>A task that represents the asynchronous operation. The task result contains the entity or a default value.</returns>
-    public Task<TEntity?> FirstOrDefaultAsync(CancellationToken cancellation = default);
-
-    /// <summary>
-    /// Asynchronously retrieves a single entity or a default value if no entity is found.
-    /// </summary>
-    /// <param name="cancellation">A <see cref="CancellationToken"/> to observe while waiting for the task to complete.</param>
-    /// <returns>A task that represents the asynchronous operation. The task result contains the entity or a default value.</returns>
-    public Task<TEntity?> SingleOrDefaultAsync(CancellationToken cancellation = default);
-
-    /// <summary>
-    /// Asynchronously retrieves a list of entities.
-    /// </summary>
-    /// <param name="cancellation">A <see cref="CancellationToken"/> to observe while waiting for the task to complete.</param>
-    /// <returns>A task that represents the asynchronous operation. The task result contains the list of entities.</returns>
-    public Task<IEnumerable<TEntity>> ToListAsync(CancellationToken cancellation = default);
-
-    /// <summary>
-    /// Asynchronously retrieves the first entity. Throws an exception if no entity is found.
-    /// </summary>
-    /// <param name="cancellation">A <see cref="CancellationToken"/> to observe while waiting for the task to complete.</param>
-    /// <returns>A task that represents the asynchronous operation. The task result contains the first entity.</returns>
-    public Task<TEntity> FirstAsync(CancellationToken cancellation = default);
-
-    /// <summary>
-    /// Asynchronously retrieves a single entity. Throws an exception if no entity is found.
-    /// </summary>
-    /// <param name="cancellation">A <see cref="CancellationToken"/> to observe while waiting for the task to complete.</param>
-    /// <returns>A task that represents the asynchronous operation. The task result contains the single entity.</returns>
-    public Task<TEntity> SingleAsync(CancellationToken cancellation = default);
-
-    /// <summary>
-    /// Synchronously retrieves the first entity or a default value if no entity is found.
-    /// </summary>
-    /// <returns>The first entity or a default value.</returns>
-    public TEntity? FirstOrDefault();
-
-    /// <summary>
-    /// Synchronously retrieves a single entity or a default value if no entity is found.
-    /// </summary>
-    /// <returns>The single entity or a default value.</returns>
-    public TEntity? SingleOrDefault();
-
-    /// <summary>
-    /// Synchronously retrieves a list of entities.
-    /// </summary>
-    /// <returns>The list of entities.</returns>
-    public IEnumerable<TEntity> ToList();
-
-    /// <summary>
-    /// Synchronously retrieves the first entity. Throws an exception if no entity is found.
-    /// </summary>
-    /// <returns>The first entity.</returns>
-    public TEntity First();
-
-    /// <summary>
-    /// Synchronously retrieves a single entity. Throws an exception if no entity is found.
-    /// </summary>
-    /// <returns>The single entity.</returns>
-    public TEntity Single();
-}

DigitalData.Core.Application/Interfaces/Repository/IRepository.cs

@@ -1,32 +0,0 @@
-using System.Linq.Expressions;
-
-namespace DigitalData.Core.Application.Interfaces.Repository;
-
-public interface IRepository<TEntity>
-{
-    public IEntityMapper<TEntity> Mapper { get; }
-
-    public Task<TEntity> CreateAsync(TEntity entity, CancellationToken cancellation = default);
-
-    public Task<IEnumerable<TEntity>> CreateAsync(IEnumerable<TEntity> entities, CancellationToken cancellation = default);
-
-    public IReadQuery<TEntity> Read(params Expression<Func<TEntity, bool>>[] expressions);
-
-    public Task UpdateAsync<TDto>(TDto dto, Expression<Func<TEntity, bool>> expression, CancellationToken cancellation = default);
-
-    public Task DeleteAsync(Expression<Func<TEntity, bool>> expression, CancellationToken cancellation = default);
-
-    #region Obsolete
-    [Obsolete("Use Read-method returning IReadQuery<TEntity> instead.")]
-    public Task<IEnumerable<TEntity>> ReadAllAsync(Expression<Func<TEntity, bool>>? expression = null, CancellationToken cancellation = default);
-
-    [Obsolete("Use Read-method returning IReadQuery<TEntity> instead.")]
-    public Task<TEntity?> ReadOrDefaultAsync(Expression<Func<TEntity, bool>> expression, bool single = true, CancellationToken cancellation = default);
-
-    [Obsolete("Use Read-method returning IReadQuery<TEntity> instead.")]
-    public Task<IEnumerable<TDto>> ReadAllAsync<TDto>(Expression<Func<TEntity, bool>>? expression = null, CancellationToken cancellation = default);
-
-    [Obsolete("Use Read-method returning IReadQuery<TEntity> instead.")]
-    public Task<TDto?> ReadOrDefaultAsync<TDto>(Expression<Func<TEntity, bool>> expression, bool single = true, CancellationToken cancellation = default);
-    #endregion
-}

DigitalData.Core.Application/Interfaces/Repository/RepositoryExtensions.cs

@@ -1,14 +0,0 @@
-using System.Linq.Expressions;
-
-namespace DigitalData.Core.Application.Interfaces.Repository;
-
-public static class RepositoryExtensions
-{
-    public static IReadQuery<TEntity> Where<TEntity>(this IReadQuery<TEntity> query, params Expression<Func<TEntity, bool>>[] expressions)
-    {
-        foreach (var expression in expressions)
-            query = query.Where(expression);
-
-        return query;
-    }
-}

DigitalData.Core.Application/JWTService.cs

@@ -1,4 +1,4 @@
-using DigitalData.Core.Application.Interfaces;
+using DigitalData.Core.Abstraction.Application;
 using Microsoft.IdentityModel.Tokens;
 using System.IdentityModel.Tokens.Jwt;
 using System.Security.Cryptography;

DigitalData.Core.Application/ReadService.cs

@@ -1,7 +1,7 @@
 using AutoMapper;
-using DigitalData.Core.Application.DTO;
-using DigitalData.Core.Application.Interfaces;
-using DigitalData.Core.Application.Interfaces.Repository;
+using DigitalData.Core.Abstraction.Application;
+using DigitalData.Core.Abstraction.Application.DTO;
+using DigitalData.Core.Abstraction.Application.Repository;
 
 namespace DigitalData.Core.Application;
 

DigitalData.Core.Client/DigitalData.Core.Client.csproj

@@ -6,7 +6,6 @@
     <Nullable>enable</Nullable>
     <Description>This package provides HTTP client extension methods for the DigitalData.Core library, offering simplified and asynchronous methods for fetching and handling HTTP responses. It includes utility methods for sending GET requests, reading response content as text or JSON, and deserializing JSON into dynamic or strongly-typed objects using Newtonsoft.Json. These extensions facilitate efficient and easy-to-read HTTP interactions in client applications.</Description>
     <PackageId>DigitalData.Core.Client</PackageId>
-    <Version>2.0.3</Version>
     <Authors>Digital Data GmbH</Authors>
     <Company>Digital Data GmbH</Company>
     <Product>Digital Data GmbH</Product>
@@ -15,8 +14,9 @@
     <PackageIcon>core_icon.png</PackageIcon>
     <RepositoryUrl>http://git.dd:3000/AppStd/WebCoreModules.git</RepositoryUrl>
     <PackageTags>digital data core http client json serilization</PackageTags>
-    <AssemblyVersion>2.0.3</AssemblyVersion>
-    <FileVersion>2.0.3</FileVersion>
+    <Version>2.1.0</Version>
+    <AssemblyVersion>2.1.0</AssemblyVersion>
+    <FileVersion>2.1.0</FileVersion>
   </PropertyGroup>
 
   <ItemGroup>
@@ -26,13 +26,27 @@
     </None>
   </ItemGroup>
 
-  <ItemGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == 'net7.0'">
     <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="7.0.0" />
-    <PackageReference Include="Microsoft.Extensions.Options" Version="7.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Options" Version="7.0.1" />
     <PackageReference Include="Microsoft.Extensions.Options.ConfigurationExtensions" Version="7.0.0" />
     <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
   </ItemGroup>
 
+  <ItemGroup Condition="'$(TargetFramework)' == 'net8.0'">
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="8.0.1" />
+    <PackageReference Include="Microsoft.Extensions.Options" Version="8.0.2" />
+    <PackageReference Include="Microsoft.Extensions.Options.ConfigurationExtensions" Version="8.0.0" />
+    <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
+  </ItemGroup>
+
+  <ItemGroup Condition="'$(TargetFramework)' == 'net9.0'">
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="9.0.5" />
+    <PackageReference Include="Microsoft.Extensions.Options" Version="9.0.5" />
+    <PackageReference Include="Microsoft.Extensions.Options.ConfigurationExtensions" Version="9.0.5" />
+    <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
+  </ItemGroup>
+
   <ItemGroup>
     <ProjectReference Include="..\DigitalData.Core.Abstractions\DigitalData.Core.Abstractions.csproj" />
   </ItemGroup>

DigitalData.Core.Exceptions.Middleware/DigitalData.Core.Exceptions.Middleware.csproj

@@ -17,9 +17,9 @@
 	  <RepositoryUrl>http://git.dd:3000/AppStd/WebCoreModules.git</RepositoryUrl>
 	  <PackAsTool>False</PackAsTool>
 	  <PackageIcon>core_icon.png</PackageIcon>
-	  <Version>1.0.0</Version>
-	  <AssemblyVersion>1.0.0</AssemblyVersion>
-	  <FileVersion>1.0.0</FileVersion>
+	  <Version>1.0.1</Version>
+	  <AssemblyVersion>1.0.1</AssemblyVersion>
+	  <FileVersion>1.0.1</FileVersion>
   </PropertyGroup>
 
   <ItemGroup>
@@ -38,6 +38,10 @@
   <ItemGroup Condition="'$(TargetFramework)' == 'net9.0'">
 	<PackageReference Include="Microsoft.Extensions.Options" Version="9.0.5" />
   </ItemGroup>
+  <ItemGroup>
+    <PackageReference Include="Microsoft.AspNetCore.Http.Abstractions" Version="2.3.0" />
+    <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="9.0.7" />
+  </ItemGroup>
 
   <ItemGroup>
     <ProjectReference Include="..\DigitalData.Core.Exceptions\DigitalData.Core.Exceptions.csproj" />

DigitalData.Core.Exceptions.Middleware/GlobalExceptionHandlerMiddleware.cs

@@ -42,11 +42,11 @@ public class GlobalExceptionHandlerMiddleware
         }
         catch (Exception ex)
         {
-            if(ex.GetType() == typeof(Exception))
-                _options?.DefaultHandler?.HandleExceptionAsync.Invoke(context, ex, _logger);
+            if(ex.GetType() == typeof(Exception) && _options?.DefaultHandler is not null)
+                await _options.DefaultHandler.HandleExceptionAsync(context, ex, _logger);
 
             if (_options?.Handlers.TryGetValue(ex.GetType(), out var handler) ?? false)
-                handler?.HandleExceptionAsync.Invoke(context, ex, _logger);
+                await handler.HandleExceptionAsync(context, ex, _logger);
         }
     }
 }

DigitalData.Core.Exceptions/BadRequestException.cs

@@ -19,4 +19,13 @@ public class BadRequestException : Exception
     public BadRequestException(string? message) : base(message)
     {
     }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="BadRequestException"/> class with a specified error message and inner exception.
+    /// </summary>
+    /// <param name="message">The message that describes the error.</param>
+    /// <param name="innerException">The exception that caused the current exception.</param>
+    public BadRequestException(string? message, Exception? innerException) : base(message, innerException)
+    {
+    }
 }

DigitalData.Core.Exceptions/DigitalData.Core.Exceptions.csproj

@@ -17,9 +17,9 @@
 	<RepositoryUrl>http://git.dd:3000/AppStd/WebCoreModules.git</RepositoryUrl>
 	<PackAsTool>False</PackAsTool>
 	<PackageIcon>core_icon.png</PackageIcon>
-	<Version>1.0.1</Version>
-	<AssemblyVersion>1.0.1</AssemblyVersion>
-	<FileVersion>1.0.1</FileVersion>
+	<Version>1.1.1</Version>
+	<AssemblyVersion>1.1.1</AssemblyVersion>
+	<FileVersion>1.1.1</FileVersion>
   </PropertyGroup>
 
   <ItemGroup>

DigitalData.Core.Exceptions/ForbiddenException.cs

@@ -0,0 +1,24 @@
+namespace DigitalData.Core.Exceptions;
+
+/// <summary>
+/// Represents an exception thrown when an operation is forbidden.
+/// Typically used to indicate lack of permission or access rights.
+/// </summary>
+public class ForbiddenException : Exception
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ForbiddenException"/> class.
+    /// </summary>
+    public ForbiddenException()
+    {
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ForbiddenException"/> class with a specified error message.
+    /// </summary>
+    /// <param name="message">The message that describes the error.</param>
+    public ForbiddenException(string? message)
+        : base(message)
+    {
+    }
+}

DigitalData.Core.Infrastructure.AutoMapper/DigitalData.Core.Infrastructure.AutoMapper.csproj

@@ -6,7 +6,6 @@
     <Nullable>enable</Nullable>
     <GeneratePackageOnBuild>True</GeneratePackageOnBuild>
     <PackageId>DigitalData.Core.Infrastructure.AutoMapper</PackageId>
-    <Version>1.0.2</Version>
     <Authors>Digital Data GmbH</Authors>
     <Company>Digital Data GmbH</Company>
     <Product>DigitalData.Core.Infrastructure.AutoMapper</Product>
@@ -16,8 +15,9 @@
     <RepositoryUrl>http://git.dd:3000/AppStd/WebCoreModules.git</RepositoryUrl>
     <RepositoryType>digital data core abstractions clean architecture mapping</RepositoryType>
     <PackageTags>digital data core infrastructure clean architecture mapping</PackageTags>
-    <AssemblyVersion>1.0.2</AssemblyVersion>
-    <FileVersion>1.0.2</FileVersion>
+	<Version>1.0.3</Version>
+    <AssemblyVersion>1.0.3</AssemblyVersion>
+    <FileVersion>1.0.3</FileVersion>
   </PropertyGroup>
 
   <ItemGroup>
@@ -28,7 +28,6 @@
   </ItemGroup>
 	
   <ItemGroup>
-    <ProjectReference Include="..\DigitalData.Core.Abstractions\DigitalData.Core.Abstractions.csproj" />
     <ProjectReference Include="..\DigitalData.Core.Infrastructure\DigitalData.Core.Infrastructure.csproj" />
   </ItemGroup>
 

DigitalData.Core.Infrastructure.AutoMapper/EntityAutoMapper.cs

@@ -1,5 +1,5 @@
 using AutoMapper;
-using DigitalData.Core.Application.Interfaces.Repository;
+using DigitalData.Core.Abstraction.Application.Repository;
 
 namespace DigitalData.Core.Infrastructure.AutoMapper;
 

DigitalData.Core.Infrastructure/CRUDRepository.cs

@@ -1,6 +1,6 @@
-using DigitalData.Core.Abstractions;
-using DigitalData.Core.Application;
-using DigitalData.Core.Application.Interfaces.Repository;
+#if NET
+using DigitalData.Core.Abstraction.Application;
+using DigitalData.Core.Abstraction.Application.Repository;
 using Microsoft.EntityFrameworkCore;
 
 namespace DigitalData.Core.Infrastructure
@@ -111,4 +111,5 @@ namespace DigitalData.Core.Infrastructure
         /// </remarks>
         public virtual async Task<int> CountAsync(TId id) => await _dbSet.Where(e => e.GetId().Equals(id)).CountAsync();
     }
-}
+}
+#endif

DigitalData.Core.Infrastructure/DbRepository.cs

@@ -1,87 +1,162 @@
-using DigitalData.Core.Application.Interfaces.Repository;
+using AutoMapper;
+using DigitalData.Core.Abstraction.Application.Repository;
+using DigitalData.Core.Infrastructure.Factory;
 using Microsoft.EntityFrameworkCore;
 using System.Linq.Expressions;
+using Microsoft.EntityFrameworkCore.Query;
+#if NETFRAMEWORK
+using System.Collections.Generic;
+using System;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+#endif
 
-namespace DigitalData.Core.Infrastructure;
-
-public class DbRepository<TDbContext, TEntity> : IRepository<TEntity> where TDbContext : DbContext where TEntity : class
+namespace DigitalData.Core.Infrastructure
 {
-    protected internal readonly TDbContext Context;
-
-    protected internal readonly DbSet<TEntity> Entities;
-
-    public IEntityMapper<TEntity> Mapper { get; }
-
-    public DbRepository(TDbContext context, Func<TDbContext, DbSet<TEntity>> queryFactory, IEntityMapper<TEntity> mapper)
+    public class DbRepository<TDbContext> : IRepository where TDbContext : DbContext
     {
-        Context = context;
-        Entities = queryFactory(context);
-        Mapper = mapper;
-    }
+        protected internal readonly TDbContext Context;
 
-    public virtual async Task<TEntity> CreateAsync(TEntity entity, CancellationToken ct = default)
-    {
-        Entities.Add(entity);
-        await Context.SaveChangesAsync(ct);
-        return entity;
-    }
-
-    public virtual async Task<IEnumerable<TEntity>> CreateAsync(IEnumerable<TEntity> entities, CancellationToken ct = default)
-    {
-        Entities.AddRange(entities);
-        await Context.SaveChangesAsync(ct);
-        return entities;
-    }
-
-    public IReadQuery<TEntity> Read(params Expression<Func<TEntity, bool>>[] expressions) => new ReadQuery<TEntity>(Entities.AsNoTracking()).Where(expressions);
-    
-    public virtual async Task UpdateAsync<TDto>(TDto dto, Expression<Func<TEntity, bool>> expression, CancellationToken ct = default)
-    {
-        var entities = await Entities.Where(expression).ToListAsync(ct);
-
-        for (int i = entities.Count - 1; i >= 0; i--)
+        public DbRepository(TDbContext context)
         {
-            Mapper.Map(dto, entities[i]);
-            Entities.Update(entities[i]);
+            Context = context;
         }
 
-        await Context.SaveChangesAsync(ct);
-    }
-
-    public virtual async Task DeleteAsync(Expression<Func<TEntity, bool>> expression, CancellationToken ct = default)
-    {
-        var entities = await Entities.Where(expression).ToListAsync(ct);
-
-        for (int i = entities.Count - 1; i >= 0; i--)
+        public Task<int> ExecuteQueryRawAsync([NotParameterized] string sql, IEnumerable<object> parameters, CancellationToken cancel = default)
         {
-            Entities.Remove(entities[i]);
+            return Context.Database.ExecuteSqlRawAsync(sql, parameters, cancel);
         }
 
-        await Context.SaveChangesAsync(ct);
+        public Task<int> ExecuteQueryInterpolatedAsync(FormattableString sql, CancellationToken cancel = default)
+        {
+            return Context.Database.ExecuteSqlInterpolatedAsync(sql, cancel);
+        }
+
+        public int ExecuteQueryRaw([NotParameterized] string sql, params object[] parameters)
+        {
+            return Context.Database.ExecuteSqlRaw(sql, parameters);
+        }
+
+        public int ExecuteQueryInterpolated(FormattableString sql)
+        {
+            return Context.Database.ExecuteSqlInterpolated(sql);
+        }
     }
 
-    #region Obsolete
-    [Obsolete("Use Read-method returning IReadQuery<TEntity> instead.")]
-    public virtual async Task<IEnumerable<TEntity>> ReadAllAsync(Expression<Func<TEntity, bool>>? expression = null, CancellationToken ct = default)
-        => expression is null
-            ? await Entities.AsNoTracking().ToListAsync(ct)
-            : await Entities.AsNoTracking().Where(expression).ToListAsync(ct);
-
-    [Obsolete("Use Read-method returning IReadQuery<TEntity> instead.")]
-    public virtual async Task<TEntity?> ReadOrDefaultAsync(Expression<Func<TEntity, bool>> expression, bool single = true, CancellationToken ct = default)
-        => single
-            ? await Entities.AsNoTracking().Where(expression).SingleOrDefaultAsync(ct)
-            : await Entities.AsNoTracking().Where(expression).FirstOrDefaultAsync(ct);
-
-    [Obsolete("Use Read-method returning IReadQuery<TEntity> instead.")]
-    public virtual async Task<IEnumerable<TDto>> ReadAllAsync<TDto>(Expression<Func<TEntity, bool>>? expression = null, CancellationToken ct = default)
-        => Mapper.Map<TDto>(await ReadAllAsync(expression, ct));
-
-    [Obsolete("Use Read-method returning IReadQuery<TEntity> instead.")]
-    public virtual async Task<TDto?> ReadOrDefaultAsync<TDto>(Expression<Func<TEntity, bool>> expression, bool single = true, CancellationToken ct = default)
+    public class DbRepository<TDbContext, TEntity> : IRepository<TEntity> where TDbContext : DbContext where TEntity : class
     {
-        var entity = await ReadOrDefaultAsync(expression, single, ct);
-        return entity is null ? default : Mapper.Map<TDto>(entity);
+        protected internal readonly TDbContext Context;
+
+        protected internal readonly DbSet<TEntity> Entities;
+
+        public IMapper
+#if NET
+        ?
+#endif
+            Mapper { get; }
+
+        public DbRepository(TDbContext context, DbSetFactory<TDbContext, TEntity> factory, IMapper
+#if NET
+        ?
+#endif
+            mapper = null)
+        {
+            Context = context;
+            Entities = factory.Create(context);
+            Mapper = mapper;
+        }
+
+        #region Create
+        public virtual async Task<TEntity> CreateAsync(TEntity entity, CancellationToken cancel = default)
+        {
+            Entities.Add(entity);
+            await Context.SaveChangesAsync(cancel);
+            return entity;
+        }
+
+        public virtual async Task<IEnumerable<TEntity>> CreateAsync(IEnumerable<TEntity> entities, CancellationToken cancel = default)
+        {
+            Entities.AddRange(entities);
+            await Context.SaveChangesAsync(cancel);
+            return entities;
+        }
+
+        public virtual Task<TEntity> CreateAsync<TDto>(TDto dto, CancellationToken cancel = default)
+            => CreateAsync(Mapper
+#if NET
+            !
+#endif
+                .Map<TEntity>(dto), cancel);
+
+        public virtual Task<IEnumerable<TEntity>> CreateAsync<TDto>(IEnumerable<TDto> dtos, CancellationToken cancel = default)
+            => CreateAsync(Mapper
+#if NET
+            !
+#endif
+                .Map<IEnumerable<TEntity>>(dtos), cancel);
+        #endregion Create
+
+        #region Read
+        public virtual IQueryable<TEntity> Query => Entities.AsNoTracking();
+
+        public virtual IQueryable<TEntity> QueryRaw([NotParameterized] string sql, params object[] parameters) => Entities.FromSqlRaw(sql, parameters).AsNoTracking();
+
+        public virtual IQueryable<TEntity> QueryInterpolated([NotParameterized] FormattableString sql) => Entities.FromSqlInterpolated(sql).AsNoTracking();
+
+        public virtual IQueryable<TEntity> Where(Expression<Func<TEntity, bool>> expression) => Entities.AsNoTracking().Where(expression);
+
+        public virtual IEnumerable<TEntity> GetAll() => Entities.AsNoTracking().ToList();
+
+        public virtual async Task<IEnumerable<TEntity>> GetAllAsync(CancellationToken cancel = default) => await Entities.AsNoTracking().ToListAsync(cancel);
+        #endregion Read
+
+        #region Update
+        public virtual Task UpdateAsync<TDto>(TDto dto, Expression<Func<TEntity, bool>> expression, CancellationToken cancel = default) => UpdateAsync(dto, q => q.Where(expression), cancel);
+
+        public virtual Task UpdateAsync<TDto>(TDto dto, Func<IQueryable<TEntity>, IQueryable<TEntity>> query, CancellationToken cancel = default)
+            => UpdateAsync(entity => Mapper
+#if NET
+                                            !
+#endif
+                                            .Map(dto, entity), query, cancel);
+
+        public virtual async Task UpdateAsync(Action<TEntity> modification, Func<IQueryable<TEntity>, IQueryable<TEntity>> query, CancellationToken cancel = default)
+        {
+            var entities = await query(Entities).ToListAsync(cancel);
+
+            for (int i = entities.Count - 1; i >= 0; i--)
+                modification.Invoke(entities[i]);
+
+            await Context.SaveChangesAsync(cancel);
+        }
+
+        public virtual Task UpdateAsync(Action<TEntity> modification, Expression<Func<TEntity, bool>> expression, CancellationToken cancel = default)
+            => UpdateAsync(modification, q => q.Where(expression), cancel);
+        #endregion Update
+
+        #region Delete
+        public virtual Task DeleteAsync(Expression<Func<TEntity, bool>> expression, CancellationToken cancel = default) => DeleteAsync(q => q.Where(expression), cancel);
+
+        public virtual async Task DeleteAsync(Func<IQueryable<TEntity>, IQueryable<TEntity>> query, CancellationToken cancel = default)
+        {
+            var entities = await query(Entities).ToListAsync(cancel);
+
+            for (int i = entities.Count - 1; i >= 0; i--)
+            {
+                Entities.Remove(entities[i]);
+            }
+
+            await Context.SaveChangesAsync(cancel);
+        }
+        #endregion Delete
+
+        #region Obsolete
+        [Obsolete("Use IRepository<TEntity>.Where")]
+        public virtual IQueryable<TEntity> Read() => Entities.AsQueryable();
+
+        [Obsolete("Use IRepository<TEntity>.Get")]
+        public virtual IQueryable<TEntity> ReadOnly() => Entities.AsNoTracking();
+        #endregion
     }
-    #endregion
 }

DigitalData.Core.Infrastructure/DependencyInjection.cs

@@ -1,19 +1,147 @@
-using DigitalData.Core.Application.Interfaces.Repository;
+using DigitalData.Core.Abstraction.Application.Repository;
+using DigitalData.Core.Infrastructure.Factory;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.DependencyInjection;
+using System.ComponentModel.DataAnnotations.Schema;
+using System.Reflection;
+#if NETFRAMEWORK
+using System.Collections.Generic;
+using System;
+using System.Linq;
+#endif
 
-namespace DigitalData.Core.Infrastructure;
-
-public static class DependencyInjection
+namespace DigitalData.Core.Infrastructure
 {
-    public static EntityConfigurationOptions<TEntity> AddDbRepository<TDbContext, TEntity>(this IServiceCollection services, Func<TDbContext, DbSet<TEntity>> queryFactory)
-        where TDbContext : DbContext
-        where TEntity : class
+    public static class DependencyInjection
     {
-        services
-            .AddScoped<IRepository<TEntity>, DbRepository<TDbContext, TEntity>>()
-            .AddSingleton(queryFactory);
+        public static IServiceCollection AddDbRepository(this IServiceCollection services, Action<RepositoryConfiguration> options)
+        {
+            // register services from configuration
+            var cfg = new RepositoryConfiguration();
+            options.Invoke(cfg);
+            cfg.RegisterAllServices(services);
 
-        return new EntityConfigurationOptions<TEntity>(services);
+            return services;
+        }
+
+        public class RepositoryConfiguration
+        {
+            // 1. register from assembly
+            private readonly Queue<Action<IServiceCollection>> RegsFromAssembly = new Queue<Action<IServiceCollection>>();
+
+            // 2. register entities (can overwrite)
+            private readonly Queue<Action<IServiceCollection>> RegsEntity = new Queue<Action<IServiceCollection>>();
+
+            // 3. register db set factories (can overwrite)
+            private readonly Queue<Action<IServiceCollection>> RegsDbSetFactory = new Queue<Action<IServiceCollection>>();
+
+            // 4. register repository
+            private readonly Queue<Action<IServiceCollection>> RegsRepository = new Queue<Action<IServiceCollection>>();
+
+            internal void RegisterAllServices(IServiceCollection services)
+            {
+                // 1. register from assembly
+                RegsFromAssembly.InvokeAll(services);
+
+                // 2. register entities (can overwrite)
+                RegsEntity.InvokeAll(services);
+
+                // 3. register db set factories (can overwrite)
+                RegsDbSetFactory.InvokeAll(services);
+
+                // 4. register repository
+                RegsRepository.InvokeAll(services);
+            }
+
+            internal RepositoryConfiguration() { }
+
+            public void RegisterFromAssembly<TDbContext>(Assembly assembly) where TDbContext : DbContext
+            {
+                void reg(IServiceCollection services)
+                {
+                    // scan all types in the Assembly
+                    var entityTypes = assembly.GetTypes()
+                        .Where(t => t.IsClass && !t.IsAbstract && t.GetCustomAttribute<TableAttribute>() != null);
+
+                    foreach (var entityType in entityTypes)
+                    {
+                        #region Repository
+                        /// register repository
+                        // create generic DbRepository<DbContext, TEntity> type
+                        var repositoryType = typeof(DbRepository<,>).MakeGenericType(typeof(TDbContext), entityType);
+                        var interfaceType = typeof(IRepository<>).MakeGenericType(entityType);
+
+                        // add into DI container as Scoped
+                        services.AddScoped(interfaceType, repositoryType);
+                        #endregion Repository
+
+                        #region DbSetFactory
+                        /// register DbSetFactory
+                        var addDbSetFactoryMethod = typeof(DependencyInjection)
+                            .GetMethod(nameof(AddDbSetFactory),
+                                       BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);
+
+                        var genericMethod = addDbSetFactoryMethod
+#if NET
+                                        !
+#endif
+                                            .MakeGenericMethod(typeof(TDbContext), entityType);
+                        genericMethod.Invoke(null, new [] { services, null });
+                        #endregion DbSetFactory
+                    }
+                }
+
+                RegsFromAssembly.Enqueue(reg);
+            }
+
+            public void RegisterEntity<TDbContext, TEntity>(Func<TDbContext, DbSet<TEntity>>
+#if NET
+            ?
+#endif
+                dbSetFactory = null)
+                where TDbContext : DbContext
+                where TEntity : class
+            {
+                void reg(IServiceCollection services)
+                    => services
+                        .AddScoped<IRepository<TEntity>, DbRepository<TDbContext, TEntity>>()
+                        .AddDbSetFactory(dbSetFactory);
+
+                RegsEntity.Enqueue(reg);
+            }
+
+            public void RegisterDbSetFactory<TDbContext, TEntity>(Func<TDbContext, DbSet<TEntity>> dbSetFactory)
+                where TDbContext : DbContext
+                where TEntity : class
+                => RegsDbSetFactory.Enqueue(s => s.AddDbSetFactory(dbSetFactory));
+
+            public void RegisterDefaultRepository<TDbContext>()
+                where TDbContext : DbContext
+                => RegsRepository.Enqueue(s => s.AddScoped<IRepository, DbRepository<TDbContext>>());
+        }
+
+        private static void InvokeAll<T>(this Queue<Action<T>> queue, T services)
+        {
+            while (queue.Count > 0)
+                queue.Dequeue().Invoke(services);
+        }
+
+        internal static IServiceCollection AddDbSetFactory<TDbContext, TEntity>(this IServiceCollection services, Func<TDbContext, DbSet<TEntity>>
+#if NET
+        ?
+#endif
+            create = null)
+            where TDbContext : DbContext
+            where TEntity : class
+        {
+#if NET
+            create ??= ctx => ctx.Set<TEntity>();
+#elif NETFRAMEWORK
+            if(create is null)
+                create = ctx => ctx.Set<TEntity>();
+#endif
+            services.AddSingleton(_ => new DbSetFactory<TDbContext, TEntity>(create));
+            return services;
+        }
     }
 }

DigitalData.Core.Infrastructure/DigitalData.Core.Infrastructure.csproj

@@ -1,9 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>net7.0;net8.0;net9.0</TargetFrameworks>
-    <ImplicitUsings>enable</ImplicitUsings>
-    <Nullable>enable</Nullable>
+    <TargetFrameworks>net462;net7.0;net8.0;net9.0</TargetFrameworks>
     <GeneratePackageOnBuild>True</GeneratePackageOnBuild>
     <PackageId>DigitalData.Core.Infrastructure</PackageId>
     <Authors>Digital Data GmbH</Authors>
@@ -15,9 +13,9 @@
     <RepositoryUrl>http://git.dd:3000/AppStd/WebCoreModules.git</RepositoryUrl>
     <RepositoryType>digital data core abstractions clean architecture</RepositoryType>
     <PackageTags>digital data core infrastructure clean architecture</PackageTags>
-    <Version>2.1.0</Version>
-    <AssemblyVersion>2.1.0</AssemblyVersion>
-    <FileVersion>2.1.0</FileVersion>
+    <Version>2.6.1</Version>
+    <AssemblyVersion>2.6.1</AssemblyVersion>
+    <FileVersion>2.6.1</FileVersion>
   </PropertyGroup>
 
   <ItemGroup>
@@ -27,21 +25,42 @@
     </None>
   </ItemGroup>
 
+  <!-- disable for net462 -->
+  <PropertyGroup Condition="'$(TargetFramework)' == 'net462'">
+	<Nullable>disable</Nullable>
+	<ImplicitUsings>disable</ImplicitUsings>
+	<LangVersion>7.3</LangVersion>
+  </PropertyGroup>
+
+  <!-- enable for net7 and more -->
+  <PropertyGroup Condition="'$(TargetFramework)' == 'net7.0' Or '$(TargetFramework)' == 'net8.0' Or '$(TargetFramework)' == 'net9.0'">
+	<Nullable>enable</Nullable>
+	<ImplicitUsings>enable</ImplicitUsings>
+	<LangVersion>latest</LangVersion>
+  </PropertyGroup>
+
+  <ItemGroup Condition="'$(TargetFramework)' == 'net462'">
+	<PackageReference Include="Microsoft.EntityFrameworkCore" Version="3.1.32" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Relational" Version="3.1.32" />
+  </ItemGroup>
+
   <ItemGroup Condition="'$(TargetFramework)' == 'net7.0'">
     <PackageReference Include="Microsoft.EntityFrameworkCore" Version="7.0.20" />
+	<PackageReference Include="Microsoft.EntityFrameworkCore.Relational" Version="7.0.20" />
   </ItemGroup>
 
   <ItemGroup Condition="'$(TargetFramework)' == 'net8.0'">
     <PackageReference Include="Microsoft.EntityFrameworkCore" Version="8.0.15" />
+	<PackageReference Include="Microsoft.EntityFrameworkCore.Relational" Version="8.0.15" />
   </ItemGroup>
 
   <ItemGroup Condition="'$(TargetFramework)' == 'net9.0'">
-    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="9.0.4" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="9.0.5" />
+	<PackageReference Include="Microsoft.EntityFrameworkCore.Relational" Version="9.0.5" />
   </ItemGroup>
 
   <ItemGroup>
-    <ProjectReference Include="..\DigitalData.Core.Abstractions\DigitalData.Core.Abstractions.csproj" />
-    <ProjectReference Include="..\DigitalData.Core.Application\DigitalData.Core.Application.csproj" />
+    <ProjectReference Include="..\DigitalData.Core.Abstraction.Application\DigitalData.Core.Abstraction.Application.csproj" />
   </ItemGroup>
 
   <ItemGroup>

DigitalData.Core.Infrastructure/EntityConfigurationOptions.cs

@@ -1,27 +0,0 @@
-using DigitalData.Core.Application.Interfaces.Repository;
-using Microsoft.Extensions.DependencyInjection;
-
-namespace DigitalData.Core.Infrastructure;
-
-public class EntityConfigurationOptions<TEntity>
-{
-    private readonly IServiceCollection _services;
-
-    public EntityConfigurationOptions(IServiceCollection services)
-    {
-        _services = services;
-    }
-
-    public EntityConfigurationOptions<TEntity> AddCustomMapper<TEntityMapper>(Action<IServiceCollection> configure, Func<IServiceProvider, TEntityMapper>? factory = null)
-        where TEntityMapper : class, IEntityMapper<TEntity>
-    {
-        configure(_services);
-
-        if (factory is null)
-            _services.AddSingleton<IEntityMapper<TEntity>, TEntityMapper>();
-        else
-            _services.AddSingleton(factory);
-        
-        return this;
-    }
-}

DigitalData.Core.Infrastructure/Factory/DbSetFactory.cs

@@ -0,0 +1,25 @@
+using Microsoft.EntityFrameworkCore;
+#if NETFRAMEWORK
+using System;
+#endif
+
+namespace DigitalData.Core.Infrastructure.Factory
+#if NET
+    ;
+#elif NETFRAMEWORK
+    {
+#endif
+
+public class DbSetFactory<TDbContext,TEntity> where TDbContext : DbContext where TEntity : class
+{
+    public readonly Func<TDbContext, DbSet<TEntity>> Create;
+
+    public DbSetFactory(Func<TDbContext, DbSet<TEntity>> create)
+    {
+        Create = create;
+    }
+}
+
+#if NETFRAMEWORK
+    }
+#endif

DigitalData.Core.Infrastructure/ReadQuery.cs

@@ -1,48 +0,0 @@
-using DigitalData.Core.Application.Interfaces.Repository;
-using Microsoft.EntityFrameworkCore;
-using System.Linq.Expressions;
-
-namespace DigitalData.Core.Infrastructure;
-
-public sealed record ReadQuery<TEntity> : IReadQuery<TEntity>
-{
-    private IQueryable<TEntity> _query;
-
-    internal ReadQuery(IQueryable<TEntity> queryable)
-    {
-        _query = queryable;
-    }
-
-    public TEntity First() => _query.First();
-
-    public Task<TEntity> FirstAsync(CancellationToken cancellation = default) => _query.FirstAsync(cancellation);
-
-    public TEntity? FirstOrDefault() => _query.FirstOrDefault();
-
-
-    public Task<TEntity?> FirstOrDefaultAsync(CancellationToken cancellation = default) => _query.FirstOrDefaultAsync(cancellation);
-
-
-    public TEntity Single() => _query.Single();
-
-
-    public Task<TEntity> SingleAsync(CancellationToken cancellation = default) => _query.SingleAsync(cancellation);
-
-
-    public TEntity? SingleOrDefault() => _query.SingleOrDefault();
-
-
-    public Task<TEntity?> SingleOrDefaultAsync(CancellationToken cancellation = default) => _query.SingleOrDefaultAsync(cancellation);
-
-
-    public IEnumerable<TEntity> ToList() => _query.ToList();
-
-
-    public async Task<IEnumerable<TEntity>> ToListAsync(CancellationToken cancellation = default) => await _query.ToListAsync(cancellation);
-
-    public IReadQuery<TEntity> Where(Expression<Func<TEntity, bool>> expression)
-    {
-        _query = _query.Where(expression);
-        return this;
-    }
-}

DigitalData.Core.Tests/Abstractions/FactoryTests.cs

@@ -0,0 +1,173 @@
+using Microsoft.Extensions.DependencyInjection;
+using DigitalData.Core.Abstractions;
+
+namespace DigitalData.Core.Tests.Abstractions
+{
+    [TestFixture]
+    public class FactoryTests
+    {
+        private Factory _factory;
+
+        [SetUp]
+        public void Setup()
+        {
+            _factory = new Factory();
+        }
+
+        [Test]
+        public void Add_ServiceDescriptor_ShouldIncreaseCount()
+        {
+            // Arrange
+            var descriptor = ServiceDescriptor.Singleton(typeof(string), "test");
+
+            // Act
+            _factory.Add(descriptor);
+
+            // Assert
+            Assert.That(_factory.Count, Is.EqualTo(1));
+            Assert.That(_factory.Contains(descriptor), Is.True);
+        }
+
+        [Test]
+        public void Clear_ShouldRemoveAllServices()
+        {
+            // Arrange
+            _factory.Add(ServiceDescriptor.Singleton(typeof(string), "test"));
+            _factory.Add(ServiceDescriptor.Singleton(typeof(int), 42));
+
+            // Act
+            _factory.Clear();
+
+            // Assert
+            Assert.That(_factory.Count, Is.EqualTo(0));
+        }
+
+        [Test]
+        public void GetService_ShouldReturnRegisteredInstance()
+        {
+            // Arrange
+            _factory.Add(ServiceDescriptor.Singleton(typeof(string), "Hello World"));
+
+            // Act
+            var result = _factory.GetService(typeof(string));
+
+            // Assert
+            Assert.That(result, Is.EqualTo("Hello World"));
+        }
+
+        [Test]
+        public void GetService_UnregisteredType_ShouldReturnNull()
+        {
+            // Act
+            var result = _factory.GetService(typeof(int));
+
+            // Assert
+            Assert.That(result, Is.Null);
+        }
+
+        [Test]
+        public void ModifyAfterBuild_ShouldThrowInvalidOperationException()
+        {
+            // Arrange
+            _factory.Add(ServiceDescriptor.Singleton(typeof(string), "x"));
+            var _ = _factory.GetService(typeof(string)); // trigger build
+
+            // Act & Assert
+            Assert.Throws<InvalidOperationException>(() => _factory.Add(ServiceDescriptor.Singleton(typeof(int), 1)));
+        }
+
+        [Test]
+        public void Remove_ShouldWorkBeforeBuild()
+        {
+            // Arrange
+            var descriptor = ServiceDescriptor.Singleton(typeof(string), "Test");
+            _factory.Add(descriptor);
+
+            // Act
+            var removed = _factory.Remove(descriptor);
+
+            // Assert
+            Assert.That(removed, Is.True);
+            Assert.That(_factory.Count, Is.EqualTo(0));
+        }
+
+        [Test]
+        public void Insert_ShouldInsertAtCorrectIndex()
+        {
+            // Arrange
+            var d1 = ServiceDescriptor.Singleton(typeof(string), "A");
+            var d2 = ServiceDescriptor.Singleton(typeof(int), 1);
+
+            _factory.Add(d1);
+            _factory.Insert(0, d2);
+
+            // Act
+            var first = _factory[0];
+
+            // Assert
+            Assert.That(first.ServiceType, Is.EqualTo(typeof(int)));
+        }
+
+        [Test]
+        public void Enumerator_ShouldIterateOverServices()
+        {
+            // Arrange
+            _factory.Add(ServiceDescriptor.Singleton(typeof(string), "a"));
+            _factory.Add(ServiceDescriptor.Singleton(typeof(int), 5));
+
+            // Act
+            var list = _factory.ToList();
+
+            // Assert
+            Assert.That(list.Count, Is.EqualTo(2));
+            Assert.That(list.Any(sd => sd.ServiceType == typeof(string)), Is.True);
+            Assert.That(list.Any(sd => sd.ServiceType == typeof(int)), Is.True);
+        }
+
+        [Test]
+        public void CopyTo_ShouldCopyElements()
+        {
+            // Arrange
+            _factory.Add(ServiceDescriptor.Singleton(typeof(string), "x"));
+            _factory.Add(ServiceDescriptor.Singleton(typeof(int), 10));
+            var array = new ServiceDescriptor[2];
+
+            // Act
+            _factory.CopyTo(array, 0);
+
+            // Assert
+            Assert.That(array[0].ServiceType, Is.EqualTo(typeof(string)));
+            Assert.That(array[1].ServiceType, Is.EqualTo(typeof(int)));
+        }
+
+        [Test]
+        public void RemoveAt_ShouldRemoveItemAtIndex()
+        {
+            // Arrange
+            _factory.Add(ServiceDescriptor.Singleton(typeof(string), "x"));
+            _factory.Add(ServiceDescriptor.Singleton(typeof(int), 5));
+
+            // Act
+            _factory.RemoveAt(0);
+
+            // Assert
+            Assert.That(_factory.Count, Is.EqualTo(1));
+            Assert.That(_factory[0].ServiceType, Is.EqualTo(typeof(int)));
+        }
+
+        [Test]
+        public void Indexer_Set_ShouldReplaceItem()
+        {
+            // Arrange
+            var original = ServiceDescriptor.Singleton(typeof(string), "A");
+            var replacement = ServiceDescriptor.Singleton(typeof(string), "B");
+            _factory.Add(original);
+
+            // Act
+            _factory[0] = replacement;
+
+            // Assert
+            Assert.That(_factory[0], Is.EqualTo(replacement));
+        }
+    }
+}

DigitalData.Core.Tests/DigitalData.Core.Tests.csproj

@@ -26,7 +26,6 @@
     <ProjectReference Include="..\DigitalData.Core.Application\DigitalData.Core.Application.csproj" />
     <ProjectReference Include="..\DigitalData.Core.Client\DigitalData.Core.Client.csproj" />
     <ProjectReference Include="..\DigitalData.Core.DTO\DigitalData.Core.DTO.csproj" />
-    <ProjectReference Include="..\DigitalData.Core.Infrastructure.AutoMapper\DigitalData.Core.Infrastructure.AutoMapper.csproj" />
     <ProjectReference Include="..\DigitalData.Core.Infrastructure\DigitalData.Core.Infrastructure.csproj" />
     <ProjectReference Include="..\DigitalData.Core.Security\DigitalData.Core.Security.csproj" />
   </ItemGroup>
@@ -42,7 +41,7 @@
   </ItemGroup>
 
   <ItemGroup Condition="'$(TargetFramework)' == 'net9.0'">
-    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="9.0.4" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="9.0.5" />
 	<PackageReference Include="Microsoft.EntityFrameworkCore.InMemory" Version="9.0.4" />
   </ItemGroup>
 

DigitalData.Core.Tests/Infrastructure/DbRepositoryTests.cs

@@ -1,113 +0,0 @@
-namespace DigitalData.Core.Tests.Infrastructure;
-
-using DigitalData.Core.Infrastructure;
-using DigitalData.Core.Tests.Mock;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Hosting;
-using System.Reflection;
-using DigitalData.Core.Infrastructure.AutoMapper;
-using DigitalData.Core.Application.Interfaces.Repository;
-
-public class DbRepositoryTests
-{
-    private IHost _host;
-
-    private IRepository<User> _userRepo;
-
-    [SetUp]
-    public void Setup()
-    {
-        var builder = Host.CreateApplicationBuilder();
-
-        builder.Services.AddDbContext<MockDbContext>(opt => opt.UseInMemoryDatabase("MockDB"));
-
-        builder.Services.AddDbRepository<MockDbContext, User>(context => context.Users).UseAutoMapper(typeof(UserCreateDto), typeof(UserReadDto), typeof(UserBase));
-
-        builder.Services.AddAutoMapper(Assembly.GetExecutingAssembly());
-
-        _host = builder.Build();
-
-        _userRepo = _host.Services.GetRequiredService<IRepository<User>>();
-    }
-
-    [TearDown]
-    public void TearDown()
-    {
-        if (_host is IDisposable disposableHost)
-            disposableHost.Dispose();
-    }
-
-    [TestCase(true, TestName = "WhenGivenMultipleUsers")]
-    [TestCase(false, TestName = "WhenGivenSingleUser")]
-    public void CreateAsync_ShouldNotThrow(bool multiple)
-    {
-        // Arrange
-        var faker = Fake.CreateUserFaker();
-
-        // Act & Assert
-        if (multiple)
-            Assert.DoesNotThrowAsync(async () => await _userRepo.CreateAsync(faker.Generate(Random.Shared.Next(1, 10))));
-        else
-            Assert.DoesNotThrowAsync(async () => await _userRepo.CreateAsync(faker.Generate()));
-    }
-
-    [TestCase(true, TestName = "WhenDtoUsed")]
-    [TestCase(false, TestName = "WhenEntityUsed")]
-    public async Task ReadAsync_ShouldReturnCreated(bool useDto)
-    {
-        // Act
-        var createdUser = useDto
-            ? await _userRepo.CreateAsync(Fake.UserCreateDto)
-            : await _userRepo.CreateAsync(Fake.User);
-
-        var readUser = await _userRepo.ReadFirstOrDefaultAsync(u => u.Id == createdUser.Id);
-
-        // Assert
-        Assert.Multiple(() =>
-        {
-            Assert.That(readUser, Is.Not.Null);
-            Assert.That(readUser, Is.EqualTo(createdUser));
-        });
-    }
-
-    [Test]
-    public async Task ReadAsync_ShouldReturnUpdated()
-    {
-        // Arrange
-        var createdUser = await _userRepo.CreateAsync(Fake.UserCreateDto);
-        var userUpdateDto = new UserUpdateDto() { Age = 10, Email = "Bar", FirstName = "Foo" };
-
-        // Act
-        await _userRepo.UpdateAsync(userUpdateDto, u => u.Id == createdUser!.Id);
-        var upToDateUser = await _userRepo.ReadFirstOrDefaultAsync(u => u.Id == createdUser!.Id);
-
-        // Assert
-        Assert.Multiple(() =>
-        {
-            Assert.That(upToDateUser, Is.Not.Null);
-            Assert.That(upToDateUser?.FirstName, Is.EqualTo(userUpdateDto.FirstName));
-            Assert.That(upToDateUser?.Email, Is.EqualTo(userUpdateDto.Email));
-            Assert.That(upToDateUser?.Age, Is.EqualTo(userUpdateDto.Age));
-        });
-    }
-
-    [Test]
-    public async Task ReadAsync_ShouldNotReturnDeleted()
-    {
-        // Arrange
-        var createdUser = await _userRepo.CreateAsync(Fake.UserCreateDto);
-        var readUser = await _userRepo.ReadFirstOrDefaultAsync(u => u.Id == createdUser.Id);
-
-        // Act
-        await _userRepo.DeleteAsync(u => u.Id == createdUser.Id);
-        var deletedUser = await _userRepo.ReadFirstOrDefaultAsync(u => u.Id == createdUser.Id);
-        
-        // Assert
-        Assert.Multiple(() =>
-        {
-            Assert.That(readUser, Is.Not.Null);
-            Assert.That(deletedUser, Is.Null);
-        });
-    }
-}

DigitalData.Core.Tests/Mock/User.cs

@@ -1,6 +1,10 @@
-namespace DigitalData.Core.Tests.Mock;
+using DigitalData.Core.Abstractions.Interfaces;
+using System.ComponentModel.DataAnnotations.Schema;
 
-public class User : UserBase
+namespace DigitalData.Core.Tests.Mock;
+
+[Table("USER")]
+public class User : UserBase, IEntity
 {
     public required int Id { get; init; }
 
@@ -9,4 +13,4 @@ public class User : UserBase
     public override bool Equals(object? obj)
         => (obj is User user && user.GetHashCode() == GetHashCode())
         || (obj is UserBase userBase && userBase.GetHashCode() == base.GetHashCode());
-}
+}

DigitalData.Core.Tests/Mock/UserCreateDto.cs

@@ -1,5 +1,7 @@
-namespace DigitalData.Core.Tests.Mock;
+using DigitalData.Core.Abstractions.Interfaces;
 
-public class UserCreateDto : UserBase
+namespace DigitalData.Core.Tests.Mock;
+
+public class UserCreateDto : UserBase, IDto<User>
 {
-}
+}

DigitalData.Core.Tests/Mock/UserReadDto.cs

@@ -1,5 +1,7 @@
-namespace DigitalData.Core.Tests.Mock;
+using DigitalData.Core.Abstractions.Interfaces;
 
-public class UserReadDto : UserBase
+namespace DigitalData.Core.Tests.Mock;
+
+public class UserReadDto : UserBase, IDto<User>
 {
-}
+}

DigitalData.Core.Tests/Mock/UserUpdateDto.cs

@@ -1,5 +1,7 @@
-namespace DigitalData.Core.Tests.Mock;
+using DigitalData.Core.Abstractions.Interfaces;
 
-public class UserUpdateDto : UserBase
+namespace DigitalData.Core.Tests.Mock;
+
+public class UserUpdateDto : UserBase, IDto<User>
 {
-}
+}

DigitalData.Core.sln

@@ -51,6 +51,10 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "assets", "assets", "{0A27EA
 		Assets\core_legacy_icon.png = Assets\core_legacy_icon.png
 	EndProjectSection
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DigitalData.Core.Abstraction.Application", "DigitalData.Core.Abstraction.Application\DigitalData.Core.Abstraction.Application.csproj", "{420C35A7-0EDE-4E2E-8500-484B57B0367A}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Application", "Application", "{E18417C2-D9F5-437A-9ED5-473DD6260066}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -120,13 +124,17 @@ Global
 		{2336AE61-A21D-437E-A11B-367D008A64B2}.Debug|Any CPU.Build.0 = Release|Any CPU
 		{2336AE61-A21D-437E-A11B-367D008A64B2}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{2336AE61-A21D-437E-A11B-367D008A64B2}.Release|Any CPU.Build.0 = Release|Any CPU
+		{420C35A7-0EDE-4E2E-8500-484B57B0367A}.Debug|Any CPU.ActiveCfg = Release|Any CPU
+		{420C35A7-0EDE-4E2E-8500-484B57B0367A}.Debug|Any CPU.Build.0 = Release|Any CPU
+		{420C35A7-0EDE-4E2E-8500-484B57B0367A}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{420C35A7-0EDE-4E2E-8500-484B57B0367A}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
 	EndGlobalSection
 	GlobalSection(NestedProjects) = preSolution
 		{A765EBEA-3D1E-4F36-869B-6D72F87FF3F6} = {41795B74-A757-4E93-B907-83BFF04EEE5C}
-		{DB404CD9-CBB8-4771-AB1B-FD4FDE2C28CC} = {02EA681E-C7D8-13C7-8484-4AC65E1B71E8}
+		{DB404CD9-CBB8-4771-AB1B-FD4FDE2C28CC} = {E18417C2-D9F5-437A-9ED5-473DD6260066}
 		{C57B2480-F632-4691-9C4C-8CC01237203C} = {02EA681E-C7D8-13C7-8484-4AC65E1B71E8}
 		{B54DEF90-C30C-44EA-9875-76F1B330CBB7} = {EDF84A84-1E01-484E-B073-383F7139C891}
 		{0B051A5F-BD38-47D1-BAFF-D44BA30D3FB7} = {02EA681E-C7D8-13C7-8484-4AC65E1B71E8}
@@ -144,6 +152,8 @@ Global
 		{BAEF6CC9-4FE2-4E3F-9D32-911C9E8CCFB4} = {8C3AF25D-81D9-4651-90CA-BF0BD2A03EA7}
 		{2336AE61-A21D-437E-A11B-367D008A64B2} = {8C3AF25D-81D9-4651-90CA-BF0BD2A03EA7}
 		{8C3AF25D-81D9-4651-90CA-BF0BD2A03EA7} = {02EA681E-C7D8-13C7-8484-4AC65E1B71E8}
+		{420C35A7-0EDE-4E2E-8500-484B57B0367A} = {E18417C2-D9F5-437A-9ED5-473DD6260066}
+		{E18417C2-D9F5-437A-9ED5-473DD6260066} = {02EA681E-C7D8-13C7-8484-4AC65E1B71E8}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {8E2C3187-F848-493A-9E79-56D20DDCAC94}