refactor(DigitalData.Core.Infrastructure.AutoMapper): Upgrade 1.0.3

DigitalData.Core.API/BasicCRUDControllerBase.cs

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

DigitalData.Core.API/CRUDControllerBase.cs

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

DigitalData.Core.API/CRUDControllerBaseWithErrorHandling.cs

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

DigitalData.Core.API/ControllerExtensions.cs

@@ -1,4 +1,4 @@
-using DigitalData.Core.Application.Abstraction.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.0</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>
+    <AssemblyVersion>2.2.0</AssemblyVersion>
-    <FileVersion>2.1.1</FileVersion>
+    <FileVersion>2.2.0</FileVersion>
   </PropertyGroup>
 
   <ItemGroup>

DigitalData.Core.API/ReadControllerBase.cs

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

DigitalData.Core.API/ReadControllerBaseWithErrorHandling.cs

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

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

@@ -0,0 +1,17 @@
+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();
+}

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

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

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

@@ -0,0 +1,34 @@
+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;
+    }
+}

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

@@ -0,0 +1,393 @@
+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;
+}

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

@@ -0,0 +1,28 @@
+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);
+}

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

@@ -0,0 +1,50 @@
+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
+}

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

@@ -0,0 +1,28 @@
+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();
+}

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

@@ -0,0 +1,108 @@
+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.
+}

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

@@ -6,10 +6,10 @@
     <Nullable>enable</Nullable>
     <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.Application.Abstraction</PackageId>
+	  <PackageId>DigitalData.Core.Abstraction.Application</PackageId>
     <Authors>Digital Data GmbH</Authors>
     <Company>Digital Data GmbH</Company>
-    <Product>DigitalData.Core.Application.Abstraction</Product>
+    <Product>DigitalData.Core.Abstraction.Application</Product>
     <Copyright>Copyright 2025</Copyright>
     <PackageIcon>core_icon.png</PackageIcon>
     <RepositoryUrl>http://git.dd:3000/AppStd/WebCoreModules.git</RepositoryUrl>

DigitalData.Core.Abstraction.Application/EntityExtensions.cs

@@ -1,4 +1,4 @@
-namespace DigitalData.Core.Application.Abstraction;
+namespace DigitalData.Core.Abstraction.Application;
 
 /// <summary>
 /// Provides extension methods for retrieving the value of an 'Id' property from objects.

DigitalData.Core.Abstraction.Application/IBasicCRUDService.cs

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

DigitalData.Core.Abstraction.Application/ICRUDService.cs

@@ -1,6 +1,6 @@
-using DigitalData.Core.Application.Abstraction.DTO;
+using DigitalData.Core.Abstraction.Application.DTO;
 
-namespace DigitalData.Core.Application.Abstraction
+namespace DigitalData.Core.Abstraction.Application
 {
     [Obsolete("Use MediatR")]
     public interface ICRUDService<TCreateDto, TReadDto, TEntity, TId> : IReadService<TReadDto, TEntity, TId>

DigitalData.Core.Abstraction.Application/IDirectorySearchService.cs

@@ -1,7 +1,7 @@
-using DigitalData.Core.Application.Abstraction.DTO;
+using DigitalData.Core.Abstraction.Application.DTO;
 using System.DirectoryServices;
 
-namespace DigitalData.Core.Application.Abstraction
+namespace DigitalData.Core.Abstraction.Application
 {
     public interface IDirectorySearchService
     {

DigitalData.Core.Abstraction.Application/IJWTService.cs

@@ -2,7 +2,7 @@
 using System.IdentityModel.Tokens.Jwt;
 using System.Security.Cryptography;
 
-namespace DigitalData.Core.Application.Abstraction
+namespace DigitalData.Core.Abstraction.Application
 {
     /// <summary>
     /// Defines the operations for JWT service handling claims of type <typeparamref name="TClaimValue"/>.

DigitalData.Core.Abstraction.Application/IReadService.cs

@@ -1,6 +1,6 @@
-using DigitalData.Core.Application.Abstraction.DTO;
+using DigitalData.Core.Abstraction.Application.DTO;
 
-namespace DigitalData.Core.Application.Abstraction
+namespace DigitalData.Core.Abstraction.Application
 {
     [Obsolete("Use MediatR")]
     public interface IReadService<TReadDto, TEntity, TId>

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

@@ -1,6 +1,6 @@
 using System.Linq.Expressions;
 
-namespace DigitalData.Core.Application.Abstraction.Repository;
+namespace DigitalData.Core.Abstraction.Application.Repository;
 
 public static class Extensions
 {

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

@@ -1,4 +1,4 @@
-namespace DigitalData.Core.Application.Abstraction.Repository
+namespace DigitalData.Core.Abstraction.Application.Repository
 {
     /// <summary>
     /// Defines the contract for CRUD operations on a repository for entities of type TEntity.

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

@@ -1,4 +1,4 @@
-namespace DigitalData.Core.Application.Abstraction.Repository
+namespace DigitalData.Core.Abstraction.Application.Repository
 {
     /// <summary>
     /// Defines methods for mapping between entities and Data Transfer Objects (DTOs).

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

@@ -1,6 +1,6 @@
 using System.Linq.Expressions;
 
-namespace DigitalData.Core.Application.Abstraction.Repository;
+namespace DigitalData.Core.Abstraction.Application.Repository;
 
 /// <summary>
 /// Provides methods for executing common queries on a given entity type.

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

@@ -1,6 +1,6 @@
 using System.Linq.Expressions;
 
-namespace DigitalData.Core.Application.Abstraction.Repository;
+namespace DigitalData.Core.Abstraction.Application.Repository;
 
 public interface IRepository<TEntity>
 {

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

@@ -1,6 +1,6 @@
 using System.Linq.Expressions;
 
-namespace DigitalData.Core.Application.Abstraction.Repository;
+namespace DigitalData.Core.Abstraction.Application.Repository;
 
 public static class RepositoryExtensions
 {

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/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/BasicCRUDService.cs

@@ -1,6 +1,6 @@
 using AutoMapper;
-using DigitalData.Core.Application.Abstraction;
+using DigitalData.Core.Abstraction.Application;
-using DigitalData.Core.Application.Abstraction.Repository;
+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.Abstraction.Application.DTO;
-using DigitalData.Core.Application.Abstraction.Repository;
+using DigitalData.Core.Abstraction.Application.Repository;
-using DigitalData.Core.Application.Abstraction;
+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.2</Version>
+    <Version>3.3.4</Version>
-    <AssemblyVersion>3.3.2</AssemblyVersion>
+    <AssemblyVersion>3.3.4</AssemblyVersion>
-    <FileVersion>3.3.2</FileVersion>
+    <FileVersion>3.3.4</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.Abstraction.Application.DTO;
-using DigitalData.Core.Application.Abstraction;
+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.Abstraction.Application;
-using DigitalData.Core.Application.Abstraction.DTO;
+using DigitalData.Core.Abstraction.Application.DTO;
-using DigitalData.Core.Application.Abstraction.Repository;
+using DigitalData.Core.Abstraction.Application.Repository;
 
 namespace DigitalData.Core.Application;
 

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>
+	<Version>1.0.3</Version>
-    <FileVersion>1.0.2</FileVersion>
+    <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,5 @@
-using DigitalData.Core.Application.Abstraction;
+using DigitalData.Core.Abstraction.Application;
-using DigitalData.Core.Application.Abstraction.Repository;
+using DigitalData.Core.Abstraction.Application.Repository;
 using Microsoft.EntityFrameworkCore;
 
 namespace DigitalData.Core.Infrastructure

DigitalData.Core.Infrastructure/DbRepository.cs

@@ -1,4 +1,4 @@
-using DigitalData.Core.Application.Abstraction.Repository;
+using DigitalData.Core.Abstraction.Application.Repository;
 using Microsoft.EntityFrameworkCore;
 using System.Linq.Expressions;
 

DigitalData.Core.Infrastructure/DependencyInjection.cs

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

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

@@ -15,9 +15,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>
+    <Version>2.1.1</Version>
-    <AssemblyVersion>2.1.0</AssemblyVersion>
+    <AssemblyVersion>2.1.1</AssemblyVersion>
-    <FileVersion>2.1.0</FileVersion>
+    <FileVersion>2.1.1</FileVersion>
   </PropertyGroup>
 
   <ItemGroup>
@@ -40,7 +40,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>
 
   <ItemGroup>

DigitalData.Core.Infrastructure/EntityConfigurationOptions.cs

@@ -1,4 +1,4 @@
-using DigitalData.Core.Application.Abstraction.Repository;
+using DigitalData.Core.Abstraction.Application.Repository;
 using Microsoft.Extensions.DependencyInjection;
 
 namespace DigitalData.Core.Infrastructure;

DigitalData.Core.Infrastructure/ReadQuery.cs

@@ -1,4 +1,4 @@
-using DigitalData.Core.Application.Abstraction.Repository;
+using DigitalData.Core.Abstraction.Application.Repository;
 using Microsoft.EntityFrameworkCore;
 using System.Linq.Expressions;
 

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