Refactor namespaces and enhance application structure

This commit reorganizes namespaces from `DigitalData.Core.Abstractions` and `DigitalData.Core.DTO` to `DigitalData.Core.Application.Interfaces` and `DigitalData.Core.Application.DTO`, improving maintainability and clarity.

Updated using directives across multiple files to reflect the new structure, ensuring functionality remains intact.

Project references in `DigitalData.Core.API.csproj` have been consolidated to include the new Application project.

Introduced new classes and interfaces such as `BaseDTO`, `CookieConsentSettings`, `DataResult`, `Notice`, and `Result` to enhance data transfer and service result handling.

Updated `IRepository`, `ICRUDRepository`, and `IEntityMapper` interfaces to facilitate CRUD operations and entity mapping.

Added extension methods in `Extensions.cs` to improve repository usability.

New interfaces for HTTP client services have been added, enhancing external API call handling.

Overall, these changes reflect a significant restructuring aimed at improving organization and preparing for future development.

DigitalData.Core.API/BasicCRUDControllerBase.cs

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

DigitalData.Core.API/CRUDControllerBase.cs

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

DigitalData.Core.API/CRUDControllerBaseWithErrorHandling.cs

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

DigitalData.Core.API/ControllerExtensions.cs

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

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

@@ -32,8 +32,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <ProjectReference Include="..\DigitalData.Core.Abstractions\DigitalData.Core.Abstractions.csproj" />
-    <ProjectReference Include="..\DigitalData.Core.DTO\DigitalData.Core.DTO.csproj" />
+    <ProjectReference Include="..\DigitalData.Core.Application\DigitalData.Core.Application.csproj" />
   </ItemGroup>
 
   <ItemGroup>

DigitalData.Core.API/ReadControllerBase.cs

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

DigitalData.Core.API/ReadControllerBaseWithErrorHandling.cs

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

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

@@ -37,8 +37,4 @@
 		<PackageReference Include="System.IdentityModel.Tokens.Jwt" Version="7.5.1" />
 	</ItemGroup>
 
-	<ItemGroup>
-	  <ProjectReference Include="..\DigitalData.Core.DTO\DigitalData.Core.DTO.csproj" />
-	</ItemGroup>
-
 </Project>

DigitalData.Core.Application/BasicCRUDService.cs

@@ -1,7 +1,7 @@
 using AutoMapper;
 using DigitalData.Core.Abstractions;
-using DigitalData.Core.Abstractions.Application;
-using DigitalData.Core.Abstractions.Infrastructure;
+using DigitalData.Core.Application.Interfaces;
+using DigitalData.Core.Application.Interfaces.Repository;
 
 namespace DigitalData.Core.Application
 {

DigitalData.Core.Application/CRUDService.cs

@@ -1,9 +1,9 @@
-using DigitalData.Core.Abstractions.Application;
-using DigitalData.Core.Abstractions.Infrastructure;
-using AutoMapper;
-using DigitalData.Core.DTO;
+using AutoMapper;
 using DigitalData.Core.Abstractions;
 using Microsoft.Extensions.Logging;
+using DigitalData.Core.Application.Interfaces.Repository;
+using DigitalData.Core.Application.Interfaces;
+using DigitalData.Core.Application.DTO;
 
 namespace DigitalData.Core.Application
 {

DigitalData.Core.Application/DIExtensions.cs

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

DigitalData.Core.Application/DTO/BaseDto.cs

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

DigitalData.Core.Application/DTO/CookieConsentSettings.cs

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

DigitalData.Core.Application/DTO/DIExtensions.cs

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

DigitalData.Core.Application/DTO/DTOExtensions.cs

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

DigitalData.Core.Application/DTO/DataResult.cs

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

DigitalData.Core.Application/DTO/Flag.cs

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

DigitalData.Core.Application/DTO/Notice.cs

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

DigitalData.Core.Application/DTO/Result.cs

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

DigitalData.Core.Application/DirectorySearchService.cs

@@ -1,10 +1,10 @@
-using DigitalData.Core.Abstractions.Application;
-using System.Diagnostics.CodeAnalysis;
+using System.Diagnostics.CodeAnalysis;
 using System.DirectoryServices;
 using Microsoft.Extensions.Caching.Memory;
 using System.DirectoryServices.AccountManagement;
-using DigitalData.Core.DTO;
 using Microsoft.Extensions.Options;
+using DigitalData.Core.Application.Interfaces;
+using DigitalData.Core.Application.DTO;
 
 namespace DigitalData.Core.Application
 {

DigitalData.Core.Application/Interfaces/IBasicCRUDService.cs

@@ -1,6 +1,6 @@
-using DigitalData.Core.Abstractions.Infrastructure;
+using DigitalData.Core.Abstractions;
 
-namespace DigitalData.Core.Abstractions.Application
+namespace DigitalData.Core.Application.Interfaces
 {
     /// <summary>
     /// Implements a simplified CRUD service interface that uses a single Data Transfer Object (DTO) type for all CRUD operations,

DigitalData.Core.Application/Interfaces/ICRUDService.cs

@@ -1,6 +1,7 @@
-using DigitalData.Core.DTO;
+using DigitalData.Core.Abstractions;
+using DigitalData.Core.Application.DTO;
 
-namespace DigitalData.Core.Abstractions.Application
+namespace DigitalData.Core.Application.Interfaces
 {
     public interface ICRUDService<TCreateDto, TReadDto, TEntity, TId> : IReadService<TReadDto, TEntity, TId>
         where TCreateDto : class where TReadDto : class where TEntity : class, IUnique<TId>

DigitalData.Core.Application/Interfaces/IDirectorySearchService.cs

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

DigitalData.Core.Application/Interfaces/IJWTService.cs

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

DigitalData.Core.Application/Interfaces/IReadService.cs

@@ -1,6 +1,6 @@
-using DigitalData.Core.DTO;
+using DigitalData.Core.Application.DTO;
 
-namespace DigitalData.Core.Abstractions.Application
+namespace DigitalData.Core.Application.Interfaces
 {
     public interface IReadService<TReadDto, TEntity, TId>
         where TReadDto : class where TEntity : class

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

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

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

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

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

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

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

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

DigitalData.Core.Application/JWTService.cs

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

DigitalData.Core.Application/ReadService.cs

@@ -1,8 +1,8 @@
-using DigitalData.Core.Abstractions.Application;
-using DigitalData.Core.Abstractions.Infrastructure;
-using AutoMapper;
-using DigitalData.Core.DTO;
+using AutoMapper;
 using DigitalData.Core.Abstractions;
+using DigitalData.Core.Application.DTO;
+using DigitalData.Core.Application.Interfaces;
+using DigitalData.Core.Application.Interfaces.Repository;
 
 namespace DigitalData.Core.Application
 {

DigitalData.Core.Client/BaseHttpClientService.cs

@@ -1,4 +1,4 @@
-using DigitalData.Core.Abstractions.Client;
+using DigitalData.Core.Client.Interface;
 using System.Diagnostics.CodeAnalysis;
 using System.Net;
 using System.Web;

DigitalData.Core.Client/DIExtensions.cs

@@ -1,4 +1,4 @@
-using DigitalData.Core.Abstractions.Client;
+using DigitalData.Core.Client.Interface;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.DependencyInjection.Extensions;

DigitalData.Core.Client/HttpClientService.cs

@@ -1,4 +1,4 @@
-using DigitalData.Core.Abstractions.Client;
+using DigitalData.Core.Client.Interface;
 using Microsoft.Extensions.Options;
 using System.Net;
 

DigitalData.Core.Client/Interface/IBaseHttpClientService.cs

@@ -1,6 +1,6 @@
 using System.Net;
 
-namespace DigitalData.Core.Abstractions.Client
+namespace DigitalData.Core.Client.Interface
 {
     public interface IBaseHttpClientService
     {

DigitalData.Core.Client/Interface/IHttpClientOptions.cs

@@ -1,4 +1,4 @@
-namespace DigitalData.Core.Abstractions.Client
+namespace DigitalData.Core.Client.Interface
 {
     public interface IHttpClientOptions
     {

DigitalData.Core.Client/Interface/IHttpClientService.cs

@@ -1,4 +1,4 @@
-namespace DigitalData.Core.Abstractions.Client
+namespace DigitalData.Core.Client.Interface
 {
     public interface IHttpClientService<TClientOptions> : IBaseHttpClientService where TClientOptions : IHttpClientOptions
     {

DigitalData.Core.Client/ServiceFactory.cs

@@ -1,4 +1,4 @@
-using DigitalData.Core.Abstractions.Client;
+using DigitalData.Core.Client.Interface;
 using Microsoft.Extensions.DependencyInjection;
 
 namespace DigitalData.Core.Client

DigitalData.Core.Infrastructure.AutoMapper/EntityAutoMapper.cs

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

DigitalData.Core.Infrastructure/CRUDRepository.cs

@@ -1,5 +1,5 @@
 using DigitalData.Core.Abstractions;
-using DigitalData.Core.Abstractions.Infrastructure;
+using DigitalData.Core.Application.Interfaces.Repository;
 using Microsoft.EntityFrameworkCore;
 
 namespace DigitalData.Core.Infrastructure

DigitalData.Core.Infrastructure/DbRepository.cs

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

DigitalData.Core.Infrastructure/DependencyInjection.cs

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

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

@@ -41,6 +41,7 @@
 
   <ItemGroup>
     <ProjectReference Include="..\DigitalData.Core.Abstractions\DigitalData.Core.Abstractions.csproj" />
+    <ProjectReference Include="..\DigitalData.Core.Application\DigitalData.Core.Application.csproj" />
   </ItemGroup>
 
   <ItemGroup>

DigitalData.Core.Infrastructure/EntityConfigurationOptions.cs

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

DigitalData.Core.Tests/Client/BaseHttpClientServiceTest.cs

@@ -1,5 +1,5 @@
-using DigitalData.Core.Abstractions.Client;
-using DigitalData.Core.Client;
+using DigitalData.Core.Client;
+using DigitalData.Core.Client.Interface;
 using Microsoft.Extensions.DependencyInjection;
 
 namespace DigitalData.Core.Tests.Client

DigitalData.Core.Tests/Infrastructure/DbRepositoryTests.cs

@@ -6,8 +6,8 @@ using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 using System.Reflection;
-using DigitalData.Core.Abstractions.Infrastructure;
 using DigitalData.Core.Infrastructure.AutoMapper;
+using DigitalData.Core.Application.Interfaces.Repository;
 
 public class DbRepositoryTests
 {