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.Abstraction;
+#if NET
+namespace DigitalData.Core.Abstraction.Application;
 
 /// <summary>
 /// Provides extension methods for retrieving the value of an 'Id' property from objects.
@@ -92,3 +93,4 @@ public static class EntityExtensions
         return id is not null;
     }
 }
+#endif

DigitalData.Core.Abstraction.Application/IBasicCRUDService.cs

@@ -1,4 +1,5 @@
-namespace DigitalData.Core.Application.Abstraction
+#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,
@@ -19,3 +20,4 @@
     {
     }
 }
+#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.Abstraction.Repository
+#if NET
+namespace DigitalData.Core.Abstraction.Application.Repository
 {
     /// <summary>
     /// Defines the contract for CRUD operations on a repository for entities of type TEntity.
@@ -61,3 +62,4 @@
         Task<int> CountAsync(TId id);
     }
 }
+#endif

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

@@ -1,4 +1,7 @@
-namespace DigitalData.Core.Application.Abstraction.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.Abstraction/DTO/BaseDto.cs

@@ -1,17 +0,0 @@
-namespace DigitalData.Core.Application.Abstraction.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.Abstraction/DTO/CookieConsentSettings.cs

@@ -1,74 +0,0 @@
-namespace DigitalData.Core.Application.Abstraction.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.Abstraction/DTO/DIExtensions.cs

@@ -1,33 +0,0 @@
-using Microsoft.Extensions.Configuration;
-using Microsoft.Extensions.DependencyInjection;
-using System.Configuration;
-
-namespace DigitalData.Core.Application.Abstraction.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.Abstraction/DTO/DTOExtensions.cs

@@ -1,367 +0,0 @@
-using Microsoft.Extensions.Logging;
-using System.Text;
-
-namespace DigitalData.Core.Application.Abstraction.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.Abstraction/DTO/DataResult.cs

@@ -1,26 +0,0 @@
-using System.Text.Json.Serialization;
-
-namespace DigitalData.Core.Application.Abstraction.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.Abstraction/DTO/Flag.cs

@@ -1,50 +0,0 @@
-namespace DigitalData.Core.Application.Abstraction.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.Abstraction/DTO/Notice.cs

@@ -1,25 +0,0 @@
-using Microsoft.Extensions.Logging;
-
-namespace DigitalData.Core.Application.Abstraction.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.Abstraction/DTO/Result.cs

@@ -1,97 +0,0 @@
-using System.Text.Json.Serialization;
-
-namespace DigitalData.Core.Application.Abstraction.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.Abstraction/DigitalData.Core.Application.Abstraction.csproj

@@ -1,37 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <TargetFrameworks>net7.0;net8.0;net9.0</TargetFrameworks>
-    <ImplicitUsings>enable</ImplicitUsings>
-    <Nullable>enable</Nullable>
-  </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)' == '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" />
-  </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" />
-  </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" />
-  </ItemGroup>
-	
-</Project>

DigitalData.Core.Application.Abstraction/ICRUDService.cs

@@ -1,25 +0,0 @@
-using DigitalData.Core.Application.Abstraction.DTO;
-
-namespace DigitalData.Core.Application.Abstraction
-{
-    [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);
-    }
-}

DigitalData.Core.Application.Abstraction/IDirectorySearchService.cs

@@ -1,94 +0,0 @@
-using DigitalData.Core.Application.Abstraction.DTO;
-using System.DirectoryServices;
-
-namespace DigitalData.Core.Application.Abstraction
-{
-    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.Abstraction/IJWTService.cs

@@ -1,41 +0,0 @@
-using Microsoft.IdentityModel.Tokens;
-using System.IdentityModel.Tokens.Jwt;
-using System.Security.Cryptography;
-
-namespace DigitalData.Core.Application.Abstraction
-{
-    /// <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.Abstraction/IReadService.cs

@@ -1,39 +0,0 @@
-using DigitalData.Core.Application.Abstraction.DTO;
-
-namespace DigitalData.Core.Application.Abstraction
-{
-    [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.Abstraction/Repository/Extensions.cs

@@ -1,34 +0,0 @@
-using System.Linq.Expressions;
-
-namespace DigitalData.Core.Application.Abstraction.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.Abstraction/Repository/IReadQuery.cs

@@ -1,85 +0,0 @@
-using System.Linq.Expressions;
-
-namespace DigitalData.Core.Application.Abstraction.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.Abstraction/Repository/IRepository.cs

@@ -1,32 +0,0 @@
-using System.Linq.Expressions;
-
-namespace DigitalData.Core.Application.Abstraction.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.Abstraction/Repository/RepositoryExtensions.cs

@@ -1,14 +0,0 @@
-using System.Linq.Expressions;
-
-namespace DigitalData.Core.Application.Abstraction.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/BasicCRUDService.cs

@@ -1,6 +1,6 @@
 using AutoMapper;
-using DigitalData.Core.Application.Abstraction;
-using DigitalData.Core.Application.Abstraction.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.Abstraction.DTO;
-using DigitalData.Core.Application.Abstraction.Repository;
-using DigitalData.Core.Application.Abstraction;
+using DigitalData.Core.Abstraction.Application.DTO;
+using DigitalData.Core.Abstraction.Application.Repository;
+using DigitalData.Core.Abstraction.Application;
 
 namespace DigitalData.Core.Application
 {

DigitalData.Core.Application/DIExtensions.cs

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

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.1</Version>
-    <AssemblyVersion>3.3.1</AssemblyVersion>
-    <FileVersion>3.3.1</FileVersion>
+    <Version>3.4.0</Version>
+    <AssemblyVersion>3.4.0</AssemblyVersion>
+    <FileVersion>3.4.0</FileVersion>
   </PropertyGroup>
 
   <ItemGroup>
@@ -55,7 +55,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <ProjectReference Include="..\DigitalData.Core.Application.Abstraction\DigitalData.Core.Application.Abstraction.csproj" />
+    <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.Abstraction.DTO;
-using DigitalData.Core.Application.Abstraction;
+using DigitalData.Core.Abstraction.Application.DTO;
+using DigitalData.Core.Abstraction.Application;
 
 namespace DigitalData.Core.Application
 {

DigitalData.Core.Application/JWTService.cs

@@ -1,4 +1,4 @@
-using DigitalData.Core.Application.Abstraction;
+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.Abstraction;
-using DigitalData.Core.Application.Abstraction.DTO;
-using DigitalData.Core.Application.Abstraction.Repository;
+using DigitalData.Core.Abstraction.Application;
+using DigitalData.Core.Abstraction.Application.DTO;
+using DigitalData.Core.Abstraction.Application.Repository;
 
 namespace DigitalData.Core.Application;
 

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,5 +1,6 @@
-using DigitalData.Core.Application.Abstraction;
-using DigitalData.Core.Application.Abstraction.Repository;
+#if NET
+using DigitalData.Core.Abstraction.Application;
+using DigitalData.Core.Abstraction.Application.Repository;
 using Microsoft.EntityFrameworkCore;
 
 namespace DigitalData.Core.Infrastructure
@@ -111,3 +112,4 @@ namespace DigitalData.Core.Infrastructure
         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.Abstraction.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.Abstraction.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,20 +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.5" />
+	<PackageReference Include="Microsoft.EntityFrameworkCore.Relational" Version="9.0.5" />
   </ItemGroup>
 
   <ItemGroup>
-    <ProjectReference Include="..\DigitalData.Core.Application.Abstraction\DigitalData.Core.Application.Abstraction.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.Abstraction.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.Abstraction.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>

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; }
 

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,7 +51,7 @@ 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.Application.Abstraction", "DigitalData.Core.Application.Abstraction\DigitalData.Core.Application.Abstraction.csproj", "{420C35A7-0EDE-4E2E-8500-484B57B0367A}"
+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
@@ -124,8 +124,8 @@ 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 = Debug|Any CPU
-		{420C35A7-0EDE-4E2E-8500-484B57B0367A}.Debug|Any CPU.Build.0 = Debug|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