feat(RSADecryptor): FileNotFoundEvent-Methode aktualisiert, um Datei zu erstellen, wenn nicht gefunden

- Kombiniert `Encryptors` und `Decryptors` in `cryptographers` für eine vereinfachte Initialisierung in `OnDeserialized`.

.gitignore

@@ -391,3 +391,22 @@ FodyWeavers.xsd
 /DigitalData.Core.Contracts/obj/Debug/net7.0/DigitalData.Core.Contracts.csproj.FileListAbsolute.txt
 /DigitalData.Core.Contracts/obj/DigitalData.Core.Contracts.csproj.nuget.dgspec.json
 /DigitalData.Core.Contracts/obj/project.assets.json
+/.vs/DigitalData.Core/v17/TestStore/0/000.testlog
+/DigitalData.Core.Tests/obj/Debug/net7.0/DigitalData.Core.Tests.assets.cache
+/DigitalData.Core.Tests/obj/DigitalData.Core.Tests.csproj.nuget.dgspec.json
+/DigitalData.Core.Tests/obj/DigitalData.Core.Tests.csproj.nuget.g.targets
+/DigitalData.Core.Tests/obj/project.assets.json
+/.vs/DigitalData.Core/v17/TestStore/0/000.testlog
+/DigitalData.Core.Tests/obj/Debug/net7.0/DigitalData.Core.Tests.assets.cache
+/DigitalData.Core.Tests/obj/DigitalData.Core.Tests.csproj.nuget.dgspec.json
+/DigitalData.Core.Tests/obj/DigitalData.Core.Tests.csproj.nuget.g.targets
+/DigitalData.Core.Tests/obj/project.assets.json
+/.vs/DigitalData.Core/v17/TestStore/0/testlog.manifest
+/DigitalData.Core.Infrastructure/obj
+/DigitalData.Core.Application/obj/Release/net7.0/DigitalData.Core.Application.AssemblyInfo.cs
+/DigitalData.Core.Application/obj/Release/net7.0/ref/DigitalData.Core.Application.dll
+/DigitalData.Core.ConsoleApp/DigitalData.Core.ConsoleApp.csproj
+/DigitalData.Core.ConsoleApp/Program.cs
+/DigitalData.Core.ConsoleApp/FooHttpOptions.cs
+/DigitalData.Core.Tests/obj/
+/DigitalData.Core.Terminal

DigitalData.Core.API/BasicCRUDControllerBase.cs

@@ -1,16 +1,15 @@
-using DigitalData.Core.Contracts.Application;
-using DigitalData.Core.Contracts.Infrastructure;
+using DigitalData.Core.Abstractions;
+using DigitalData.Core.Abstractions.Application;
 using Microsoft.AspNetCore.Mvc;
 
 namespace DigitalData.Core.API
 {
     [ApiController]
     [Route("api/[controller]")]
-    public class BasicCRUDControllerBase<TCRUDService, TCRUDRepository, TDto, TEntity, TId> : CRUDControllerBase<TCRUDService, TCRUDRepository, TDto, TDto, TDto, TEntity, TId>
-        where TCRUDService : ICRUDService<TCRUDRepository, TDto, TDto, TDto, TEntity, TId>
-        where TCRUDRepository : ICRUDRepository<TEntity, TId>
-        where TDto : class
-        where TEntity : class
+    public class BasicCRUDControllerBase<TCRUDService, TDto, TEntity, TId> : CRUDControllerBase<TCRUDService, TDto, TDto, TDto, TEntity, TId>
+        where TCRUDService : ICRUDService<TDto, TDto, TDto, TEntity, TId>
+        where TDto : class, IUnique<TId>
+        where TEntity : class, IUnique<TId>
     {
         public BasicCRUDControllerBase(ILogger logger, TCRUDService service) : base(logger, service)
         {

DigitalData.Core.API/CRUDControllerBase.cs

@@ -1,5 +1,5 @@
-using DigitalData.Core.Contracts.Application;
-using DigitalData.Core.Contracts.Infrastructure;
+using DigitalData.Core.Abstractions;
+using DigitalData.Core.Abstractions.Application;
 using DigitalData.Core.DTO;
 using Microsoft.AspNetCore.Mvc;
 
@@ -16,13 +16,12 @@ namespace DigitalData.Core.API
     /// <typeparam name="TId">The type of the entity's identifier.</typeparam>
     [ApiController]
     [Route("api/[controller]")]
-    public class CRUDControllerBase<TCRUDService, TCRUDRepository, TCreateDto, TReadDto, TUpdateDto, TEntity, TId> : ControllerBase
-        where TCRUDService : ICRUDService<TCRUDRepository, TCreateDto, TReadDto, TUpdateDto, TEntity, TId>
-        where TCRUDRepository : ICRUDRepository<TEntity, TId>
+    public class CRUDControllerBase<TCRUDService, TCreateDto, TReadDto, TUpdateDto, TEntity, TId> : ControllerBase
+        where TCRUDService : ICRUDService<TCreateDto, TReadDto, TUpdateDto, TEntity, TId>
         where TCreateDto : class
         where TReadDto : class
-        where TUpdateDto : class
-        where TEntity : class
+        where TUpdateDto : class, IUnique<TId>
+        where TEntity : class, IUnique<TId>
     {
         protected readonly ILogger _logger;
         protected readonly TCRUDService _service;

DigitalData.Core.API/CRUDControllerBaseWithErrorHandling.cs

@@ -0,0 +1,173 @@
+using DigitalData.Core.Abstractions;
+using DigitalData.Core.Abstractions.Application;
+using DigitalData.Core.DTO;
+using Microsoft.AspNetCore.Mvc;
+
+namespace DigitalData.Core.API
+{
+    /// <summary>
+    /// A base controller class that provides generic CRUD (Create, Read, Update, Delete) operations for a specified entity type,
+    /// with enhanced error handling to ensure robust and reliable API endpoints.
+    /// </summary>
+    /// <typeparam name="TCRUDService">The derived CRUD service type implementing ICRUDService<TCreateDto, TReadDto, TUpdateDto, TEntity, TId>.</typeparam>
+    /// <typeparam name="TCreateDto">The Data Transfer Object type for create operations.</typeparam>
+    /// <typeparam name="TReadDto">The Data Transfer Object type for read operations.</typeparam>
+    /// <typeparam name="TUpdateDto">The Data Transfer Object type for update operations.</typeparam>
+    /// <typeparam name="TEntity">The entity type CRUD operations will be performed on.</typeparam>
+    /// <typeparam name="TId">The type of the entity's identifier.</typeparam>
+    [ApiController]
+    [Route("api/[controller]")]
+    public class CRUDControllerBaseWithErrorHandling<TCRUDService, TCreateDto, TReadDto, TUpdateDto, TEntity, TId> : ControllerBase
+        where TCRUDService : ICRUDService<TCreateDto, TReadDto, TUpdateDto, TEntity, TId>
+        where TCreateDto : class
+        where TReadDto : class
+        where TUpdateDto : class, IUnique<TId>
+        where TEntity : class, IUnique<TId>
+    {
+        protected readonly ILogger _logger;
+        protected readonly TCRUDService _service;
+
+        /// <summary>
+        /// Initializes a new instance of the CRUDControllerBase class with specified logger and CRUD service.
+        /// </summary>
+        /// <param name="logger">The logger to be used by the controller.</param>
+        /// <param name="service">The CRUD service handling business logic for the entity.</param>
+        public CRUDControllerBaseWithErrorHandling(
+            ILogger logger,
+            TCRUDService service)
+        {
+            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
+            _service = service ?? throw new ArgumentNullException(nameof(service));
+        }
+
+        /// <summary>
+        /// Creates a new entity based on the provided DTO.
+        /// </summary>
+        /// <param name="createDto">The DTO from which to create the entity.</param>
+        /// <returns>A task that represents the asynchronous create operation. The task result contains the action result.</returns>
+        [HttpPost]
+        public virtual async Task<IActionResult> Create(TCreateDto createDto)
+        {
+            try
+            {
+                return await _service.CreateAsync(createDto).ThenAsync<TId, IActionResult>(
+                                Success: id =>
+                                {
+                                    var createdResource = new { Id = id };
+                                    var actionName = nameof(GetById);
+                                    var routeValues = new { id = createdResource.Id };
+                                    return CreatedAtAction(actionName, routeValues, createdResource);
+                                },
+                                Fail: (messages, notices) =>
+                                {
+                                    _logger.LogNotice(notices);
+                                    return BadRequest(messages);
+                                });
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "{Message}", ex.Message);
+                return StatusCode(StatusCodes.Status500InternalServerError);
+            }
+        }
+
+        /// <summary>
+        /// Retrieves an entity by its identifier.
+        /// </summary>
+        /// <param name="id">The identifier of the entity to retrieve.</param>
+        /// <returns>A task that represents the asynchronous read operation. The task result contains the action result.</returns>
+        [HttpGet("{id}")]
+        public virtual async Task<IActionResult> GetById([FromRoute] TId id)
+        {
+            try
+            {
+                return await _service.ReadByIdAsync(id).ThenAsync(
+                    Success: Ok,
+                    Fail: IActionResult (messages, notices) =>
+                    {
+                        _logger.LogNotice(notices);
+                        return NotFound(messages);
+                    });
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "{Message}", ex.Message);
+                return StatusCode(StatusCodes.Status500InternalServerError);
+            }
+        }
+
+        /// <summary>
+        /// Retrieves all entities.
+        /// </summary>
+        /// <returns>A task that represents the asynchronous read-all operation. The task result contains the action result.</returns>
+        [HttpGet]
+        public virtual async Task<IActionResult> GetAll()
+        {
+            try
+            {
+                return await _service.ReadAllAsync().ThenAsync(
+                    Success: Ok,
+                    Fail: IActionResult (messages, notices) =>
+                    {
+                        _logger.LogNotice(notices);
+                        return NotFound(messages);
+                    });
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "{Message}", ex.Message);
+                return StatusCode(StatusCodes.Status500InternalServerError);
+            }
+        }
+
+        /// <summary>
+        /// Updates an existing entity based on the provided DTO.
+        /// </summary>
+        /// <param name="updateDto">The DTO containing the updated data for the entity.</param>
+        /// <returns>A task that represents the asynchronous update operation. The task result contains the action result.</returns>
+        [HttpPut]
+        public virtual async Task<IActionResult> Update(TUpdateDto updateDto)
+        {
+            try
+            {
+                return await _service.UpdateAsync(updateDto).ThenAsync(
+                                Success: Ok,
+                                Fail: IActionResult (messages, notices) =>
+                                {
+                                    _logger.LogNotice(notices);
+                                    return BadRequest(messages);
+                                });
+            }
+            catch(Exception ex)
+            {
+                _logger.LogError(ex, "{Message}", ex.Message);
+                return StatusCode(StatusCodes.Status500InternalServerError);
+            }
+        }
+
+        /// <summary>
+        /// Deletes an entity by its identifier.
+        /// </summary>
+        /// <param name="id">The identifier of the entity to delete.</param>
+        /// <returns>A task that represents the asynchronous delete operation. The task result contains the action result.</returns>
+        [HttpDelete("{id}")]
+        public virtual async Task<IActionResult> Delete([FromRoute] TId id)
+        {
+            try
+            {
+                return await _service.DeleteAsyncById(id).ThenAsync(
+                                Success: Ok,
+                                Fail: IActionResult (messages, notices) =>
+                                {
+                                    _logger.LogNotice(notices);
+                                    return BadRequest(messages);
+                                });
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "{Message}", ex.Message);
+                return StatusCode(StatusCodes.Status500InternalServerError);
+            }
+        }
+    }
+}

DigitalData.Core.API/CSPMiddleware.cs

@@ -0,0 +1,47 @@
+namespace DigitalData.Core.API
+{
+    /// <summary>
+    /// Middleware to add Content Security Policy (CSP) headers to the HTTP response.
+    /// </summary>
+    public class CSPMiddleware
+    {
+        private readonly RequestDelegate _next;
+        private readonly string _policy;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CSPMiddleware"/> class.
+        /// </summary>
+        /// <param name="next">The next middleware in the request pipeline.</param>
+        /// <param name="policy">The CSP policy string with placeholders for nonces.</param>
+        public CSPMiddleware(RequestDelegate next, string policy)
+        {
+            _next = next;
+            _policy = policy;
+        }
+
+        /// <summary>
+        /// Invokes the middleware to add the CSP header to the response.
+        /// </summary>
+        /// <param name="context">The HTTP context.</param>
+        /// <returns>A task that represents the completion of request processing.</returns>
+        public async Task Invoke(HttpContext context)
+        {
+            // Generate a nonce (number used once) for inline scripts and styles
+            var nonce = Convert.ToBase64String(Guid.NewGuid().ToByteArray());
+
+            // Store the nonce in the context items for later use
+            context.Items["csp-nonce"] = nonce;
+
+            // Add the CSP header to the response
+            context.Response.OnStarting(() =>
+            {
+                context.Response.Headers.Add("Content-Security-Policy",
+                    string.Format(_policy, nonce));
+                return Task.CompletedTask;
+            });
+
+            // Call the next middleware in the pipeline
+            await _next(context);
+        }
+    }
+}

DigitalData.Core.API/ControllerExtensions.cs

@@ -1,5 +1,4 @@
-using DigitalData.Core.Contracts.Application;
-using DigitalData.Core.DTO;
+using DigitalData.Core.DTO;
 using Microsoft.AspNetCore.Mvc;
 using System.Text;
 
@@ -34,15 +33,13 @@ namespace DigitalData.Core.API
         /// <param name="message">Optional. A custom error message to include in the response.</param>
         /// /// <param name="messageKey">Optional. A custom error message key to include in the response.</param>
         /// <returns>An ObjectResult representing an internal server error (status code 500).</returns>
-        public static ObjectResult InnerServiceError(this ControllerBase controllerBase, Exception? ex = null, string? message = null, Enum? messageKey = null)
+        public static ObjectResult InnerServiceError(this ControllerBase controllerBase, Exception? ex = null, string? message = null)
         {
             var sb = new StringBuilder();
             if (ex is not null)
                 sb.AppendLine(ex.Message);
             if (message is not null)
                 sb.AppendLine(message);
-            if (messageKey is not null)
-                sb.AppendLine(messageKey.ToString());
 
             return controllerBase.StatusCode(500, sb.Length > 0 ? sb.ToString() : null);
         }

DigitalData.Core.API/DIExtensions.cs

@@ -0,0 +1,69 @@
+using Microsoft.AspNetCore.Builder;
+using System.Configuration;
+
+namespace DigitalData.Core.API
+{
+    /// <summary>
+    /// Provides extension methods for adding middleware to the application's request pipeline.
+    /// </summary>
+    public static class DIExtensions
+    {
+        /// <summary>
+        /// Adds the <see cref="CSPMiddleware"/> to the application's request pipeline to include 
+        /// Content Security Policy (CSP) headers in the HTTP response.
+        /// </summary>
+        /// <param name="app">The application builder.</param>
+        /// <param name="policy">
+        /// The CSP policy string with placeholders. The first format parameter {0} will be replaced 
+        /// by the nonce value.
+        /// </param>
+        /// <returns>The application builder with the CSP middleware added.</returns>
+        public static IApplicationBuilder UseCSPMiddleware(this IApplicationBuilder app, string policy)
+            => app.UseMiddleware<CSPMiddleware>(policy);
+
+        /// <summary>
+        /// Checks if the DiP (Development in Production) mode is enabled for the WebApplicationBuilder.
+        /// </summary>
+        /// <param name="builder">The WebApplicationBuilder instance.</param>
+        /// <returns>True if DiP mode is enabled; otherwise, false.</returns>
+        public static bool IsDiP(this WebApplicationBuilder builder) => builder.Configuration.GetValue<bool>("DiPMode");
+
+        /// <summary>
+        /// Checks if the DiP (Development in Production) mode is enabled for the WebApplication.
+        /// </summary>
+        /// <param name="app">The WebApplication instance.</param>
+        /// <returns>True if DiP mode is enabled; otherwise, false.</returns>
+        public static bool IsDiP(this WebApplication app) => app.Configuration.GetValue<bool>("DiPMode");
+
+        /// <summary>
+        /// Checks if the environment is Development or DiP (Development in Production) mode is enabled for the WebApplicationBuilder.
+        /// </summary>
+        /// <param name="builder">The WebApplicationBuilder instance.</param>
+        /// <returns>True if the environment is Development or DiP mode is enabled; otherwise, false.</returns>
+        public static bool IsDevOrDiP(this WebApplicationBuilder builder) => builder.Environment.IsDevelopment() || builder.IsDiP();
+
+        /// <summary>
+        /// Checks if the environment is Development or DiP (Development in Production) mode is enabled for the WebApplication.
+        /// </summary>
+        /// <param name="app">The WebApplication instance.</param>
+        /// <returns>True if the environment is Development or DiP mode is enabled; otherwise, false.</returns>
+        public static bool IsDevOrDiP(this WebApplication app) => app.Environment.IsDevelopment() || app.IsDiP();
+
+		/// <summary>
+		/// Configures the services with options from the specified section of the appsettings.json file.
+		/// </summary>
+		/// <typeparam name="T">The options class type. Must be a reference type.</typeparam>
+		/// <param name="builder">The WebApplicationBuilder instance.</param>
+		/// <returns>The WebApplicationBuilder instance for chaining.</returns>
+		/// <exception cref="InvalidOperationException">Thrown if the section is not found in the configuration.</exception>
+		public static WebApplicationBuilder ConfigureBySection<T>(this WebApplicationBuilder builder) where T : class
+		{
+			var section = builder.Configuration.GetSection(typeof(T).Name);
+			if (!section.Exists())
+				throw new InvalidOperationException($"Section '{typeof(T).Name}' not found in appsettings.");
+
+			builder.Services.Configure<T>(section);
+			return builder;
+		}
+	}
+}

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

@@ -1,19 +1,45 @@
 <Project Sdk="Microsoft.NET.Sdk.Web">
 
   <PropertyGroup>
-    <TargetFramework>net7.0</TargetFramework>
+    <TargetFrameworks>net7.0;net8.0</TargetFrameworks>
+	<IsPackable>true</IsPackable>
     <Nullable>enable</Nullable>
     <ImplicitUsings>enable</ImplicitUsings>
     <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.0.0.0</Version>
+    <Authors>Digital Data GmbH</Authors>
+    <Company>Digital Data GmbH</Company>
+    <Product>DigitalData.Core.API</Product>
+    <Copyright>Copyright 2024</Copyright>
+    <RepositoryUrl>http://git.dd:3000/AppStd/WebCoreModules.git</RepositoryUrl>
+    <PackageTags>digital data core api</PackageTags>
+    <PackageIcon>core_icon.png</PackageIcon>
   </PropertyGroup>
 
+  <ItemGroup>
+    <None Include="..\..\nuget-package-icons\core_icon.png">
+      <Pack>True</Pack>
+      <PackagePath>\</PackagePath>
+    </None>
+  </ItemGroup>
+
   <ItemGroup>
     <PackageReference Include="Microsoft.Extensions.Logging" Version="7.0.0" />
   </ItemGroup>
 
   <ItemGroup>
-    <ProjectReference Include="..\DigitalData.Core.Contracts\DigitalData.Core.Contracts.csproj" />
+    <ProjectReference Include="..\DigitalData.Core.Abstractions\DigitalData.Core.Abstractions.csproj" />
     <ProjectReference Include="..\DigitalData.Core.DTO\DigitalData.Core.DTO.csproj" />
   </ItemGroup>
 
+  <ItemGroup>
+    <None Update="Assets\icon.png">
+      <PackagePath>\</PackagePath>
+      <Pack>True</Pack>
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
+  </ItemGroup>
+
 </Project>

DigitalData.Core.API/LocalizationExtensions.cs

@@ -1,5 +1,6 @@
 using Microsoft.AspNetCore.Localization;
 using Microsoft.Extensions.Localization;
+using System.Dynamic;
 using System.Globalization;
 
 namespace DigitalData.Core.API
@@ -55,5 +56,27 @@ namespace DigitalData.Core.API
             app.UseRequestLocalization(options);
             return app;
         }
+
+        /// <summary>
+        /// Converts all localized strings to a dictionary.
+        /// </summary>
+        /// <param name="localizer">The <see cref="IStringLocalizer"/> instance containing the localized strings.</param>
+        /// <returns>A dictionary containing all localized strings, where the key is the name of the string and the value is the localized value.</returns>
+        public static Dictionary<string, string> ToDictionary(this IStringLocalizer localizer) => localizer.GetAllStrings().ToDictionary(ls => ls.Name, ls => ls.Value);
+
+        /// <summary>
+        /// Converts the localized strings from an <see cref="IStringLocalizer"/> to a dynamic object.
+        /// </summary>
+        /// <param name="localizer">The string localizer to get localized strings from.</param>
+        /// <returns>A dynamic object containing all localized strings.</returns>
+        public static dynamic ToDynamic(this IStringLocalizer localizer)
+        {
+            var expando = new ExpandoObject() as IDictionary<string, object>;
+            foreach (var localizedString in localizer.GetAllStrings())
+            {
+                expando[localizedString.Name] = localizedString.Value;
+            }
+            return expando;
+        }
     }
-}
+}

DigitalData.Core.API/Properties/launchSettings.json

@@ -1,12 +1,12 @@
-{
-  "profiles": {
-    "DigitalData.Core.API": {
-      "commandName": "Project",
-      "launchBrowser": true,
-      "environmentVariables": {
-        "ASPNETCORE_ENVIRONMENT": "Development"
-      },
-      "applicationUrl": "https://localhost:59445;http://localhost:59446"
-    }
-  }
+{
+  "profiles": {
+    "DigitalData.Core.API": {
+      "commandName": "Project",
+      "launchBrowser": true,
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      },
+      "applicationUrl": "https://localhost:50245;http://localhost:50246"
+    }
+  }
 }

DigitalData.Core.API/ReadControllerBase.cs

@@ -1,5 +1,5 @@
-using DigitalData.Core.Contracts.Application;
-using DigitalData.Core.Contracts.Infrastructure;
+using DigitalData.Core.Abstractions.Application;
+using DigitalData.Core.DTO;
 using Microsoft.AspNetCore.Mvc;
 
 namespace DigitalData.Core.API
@@ -12,14 +12,13 @@ namespace DigitalData.Core.API
     /// <typeparam name="TId">The type of the entity's identifier.</typeparam>
     [ApiController]
     [Route("api/[controller]")]
-    public class ReadControllerBase<TBasicCRUDService, TCRUDRepository, TReadDto, TEntity, TId> : ControllerBase
-        where TBasicCRUDService : IBasicCRUDService<TCRUDRepository, TReadDto, TEntity, TId>
-        where TCRUDRepository : ICRUDRepository<TEntity, TId>
+    public class ReadControllerBase<TReadService, TReadDto, TEntity, TId> : ControllerBase
+        where TReadService : IReadService<TReadDto, TEntity, TId>
         where TReadDto : class
         where TEntity : class
     {
         protected readonly ILogger _logger;
-        protected readonly TBasicCRUDService _service;
+        protected readonly TReadService _service;
 
         /// <summary>
         /// Initializes a new instance of the CRUDControllerBase class with specified logger and CRUD service.
@@ -28,7 +27,7 @@ namespace DigitalData.Core.API
         /// <param name="service">The CRUD service handling business logic for the entity.</param>
         public ReadControllerBase(
             ILogger logger,
-            TBasicCRUDService service)
+            TReadService service)
         {
             _logger = logger;
             _service = service;
@@ -42,12 +41,13 @@ namespace DigitalData.Core.API
         [HttpGet("{id}")]
         public virtual async Task<IActionResult> GetById([FromRoute] TId id)
         {
-            var result = await _service.ReadByIdAsync(id);
-            if (result.IsSuccess)
-            {
-                return Ok(result);
-            }
-            return NotFound(result);
+            return await _service.ReadByIdAsync(id).ThenAsync(
+                Success: Ok,
+                Fail: IActionResult (messages, notices) =>
+                {
+                    _logger.LogNotice(notices);
+                    return NotFound(messages);
+                });
         }
 
         /// <summary>
@@ -57,12 +57,13 @@ namespace DigitalData.Core.API
         [HttpGet]
         public virtual async Task<IActionResult> GetAll()
         {
-            var result = await _service.ReadAllAsync();
-            if (result.IsSuccess)
-            {
-                return Ok(result);
-            }
-            return NotFound(result);
+            return await _service.ReadAllAsync().ThenAsync(
+                Success: Ok,
+                Fail: IActionResult (messages, notices) =>
+                {
+                    _logger.LogNotice(notices);
+                    return NotFound(messages);
+                });
         }
     }
 }

DigitalData.Core.API/ReadControllerBaseWithErrorHandling.cs

@@ -0,0 +1,86 @@
+using DigitalData.Core.Abstractions.Application;
+using DigitalData.Core.DTO;
+using Microsoft.AspNetCore.Mvc;
+
+namespace DigitalData.Core.API
+{
+    /// <summary>
+    /// A base controller class providing  Read operation for a specified entity type,
+    /// with enhanced error handling to ensure robust and reliable API endpoints.
+    /// </summary>
+    /// <typeparam name="TReadDto">The Data Transfer Object type for read operations.</typeparam>
+    /// <typeparam name="TEntity">The entity type CRUD operations will be performed on.</typeparam>
+    /// <typeparam name="TId">The type of the entity's identifier.</typeparam>
+    [ApiController]
+    [Route("api/[controller]")]
+    public class ReadControllerBaseWithErrorHandling<TReadService, TReadDto, TEntity, TId> : ControllerBase
+        where TReadService : IReadService<TReadDto, TEntity, TId>
+        where TReadDto : class
+        where TEntity : class
+    {
+        protected readonly ILogger _logger;
+        protected readonly TReadService _service;
+
+        /// <summary>
+        /// Initializes a new instance of the CRUDControllerBase class with specified logger and CRUD service.
+        /// </summary>
+        /// <param name="logger">The logger to be used by the controller.</param>
+        /// <param name="service">The CRUD service handling business logic for the entity.</param>
+        public ReadControllerBaseWithErrorHandling(
+            ILogger logger,
+            TReadService service)
+        {
+            _logger = logger;
+            _service = service;
+        }
+
+        /// <summary>
+        /// Retrieves an entity by its identifier.
+        /// </summary>
+        /// <param name="id">The identifier of the entity to retrieve.</param>
+        /// <returns>A task that represents the asynchronous read operation. The task result contains the action result.</returns>
+        [HttpGet("{id}")]
+        public virtual async Task<IActionResult> GetById([FromRoute] TId id)
+        {
+            try
+            {
+                return await _service.ReadByIdAsync(id).ThenAsync(
+                    Success: Ok,
+                    Fail: IActionResult (messages, notices) =>
+                    {
+                        _logger.LogNotice(notices);
+                        return NotFound(messages);
+                    });
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "{Message}", ex.Message);
+                return StatusCode(StatusCodes.Status500InternalServerError);
+            }
+        }
+
+        /// <summary>
+        /// Retrieves all entities.
+        /// </summary>
+        /// <returns>A task that represents the asynchronous read-all operation. The task result contains the action result.</returns>
+        [HttpGet]
+        public virtual async Task<IActionResult> GetAll()
+        {
+            try
+            {
+                return await _service.ReadAllAsync().ThenAsync(
+                    Success: Ok,
+                    Fail: IActionResult (messages, notices) =>
+                    {
+                        _logger.LogNotice(notices);
+                        return NotFound(messages);
+                    });
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "{Message}", ex.Message);
+                return StatusCode(StatusCodes.Status500InternalServerError);
+            }
+        }
+    }
+}

DigitalData.Core.Abstractions/Application/IBasicCRUDService.cs

@@ -1,6 +1,6 @@
-using DigitalData.Core.Contracts.Infrastructure;
+using DigitalData.Core.Abstractions.Infrastructure;
 
-namespace DigitalData.Core.Contracts.Application
+namespace DigitalData.Core.Abstractions.Application
 {
     /// <summary>
     /// Implements a simplified CRUD service interface that uses a single Data Transfer Object (DTO) type for all CRUD operations,
@@ -8,7 +8,6 @@ namespace DigitalData.Core.Contracts.Application
     /// This interface inherits from the ICRUDService interface, applying the same DTO type for all generic type parameters,
     /// thereby simplifying the usage for cases where a single DTO is sufficient for all operations on an entity.
     /// </summary>
-    /// <typeparam name="TCRUDRepository">The repository type that provides CRUD operations for entities of type TEntity.</typeparam>
     /// <typeparam name="TDto">The type of the Data Transfer Object used for all CRUD operations.</typeparam>
     /// <typeparam name="TEntity">The type of the entity this service maps to.</typeparam>
     /// <typeparam name="TId">The type of the identifier for the entity.</typeparam>
@@ -16,8 +15,8 @@ namespace DigitalData.Core.Contracts.Application
     /// This interface is useful for entities that do not require different DTOs for different operations,
     /// allowing for a more concise and maintainable codebase when implementing services for such entities.
     /// </remarks>
-    public interface IBasicCRUDService<TCRUDRepository, TDto, TEntity, TId> : ICRUDService<TCRUDRepository, TDto, TDto, TDto, TEntity, TId>
-        where TCRUDRepository : ICRUDRepository<TEntity, TId> where TDto : class where TEntity : class
+    public interface IBasicCRUDService<TDto, TEntity, TId> : ICRUDService<TDto, TDto, TDto, TEntity, TId>
+        where TDto : class, IUnique<TId> where TEntity : class, IUnique<TId>
     {
     }
 }

DigitalData.Core.Abstractions/Application/ICRUDService.cs

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

DigitalData.Core.Abstractions/Application/IDirectorySearchService.cs

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

DigitalData.Core.Abstractions/Application/IReadService.cs

@@ -1,13 +1,10 @@
-using DigitalData.Core.Contracts.Infrastructure;
-using DigitalData.Core.DTO;
+using DigitalData.Core.DTO;
 
-namespace DigitalData.Core.Contracts.Application
+namespace DigitalData.Core.Abstractions.Application
 {
-    public interface ICRUDService<TCRUDRepository, TCreateDto, TReadDto, TUpdateDto, TEntity, TId>
-        where TCRUDRepository : ICRUDRepository<TEntity, TId> where TCreateDto : class where TReadDto : class where TUpdateDto : class where TEntity : class
+    public interface IReadService<TReadDto, TEntity, TId>
+        where TReadDto : class where TEntity : class
     {
-        Task<DataResult<TId>> CreateAsync(TCreateDto createDto);
-
         /// <summary>
         /// Retrieves an entity by its identifier and returns its readDTO representation wrapped in an IServiceResult,
         /// including the readDTO on success or null and an error message on failure.
@@ -22,15 +19,7 @@ namespace DigitalData.Core.Contracts.Application
         /// </summary>
         /// <returns>An DataResult containing a collection of readDTOs representing all entities or an error message.</returns>
         Task<DataResult<IEnumerable<TReadDto>>> ReadAllAsync();
-
-        /// <summary>
-        /// Updates an existing entity based on the provided updateDTO and returns the result wrapped in an IServiceMessage,
-        /// indicating the success or failure of the operation, including the error messages on failure.
-        /// </summary>
-        /// <param name="updateDto">The updateDTO with updated values for the entity.</param>
-        /// <returns>An Result indicating the outcome of the update operation, with an appropriate message.</returns>
-        Task<Result> UpdateAsync(TUpdateDto updateDto);
-
+        
         /// <summary>
         /// Deletes an entity by its identifier and returns the result wrapped in an IServiceMessage,
         /// indicating the success or failure of the operation, including the error messages on failure.
@@ -45,16 +34,5 @@ namespace DigitalData.Core.Contracts.Application
         /// <param name="id">The identifier of the entity to check.</param>
         /// <returns>A task that represents the asynchronous operation. The task result contains a boolean value indicating whether the entity exists.</returns>
         Task<bool> HasEntity(TId id);
-
-        /// <summary>
-        /// Handles exceptions that occur within service actions. This method should log the exception
-        /// and return an String that contains information about the error, which can then be sent to the client.
-        /// The implementation should determine the appropriate level of detail to include in the error message
-        /// based on security and usability considerations.
-        /// </summary>
-        /// <param name="ex">The exception that occurred during the controller action.</param>
-        /// <returns>An string instance representing the outcome of the error handling process.
-        /// This includes a flag indicating the operation was unsuccessful and any relevant error messages.</returns>
-        string HandleException(Exception ex);
     }
 }

DigitalData.Core.Abstractions/Client/IBaseHttpClientService.cs

@@ -0,0 +1,22 @@
+using System.Net;
+
+namespace DigitalData.Core.Abstractions.Client
+{
+    public interface IBaseHttpClientService
+    {
+        CookieCollection GetCookies(string path = "");
+
+        Task<HttpResponseMessage> FetchAsync(
+            string? scheme = null,
+            int? port = null,
+            string path = "",
+            IEnumerable<KeyValuePair<string, object?>>? queryParams = null,
+            HttpMethod? method = null,
+            HttpContent? body = null,
+            IEnumerable<KeyValuePair<string, object>>? form = null,
+            IEnumerable<KeyValuePair<string, object>>? headers = null,
+            bool sendWithCookie = true,
+            bool saveCookie = true
+        );
+    }
+}

DigitalData.Core.Abstractions/Client/IHttpClientOptions.cs

@@ -0,0 +1,13 @@
+namespace DigitalData.Core.Abstractions.Client
+{
+    public interface IHttpClientOptions
+    {
+        string Uri { get; init; }
+
+        string? Path { get; init; }
+
+        Dictionary<string, object>? Headers { get; init; }
+
+        Dictionary<string, object?>? QueryParams { get; init; }
+    }
+}

DigitalData.Core.Abstractions/Client/IHttpClientService.cs

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

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

@@ -0,0 +1,44 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+	<PropertyGroup>
+		<TargetFrameworks>net7.0;net8.0</TargetFrameworks>
+		<ImplicitUsings>enable</ImplicitUsings>
+		<Nullable>enable</Nullable>
+		<!-- NuGet Package Metadata -->
+		<PackageId>DigitalData.Core.Abstractions</PackageId>
+		<Authors>Digital Data GmbH</Authors>
+		<Company>Digital Data GmbH</Company>
+		<Product>DigitalData.Core.Abstractions</Product>
+		<Description>This package contains abstractions for the DigitalData.Core.Abstractions library, developed according to the principles of Clean Architecture. It promotes separation of concerns and enables independent core logic.</Description>
+		<PackageTags>digital data core abstractions clean architecture</PackageTags>
+		<GeneratePackageOnBuild>True</GeneratePackageOnBuild>
+		<Copyright>Copyright 2024</Copyright>
+		<PackageProjectUrl></PackageProjectUrl>
+		<RepositoryUrl>http://git.dd:3000/AppStd/WebCoreModules.git</RepositoryUrl>
+		<PackAsTool>False</PackAsTool>
+		<PackageIcon>core_icon.png</PackageIcon>
+		<Version>2.2.1</Version>
+		<AssemblyVersion>2.2.1</AssemblyVersion>
+		<FileVersion>2.2.1</FileVersion>
+	</PropertyGroup>
+
+	<ItemGroup>
+	  <None Include="..\..\nuget-package-icons\core_icon.png">
+	    <Pack>True</Pack>
+	    <PackagePath>\</PackagePath>
+	  </None>
+	</ItemGroup>
+
+	<ItemGroup>
+		<PackageReference Include="Microsoft.Extensions.Caching.Memory" Version="7.0.0" />
+		<PackageReference Include="Microsoft.Extensions.Configuration.Binder" Version="7.0.4" />
+		<PackageReference Include="System.DirectoryServices" Version="7.0.1" />
+		<PackageReference Include="System.DirectoryServices.AccountManagement" Version="7.0.1" />
+		<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.Abstractions/IUnique.cs

@@ -0,0 +1,7 @@
+namespace DigitalData.Core.Abstractions
+{
+    public interface IUnique<T>
+    {
+        public T Id { get; }
+    }
+}

DigitalData.Core.Abstractions/Infrastructure/ICRUDRepository.cs

@@ -1,11 +1,11 @@
-namespace DigitalData.Core.Contracts.Infrastructure
+namespace DigitalData.Core.Abstractions.Infrastructure
 {
     /// <summary>
     /// Defines the contract for CRUD operations on a repository for entities of type TEntity.
     /// </summary>
     /// <typeparam name="TEntity">The type of the entity this repository works with.</typeparam>
     /// <typeparam name="TId">The type of the identifier for the entity.</typeparam>
-    public interface ICRUDRepository<TEntity, TId> where TEntity : class
+    public interface ICRUDRepository<TEntity, TId> where TEntity : class, IUnique<TId>
     {
         /// <summary>
         /// Adds a new entity to the repository.
@@ -40,5 +40,23 @@
         /// <param name="entity">The entity to delete.</param>
         /// <returns>If entity is deleted, return true othwerwise return false.</returns>
         Task<bool> DeleteAsync(TEntity entity);
+
+        /// <summary>
+        /// Asynchronously counts all entities in the repository.
+        /// </summary>
+        /// <returns>The total number of entities in the repository.</returns>
+        Task<int> CountAsync();
+
+        /// <summary>
+        /// Asynchronously counts the number of entities in the repository that match a specific identifier.
+        /// </summary>
+        /// <param name="id">The identifier of the entities to count.</param>
+        /// <returns>The number of entities with the specified identifier.</returns>
+        /// <remarks>
+        /// This method provides a count of entities in the database that match the given identifier. 
+        /// If there are multiple entities with the same identifier, they will all be counted. 
+        /// The default implementation assumes that the identifier is unique for each entity.
+        /// </remarks>
+        Task<int> CountAsync(TId id);
     }
 }

DigitalData.Core.Abstractions/Security/CryptographerExtensions.cs

@@ -0,0 +1,21 @@
+namespace DigitalData.Core.Abstractions.Security
+{
+    public static class CryptographerExtensions
+    {
+        public static IEnumerable<TRSACryptographer> GetByIssuer<TRSACryptographer>(this IEnumerable<TRSACryptographer> cryptographers, string issuer) where TRSACryptographer: IRSACryptographer
+            => cryptographers.Where(c => c.Issuer == issuer);
+
+        public static IEnumerable<TRSACryptographer> GetByAudience<TRSACryptographer>(this IEnumerable<TRSACryptographer> cryptographers, string audience) where TRSACryptographer : IRSACryptographer
+            => cryptographers.Where(c => c.Audience == audience);
+
+        public static TRSACryptographer Get<TRSACryptographer>(this IEnumerable<TRSACryptographer> cryptographers, string issuer, string audience) where TRSACryptographer : IRSACryptographer
+            => cryptographers.Where(c => c.Issuer == issuer && c.Audience == audience).SingleOrDefault()
+            ?? throw new InvalidOperationException($"No {typeof(TRSACryptographer).GetType().Name.TrimStart('I')} found with Issuer: {issuer} and Audience: {audience}.");
+
+        public static bool TryGet<TRSACryptographer>(this IEnumerable<TRSACryptographer> cryptographers, string issuer, string audience, out TRSACryptographer? cryptographer) where TRSACryptographer : IRSACryptographer
+        {
+            cryptographer = cryptographers.SingleOrDefault(c => c.Issuer == issuer && c.Audience == audience);
+            return cryptographer is not null;
+        }
+    }
+}

DigitalData.Core.Abstractions/Security/IAsymCryptService.cs

@@ -0,0 +1,9 @@
+namespace DigitalData.Core.Abstractions.Security
+{
+    public interface IAsymCryptService<TParams> : IRSAFactory<TParams>
+    {
+        public IEnumerable<IRSADecryptor> Decryptors { get; }
+
+        public IEnumerable<IRSAEncryptor> Encryptors { get; }
+    }
+}

DigitalData.Core.Abstractions/Security/IRSACryptographer.cs

@@ -0,0 +1,21 @@
+using System.Security.Cryptography;
+
+namespace DigitalData.Core.Abstractions.Security
+{
+    public interface IRSACryptographer
+    {
+        public string Pem { get; init; }
+
+        public RSAEncryptionPadding Padding { get; init; }
+
+        public string? Directory { get; set; }
+
+        public string? FileName { get; set; }
+
+        public string Issuer { get; init; }
+
+        public string Audience { get; init; }
+
+        public void Init();
+    }
+}

DigitalData.Core.Abstractions/Security/IRSADecryptor.cs

@@ -0,0 +1,13 @@
+namespace DigitalData.Core.Abstractions.Security
+{
+    public interface IRSADecryptor : IRSACryptographer
+    {
+        public bool Encrypt { get; init; }
+
+        IRSAEncryptor Encryptor { get; }
+
+        byte[] Decrypt(byte[] data);
+
+        string Decrypt(string data);
+    }
+}

DigitalData.Core.Abstractions/Security/IRSAEncryptor.cs

@@ -0,0 +1,11 @@
+namespace DigitalData.Core.Abstractions.Security
+{
+    public interface IRSAEncryptor : IRSACryptographer
+    {
+        public byte[] Encrypt(byte[] data);
+
+        public string Encrypt(string data);
+
+        public bool Verify(string data, string signature) => Encrypt(data) == signature;
+    }
+}

DigitalData.Core.Abstractions/Security/IRSAFactory.cs

@@ -0,0 +1,16 @@
+using System.Security.Cryptography;
+
+namespace DigitalData.Core.Abstractions.Security
+{
+    public interface IRSAFactory<TParams>
+    {
+        string CreateRSAPrivateKeyPem(int? keySizeInBits = null);
+
+        string CreateEncryptedPrivateKeyPem(
+            int? keySizeInBits = null,
+            string? password = null,
+            PbeEncryptionAlgorithm? pbeEncryptionAlgorithm = null,
+            HashAlgorithmName? hashAlgorithmName = null,
+            int? iterationCount = null);
+    }
+}

DigitalData.Core.Application/BasicCRUDService.cs

@@ -1,8 +1,7 @@
 using AutoMapper;
-using DigitalData.Core.Contracts.Application;
-using DigitalData.Core.Contracts.Infrastructure;
-using Microsoft.Extensions.Localization;
-
+using DigitalData.Core.Abstractions;
+using DigitalData.Core.Abstractions.Application;
+using DigitalData.Core.Abstractions.Infrastructure;
 
 namespace DigitalData.Core.Application
 {
@@ -20,17 +19,16 @@ namespace DigitalData.Core.Application
     /// and a culture-specific translation service for any necessary text translations, ensuring a versatile and internationalized approach to CRUD operations.
     /// </remarks>
     public class BasicCRUDService<TCRUDRepository, TDto, TEntity, TId> :
-        CRUDService<TCRUDRepository, TDto, TDto, TDto, TEntity, TId>, IBasicCRUDService<TCRUDRepository, TDto, TEntity, TId>
-         where TCRUDRepository : ICRUDRepository<TEntity, TId> where TDto : class where TEntity : class
+        CRUDService<TCRUDRepository, TDto, TDto, TDto, TEntity, TId>, IBasicCRUDService<TDto, TEntity, TId>
+         where TCRUDRepository : ICRUDRepository<TEntity, TId> where TDto : class, IUnique<TId> where TEntity : class, IUnique<TId>
     {
         /// <summary>
         /// Initializes a new instance of the BasicCRUDService with the specified repository, translation service, and AutoMapper configuration.
         /// </summary>
         /// <param name="repository">The CRUD repository for accessing and manipulating entity data.</param>
-        /// <param name="translationService">The service used for key-based text translations, facilitating localization.</param>
         /// <param name="mapper">The AutoMapper instance for mapping between DTOs and entities.</param>
-        public BasicCRUDService(TCRUDRepository repository, IStringLocalizer defaultLocalizer, IMapper mapper) :
-            base(repository, defaultLocalizer, mapper)
+        public BasicCRUDService(TCRUDRepository repository, IMapper mapper) :
+            base(repository, mapper)
         {
         }
     }

DigitalData.Core.Application/CRUDService.cs

@@ -1,10 +1,9 @@
-using DigitalData.Core.Contracts.Application;
-using DigitalData.Core.Contracts.Infrastructure;
+using DigitalData.Core.Abstractions.Application;
+using DigitalData.Core.Abstractions.Infrastructure;
 using AutoMapper;
-using System.Reflection;
-using System.ComponentModel.DataAnnotations;
-using Microsoft.Extensions.Localization;
 using DigitalData.Core.DTO;
+using DigitalData.Core.Abstractions;
+using Microsoft.Extensions.Logging;
 
 namespace DigitalData.Core.Application
 {
@@ -16,29 +15,17 @@ namespace DigitalData.Core.Application
     /// <typeparam name="TUpdateDto">The DTO type for update operations.</typeparam>
     /// <typeparam name="TEntity">The entity type.</typeparam>
     /// <typeparam name="TId">The type of the identifier for the entity.</typeparam>
-    public class CRUDService<TCRUDRepository, TCreateDto, TReadDto, TUpdateDto, TEntity, TId> : ICRUDService<TCRUDRepository, TCreateDto, TReadDto, TUpdateDto, TEntity, TId>
-        where TCRUDRepository : ICRUDRepository<TEntity, TId> where TCreateDto : class where TReadDto : class where TUpdateDto : class where TEntity : class
+    public class CRUDService<TCRUDRepository, TCreateDto, TReadDto, TUpdateDto, TEntity, TId> : ReadService<TCRUDRepository, TReadDto, TEntity, TId>, ICRUDService<TCreateDto, TReadDto, TUpdateDto, TEntity, TId>
+        where TCRUDRepository : ICRUDRepository<TEntity, TId> where TCreateDto : class where TReadDto : class where TUpdateDto : IUnique<TId> where TEntity : class, IUnique<TId>
     {
-        protected readonly TCRUDRepository _repository;
-        protected readonly IMapper _mapper;
-        protected readonly PropertyInfo? _keyPropertyInfo;
-        protected readonly IStringLocalizer _localizer;
 
         /// <summary>
         /// Initializes a new instance of the CRUDService class with the specified repository, translation service, and mapper.
         /// </summary>
         /// <param name="repository">The CRUD repository for accessing the database.</param>
-        /// <param name="localizer">The localizer for translating messages based on culture.</param>
         /// <param name="mapper">The AutoMapper instance for mapping between DTOs and entity objects.</param>
-        public CRUDService(TCRUDRepository repository, IStringLocalizer localizer, IMapper mapper)
+        public CRUDService(TCRUDRepository repository, IMapper mapper) : base(repository: repository, mapper: mapper)
         {
-            _repository = repository;
-            _mapper = mapper;
-
-            _keyPropertyInfo = typeof(TEntity).GetProperties()
-                .FirstOrDefault(prop => Attribute.IsDefined(prop, typeof(KeyAttribute)));
-
-            _localizer = localizer;
         }
 
         /// <summary>
@@ -48,33 +35,9 @@ namespace DigitalData.Core.Application
         /// <returns>A service result indicating success or failure, including the entity DTO.</returns>
         public virtual async Task<DataResult<TId>> CreateAsync(TCreateDto createDto)
         {
-            var entity = _mapper.MapOrThrow<TEntity>(createDto);
+            var entity = _mapper.Map<TEntity>(createDto);
             var createdEntity = await _repository.CreateAsync(entity);
-            return createdEntity is null ? Result.Fail<TId>() : Result.Success(KeyValueOf(createdEntity));
-        }
-
-        /// <summary>
-        /// Asynchronously reads an entity by its identifier and maps it to a read DTO.
-        /// </summary>
-        /// <param name="id">The identifier of the entity to read.</param>
-        /// <returns>A service result indicating success or failure, including the read DTO if successful.</returns>
-        public virtual async Task<DataResult<TReadDto>> ReadByIdAsync(TId id)
-        {
-            var entity = await _repository.ReadByIdAsync(id);
-            return entity is null
-                ? Result.Fail<TReadDto>().Message(_localizer[Key.EntityDoesNotExist])
-                : Result.Success(_mapper.MapOrThrow<TReadDto>(entity));
-        }
-
-        /// <summary>
-        /// Asynchronously reads all entities and maps them to read DTOs.
-        /// </summary>
-        /// <returns>A service result including a collection of read DTOs.</returns>
-        public virtual async Task<DataResult<IEnumerable<TReadDto>>> ReadAllAsync()
-        {
-            var entities = await _repository.ReadAllAsync();
-            var readDto = _mapper.MapOrThrow<IEnumerable<TReadDto>>(entities);
-            return Result.Success(readDto);
+            return createdEntity is null ? Result.Fail<TId>() : Result.Success(createdEntity.Id);
         }
 
         /// <summary>
@@ -84,64 +47,16 @@ namespace DigitalData.Core.Application
         /// <returns>A service message indicating success or failure.</returns>
         public virtual async Task<Result> UpdateAsync(TUpdateDto updateDto)
         {
-            var entity = _mapper.MapOrThrow<TEntity>(updateDto);
-            bool isUpdated = await _repository.UpdateAsync(entity);
-            return isUpdated ? Result.Success() : Result.Fail().Message(_localizer[Key.UpdateFailed]);
-        }
+            var currentEntitiy = await _repository.ReadByIdAsync(updateDto.Id);
 
-        /// <summary>
-        /// Asynchronously deletes an entity by its identifier.
-        /// </summary>
-        /// <param name="id">The identifier of the entity to delete.</param>
-        /// <returns>A service message indicating success or failure.</returns>
-        public virtual async Task<Result> DeleteAsyncById(TId id)
-        {
-            TEntity? entity = await _repository.ReadByIdAsync(id);
+            if (currentEntitiy is null)
+                return Result.Fail().Notice(LogLevel.Warning, Flag.NotFound, $"{updateDto.Id} is not found in update process of {GetType()} entity.");
+    
+            var entity = _mapper.Map(updateDto, currentEntitiy);
 
-            if (entity is null)
-                return Result.Fail().Message(_localizer[Key.DeletionFailed], _localizer[Key.EntityDoesNotExist]);
-
-            bool isDeleted = await _repository.DeleteAsync(entity);
-            return isDeleted ? Result.Success() : Result.Fail().Message(_localizer[Key.DeletionFailed]);
-        }
-
-        /// <summary>
-        /// Asynchronously checks if an entity with the specified identifier exists.
-        /// </summary>
-        /// <param name="id">The identifier of the entity to check.</param>
-        /// <returns>A Task that represents the asynchronous operation. The task result contains a boolean value indicating whether the entity exists.</returns>
-        public virtual async Task<bool> HasEntity(TId id)
-        {
-            var entity = await _repository.ReadByIdAsync(id);
-            return entity is not null;
-        }
-
-        /// <summary>
-        /// Retrieves the ID value of an entity based on the defined [Key] attribute.
-        /// </summary>
-        /// <param name="entity">The entity from which to extract the ID.</param>
-        /// <returns>The ID of the entity.</returns>
-        protected virtual TId KeyValueOf(TEntity entity)
-        {
-            if (_keyPropertyInfo is null)
-                throw new InvalidOperationException($"No property with [Key] attribute found on {typeof(TEntity).Name} entity.");
-
-            object idObj = _keyPropertyInfo?.GetValue(entity) ?? throw new InvalidOperationException($"The ID property of {typeof(TEntity).Name} entity cannot be null.");
-
-            if (idObj is TId id)
-                return id;
-            else
-                throw new InvalidCastException($"The ID of {typeof(TEntity).Name} entity must be type of {typeof(TId).Name}, but it is type of {idObj.GetType().Name}.");
-        }
-
-        /// <summary>
-        /// Handles exceptions that occur during CRUD operations, providing a structured string.
-        /// </summary>
-        /// <param name="ex">The exception that was caught during CRUD operations.</param>
-        /// <returns>A <see cref="IServiceMessage"/> containing information about the failure, including a user-friendly error message and additional error details.</returns>
-        public virtual string HandleException(Exception ex)
-        {
-            return $"An unexpected error occurred on the server side. Please inform the IT support team.\n{ex.GetType().Name}\n{ex.Message}";
+            return await _repository.UpdateAsync(entity) 
+                ? Result.Success() 
+                : Result.Fail();
         }
     }
 }

DigitalData.Core.Application/DIExtensions.cs

@@ -1,10 +1,10 @@
 using AutoMapper;
-using DigitalData.Core.Contracts.Application;
-using DigitalData.Core.Contracts.Infrastructure;
-using Microsoft.Extensions.Configuration;
+using DigitalData.Core.Abstractions;
+using DigitalData.Core.Abstractions.Application;
+using DigitalData.Core.Abstractions.Infrastructure;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Options;
 using Microsoft.IdentityModel.Tokens;
-using System.Configuration;
 
 namespace DigitalData.Core.Application
 {
@@ -24,9 +24,9 @@ namespace DigitalData.Core.Application
         /// <param name="configureService">An optional action to configure additional services for the CRUD service.</param>
         /// <returns>The original <see cref="IServiceCollection"/> instance, allowing further configuration.</returns>
         public static IServiceCollection AddCleanBasicCRUDService<TCRUDRepository, TDto, TEntity, TId, TProfile>(this IServiceCollection services, Action<IServiceCollection>? configureService = null)
-            where TCRUDRepository : ICRUDRepository<TEntity, TId> where TDto : class where TEntity : class where TProfile : Profile
+            where TCRUDRepository : ICRUDRepository<TEntity, TId> where TDto : class, IUnique<TId> where TEntity : class, IUnique<TId> where TProfile : Profile
         {
-            services.AddScoped<IBasicCRUDService<TCRUDRepository, TDto, TEntity, TId>, BasicCRUDService<TCRUDRepository, TDto, TEntity, TId>>();
+            services.AddScoped<IBasicCRUDService<TDto, TEntity, TId>, BasicCRUDService<TCRUDRepository, TDto, TEntity, TId>>();
             configureService?.Invoke(services);
 
             services.AddAutoMapper(typeof(TProfile).Assembly);
@@ -48,9 +48,9 @@ namespace DigitalData.Core.Application
         /// <param name="configureService">An optional action to configure additional services for the CRUD service.</param>
         /// <returns>The original <see cref="IServiceCollection"/> instance, allowing further configuration.</returns>
         public static IServiceCollection AddCleanCRUDService<TCRUDRepository, TCreateDto, TReadDto, TUpdateDto, TEntity, TId, TProfile>(this IServiceCollection services, Action<IServiceCollection>? configureService = null)
-            where TCRUDRepository : ICRUDRepository<TEntity, TId> where TCreateDto : class where TReadDto : class where TUpdateDto : class where TEntity : class where TProfile : Profile
+            where TCRUDRepository : ICRUDRepository<TEntity, TId> where TCreateDto : class where TReadDto : class where TUpdateDto : class, IUnique<TId> where TEntity : class, IUnique<TId> where TProfile : Profile
         {
-            services.AddScoped<ICRUDService<TCRUDRepository, TCreateDto, TReadDto, TUpdateDto, TEntity, TId>, CRUDService<TCRUDRepository, TCreateDto, TReadDto, TUpdateDto, TEntity, TId>>();
+            services.AddScoped<ICRUDService<TCreateDto, TReadDto, TUpdateDto, TEntity, TId>, CRUDService<TCRUDRepository, TCreateDto, TReadDto, TUpdateDto, TEntity, TId>>();
             configureService?.Invoke(services);
 
             services.AddAutoMapper(typeof(TProfile).Assembly);
@@ -58,13 +58,40 @@ namespace DigitalData.Core.Application
             return services;
         }
 
-        public static IServiceCollection AddDirectorySearchService(this IServiceCollection service)
+        /// <summary>
+        /// Adds the directory search service to the <see cref="IServiceCollection"/>.
+        /// </summary>
+        /// <param name="service">The <see cref="IServiceCollection"/> to add services to.</param>
+        /// <param name="directorySearchOptions">
+        /// Optional. An instance of <see cref="DirectorySearchOptions"/> to configure the directory search service.
+        /// If not provided, the options need to be configured separately.
+        /// </param>
+        /// <returns>The updated <see cref="IServiceCollection"/>.</returns>
+        /// <remarks>
+        /// This method adds the necessary services for directory search functionality, including memory caching.
+        /// If <paramref name="directorySearchOptions"/> is not provided, ensure to configure the options separately
+        /// using the <see cref="IOptions{TOptions}"/> pattern.
+        /// </remarks>
+        public static IServiceCollection AddDirectorySearchService(this IServiceCollection service, DirectorySearchOptions? directorySearchOptions = null)
         {
-            service.AddMemoryCache();
-            service.AddScoped<IDirectorySearchService, DirectorySearchService>();
-            return service;
+            if(directorySearchOptions is not null)
+                service.AddSingleton(Options.Create(directorySearchOptions));
+
+            return service
+                .AddMemoryCache()
+                .AddScoped<IDirectorySearchService, DirectorySearchService>();
         }
 
+        /// <summary>
+        /// Adds the JWT service to the <see cref="IServiceCollection"/>.
+        /// </summary>
+        /// <typeparam name="TClaimValue">The type of the claim value used in the JWT token.</typeparam>
+        /// <param name="services">The <see cref="IServiceCollection"/> to add the service to.</param>
+        /// <param name="tokenDescriptorFactory">A function that takes a claim value of type <typeparamref name="TClaimValue"/> and returns a <see cref="SecurityTokenDescriptor"/> used to configure the JWT token.</param>
+        /// <returns>The original <see cref="IServiceCollection"/> instance, allowing further configuration.</returns>
+        /// <remarks>
+        /// This method adds the necessary services for handling JWT tokens. The <paramref name="tokenDescriptorFactory"/> function is used to generate the <see cref="SecurityTokenDescriptor"/> which is essential for creating the JWT tokens.
+        /// </remarks>
         public static IServiceCollection AddJWTService<TClaimValue>(this IServiceCollection services, Func<TClaimValue, SecurityTokenDescriptor> tokenDescriptorFactory)
         {
             return services.AddScoped<IJWTService<TClaimValue>, JWTService<TClaimValue>>(provider => new (tokenDescriptorFactory));

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

@@ -1,15 +1,27 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net7.0</TargetFramework>
+	<TargetFrameworks>net7.0;net8.0</TargetFrameworks>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
+    <GeneratePackageOnBuild>True</GeneratePackageOnBuild>
+    <Description>This package provides implementations for application services within the DigitalData.Core.Abstractions library. It includes generic CRUD operations using Entity Framework Core, AutoMapper integration for object mapping, and additional services such as JWT handling and directory search functionality, adhering to Clean Architecture principles to ensure separation of concerns and maintainability.</Description>
+    <PackageId>DigitalData.Core.Application</PackageId>
+    <Authors>Digital Data GmbH</Authors>
+    <Company>Digital Data GmbH</Company>
+    <Product>DigitalData.Core.Application</Product>
+    <Copyright>Copyright 2024</Copyright>
+    <PackageIcon>core_icon.png</PackageIcon>
+    <RepositoryUrl>http://git.dd:3000/AppStd/WebCoreModules.git</RepositoryUrl>
+    <PackageTags>digital data core application clean architecture</PackageTags>
+    <Version>2.0.0.0</Version>
   </PropertyGroup>
 
   <ItemGroup>
-    <Compile Remove="NewFolder\**" />
-    <EmbeddedResource Remove="NewFolder\**" />
-    <None Remove="NewFolder\**" />
+    <None Include="..\..\nuget-package-icons\core_icon.png">
+      <Pack>True</Pack>
+      <PackagePath>\</PackagePath>
+    </None>
   </ItemGroup>
 
   <ItemGroup>
@@ -24,7 +36,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <ProjectReference Include="..\DigitalData.Core.Contracts\DigitalData.Core.Contracts.csproj" />
+    <ProjectReference Include="..\DigitalData.Core.Abstractions\DigitalData.Core.Abstractions.csproj" />
   </ItemGroup>
 
 </Project>

DigitalData.Core.Application/DirectorySearchOptions.cs

@@ -0,0 +1,28 @@
+namespace DigitalData.Core.Application
+{
+    /// <summary>
+    /// Represents the options for configuring directory search operations.
+    /// </summary>
+    public class DirectorySearchOptions
+    {
+        /// <summary>
+        /// Gets or initializes the name of the server to be used in the directory search.
+        /// </summary>
+        public string? ServerName { get; init; }
+
+        /// <summary>
+        /// Gets or initializes the root directory path for the search.
+        /// </summary>
+        public string? Root { get; init; }
+
+        /// <summary>
+        /// Gets or initializes the number of days before the user cache expires.
+        /// </summary>
+        public int UserCacheExpirationDays { get; init; }
+
+        /// <summary>
+        /// Gets or initializes the custom search filters to be applied during directory searches.
+        /// </summary>
+        public Dictionary<string, string> CustomSearchFilters { get; init; } = new();
+    }
+}

DigitalData.Core.Application/DirectorySearchService.cs

@@ -1,12 +1,10 @@
-using DigitalData.Core.Contracts.Application;
-using Microsoft.Extensions.Logging;
+using DigitalData.Core.Abstractions.Application;
 using System.Diagnostics.CodeAnalysis;
 using System.DirectoryServices;
 using Microsoft.Extensions.Caching.Memory;
-using Microsoft.Extensions.Configuration;
 using System.DirectoryServices.AccountManagement;
-using Microsoft.Extensions.Localization;
 using DigitalData.Core.DTO;
+using Microsoft.Extensions.Options;
 
 namespace DigitalData.Core.Application
 {
@@ -19,36 +17,57 @@ namespace DigitalData.Core.Application
         public string SearchRootPath { get; }
         private readonly DateTimeOffset _userCacheExpiration;
         public Dictionary<string, string> CustomSearchFilters { get; }
-        protected readonly IStringLocalizer _localizer;
 
-        public DirectorySearchService(IConfiguration configuration, ILogger<DirectorySearchService> logger, IMemoryCache memoryCache, IStringLocalizer localizer)
+        /// <summary>
+        /// Initializes a new instance of the <see cref="DirectorySearchService"/> class.
+        /// </summary>
+        /// <param name="options">The options for directory search.</param>
+        /// <param name="memoryCache">The memory cache.</param>
+        /// <exception cref="InvalidOperationException">
+        /// Thrown if the server name or root directory is not configured.
+        /// </exception>
+        public DirectorySearchService(IOptions<DirectorySearchOptions> options, IMemoryCache memoryCache)
         {
             _memoryCache = memoryCache;
 
-            ServerName = configuration["DirectorySearch:ServerName"] ?? throw new InvalidOperationException("The server name for directory search is not configured. Please specify the 'DirectorySearch:ServerName' in the configuration.");
+            var dirSearchOptions = options.Value;
 
-            Root = configuration["DirectorySearch:Root"] ?? throw new InvalidOperationException("The root for directory search is not configured. Please specify the 'DirectorySearch:Root' in the configuration.");
+            ServerName = dirSearchOptions.ServerName ?? throw new InvalidOperationException("The server name for directory search is not configured. Please specify the 'DirectorySearch:ServerName' in the configuration.");
+
+            Root = dirSearchOptions.Root ?? throw new InvalidOperationException("The root for directory search is not configured. Please specify the 'DirectorySearch:Root' in the configuration.");
 
             SearchRootPath = $"LDAP://{ServerName}/{Root}";
+            
+            CustomSearchFilters = dirSearchOptions.CustomSearchFilters;
 
-            var customSearchFiltersSection = configuration.GetSection("DirectorySearch:CustomSearchFilters");
-            CustomSearchFilters = customSearchFiltersSection.Get<Dictionary<string, string>>() ?? new();
-
-            var dayCounts = configuration.GetValue<int>("DirectorySearch:UserCacheExpirationDays");
+            var dayCounts = dirSearchOptions.UserCacheExpirationDays;
             if (dayCounts == default)
                 _userCacheExpiration = default;
             else
                 _userCacheExpiration = DateTimeOffset.Now.Date.AddDays(dayCounts);
-
-            _localizer = localizer;
         }
 
+        /// <summary>
+        /// Validates the credentials of a directory entry.
+        /// </summary>
+        /// <param name="dirEntryUsername">The directory entry username.</param>
+        /// <param name="dirEntryPassword">The directory entry password.</param>
+        /// <returns>True if the credentials are valid; otherwise, false.</returns>
         public bool ValidateCredentials(string dirEntryUsername, string dirEntryPassword)
         {
             using var context = new PrincipalContext(ContextType.Domain, ServerName, Root);
             return context.ValidateCredentials(dirEntryUsername, dirEntryPassword);
         }
 
+        /// <summary>
+        /// Finds all directory entries matching the specified filter.
+        /// </summary>
+        /// <param name="searchRoot">The search root.</param>
+        /// <param name="filter">The search filter.</param>
+        /// <param name="searchScope">The search scope.</param>
+        /// <param name="sizeLimit">The size limit.</param>
+        /// <param name="properties">The properties to load.</param>
+        /// <returns>A <see cref="DataResult{T}"/> containing the results.</returns>
         public DataResult<IEnumerable<ResultPropertyCollection>> FindAll(DirectoryEntry searchRoot, string filter, SearchScope searchScope = SearchScope.Subtree, int sizeLimit = 5000, params string[] properties)
         {
             List<ResultPropertyCollection> list = new();
@@ -78,18 +97,30 @@ namespace DigitalData.Core.Application
             return Result.Success<IEnumerable<ResultPropertyCollection>>(list);
         }
 
+        /// <summary>
+        /// Finds all directory entries matching the specified filter, using the user cache.
+        /// </summary>
+        /// <param name="username">The username.</param>
+        /// <param name="filter">The search filter.</param>
+        /// <param name="searchScope">The search scope.</param>
+        /// <param name="sizeLimit">The size limit.</param>
+        /// <param name="properties">The properties to load.</param>
+        /// <returns>A <see cref="DataResult{T}"/> containing the results.</returns>
         public DataResult<IEnumerable<ResultPropertyCollection>> FindAllByUserCache(string username, string filter, SearchScope searchScope = SearchScope.Subtree, int sizeLimit = 5000, params string[] properties)
         {
-            List<ResultPropertyCollection> list = new();
-
             _memoryCache.TryGetValue(username, out DirectoryEntry? searchRoot);
 
             if (searchRoot is null)
-                return Result.Fail<IEnumerable<ResultPropertyCollection>>().Message(_localizer[Key.DirSearcherDisconnected]);
+                return Result.Fail<IEnumerable<ResultPropertyCollection>>();
 
             return FindAll(searchRoot, filter, searchScope, sizeLimit, properties);
         }
 
+        /// <summary>
+        /// Sets the search root in the cache.
+        /// </summary>
+        /// <param name="dirEntryUsername">The directory entry username.</param>
+        /// <param name="dirEntryPassword">The directory entry password.</param>
         public void SetSearchRootCache(string dirEntryUsername, string dirEntryPassword)
         {
             if (_userCacheExpiration == default)
@@ -98,6 +129,12 @@ namespace DigitalData.Core.Application
                 _memoryCache.Set(key: dirEntryUsername, new DirectoryEntry(path: SearchRootPath, username: dirEntryUsername, password: dirEntryPassword), absoluteExpiration: _userCacheExpiration);
         }
 
+
+        /// <summary>
+        /// Gets the search root from the cache.
+        /// </summary>
+        /// <param name="dirEntryUsername">The directory entry username.</param>
+        /// <returns>The cached <see cref="DirectoryEntry"/> if found; otherwise, null.</returns>
         public DirectoryEntry? GetSearchRootCache(string dirEntryUsername)
         {
             _memoryCache.TryGetValue(dirEntryUsername, out DirectoryEntry? root);

DigitalData.Core.Application/ReadService.cs

@@ -0,0 +1,79 @@
+using DigitalData.Core.Abstractions.Application;
+using DigitalData.Core.Abstractions.Infrastructure;
+using AutoMapper;
+using DigitalData.Core.DTO;
+using DigitalData.Core.Abstractions;
+
+namespace DigitalData.Core.Application
+{
+    /// <summary>
+    /// Provides generic Read (Read and Delete) operations for a specified type of entity.
+    /// </summary>
+    /// <typeparam name="TReadDto">The DTO type for read operations.</typeparam>
+    /// <typeparam name="TEntity">The entity type.</typeparam>
+    /// <typeparam name="TId">The type of the identifier for the entity.</typeparam>
+    public class ReadService<TCRUDRepository, TReadDto, TEntity, TId> : IReadService<TReadDto, TEntity, TId>
+        where TCRUDRepository : ICRUDRepository<TEntity, TId> where TReadDto : class where TEntity : class, IUnique<TId>
+    {
+        protected readonly TCRUDRepository _repository;
+        protected readonly IMapper _mapper;
+
+        /// <summary>
+        /// Initializes a new instance of the CRUDService class with the specified repository, translation service, and mapper.
+        /// </summary>
+        /// <param name="repository">The CRUD repository for accessing the database.</param>
+        /// <param name="mapper">The AutoMapper instance for mapping between DTOs and entity objects.</param>
+        public ReadService(TCRUDRepository repository, IMapper mapper)
+        {
+            _repository = repository;
+            _mapper = mapper;
+        }
+
+        /// <summary>
+        /// Asynchronously reads an entity by its identifier and maps it to a read DTO.
+        /// </summary>
+        /// <param name="id">The identifier of the entity to read.</param>
+        /// <returns>A service result indicating success or failure, including the read DTO if successful.</returns>
+        public virtual async Task<DataResult<TReadDto>> ReadByIdAsync(TId id)
+        {
+            var entity = await _repository.ReadByIdAsync(id);
+            return entity is null
+                ? Result.Fail<TReadDto>()
+                : Result.Success(_mapper.Map<TReadDto>(entity));
+        }
+
+        /// <summary>
+        /// Asynchronously reads all entities and maps them to read DTOs.
+        /// </summary>
+        /// <returns>A service result including a collection of read DTOs.</returns>
+        public virtual async Task<DataResult<IEnumerable<TReadDto>>> ReadAllAsync()
+        {
+            var entities = await _repository.ReadAllAsync();
+            var readDto = _mapper.Map<IEnumerable<TReadDto>>(entities);
+            return Result.Success(readDto);
+        }
+
+        /// <summary>
+        /// Asynchronously deletes an entity by its identifier.
+        /// </summary>
+        /// <param name="id">The identifier of the entity to delete.</param>
+        /// <returns>A service message indicating success or failure.</returns>
+        public virtual async Task<Result> DeleteAsyncById(TId id)
+        {
+            TEntity? entity = await _repository.ReadByIdAsync(id);
+
+            if (entity is null)
+                return Result.Fail();
+
+            bool isDeleted = await _repository.DeleteAsync(entity);
+            return isDeleted ? Result.Success() : Result.Fail();
+        }
+
+        /// <summary>
+        /// Asynchronously checks if an entity with the specified identifier exists.
+        /// </summary>
+        /// <param name="id">The identifier of the entity to check.</param>
+        /// <returns>A Task that represents the asynchronous operation. The task result contains a boolean value indicating whether the entity exists.</returns>
+        public virtual async Task<bool> HasEntity(TId id) => await _repository.CountAsync(id) > 0;
+    }
+}

DigitalData.Core.Application/bin/Release/net7.0/DigitalData.Core.Application.deps.json

@@ -1,642 +0,0 @@
-{
-  "runtimeTarget": {
-    "name": ".NETCoreApp,Version=v7.0",
-    "signature": ""
-  },
-  "compilationOptions": {},
-  "targets": {
-    ".NETCoreApp,Version=v7.0": {
-      "DigitalData.Core.Application/1.0.0": {
-        "dependencies": {
-          "AutoMapper": "13.0.1",
-          "Microsoft.Extensions.Caching.Abstractions": "7.0.0",
-          "Microsoft.Extensions.Configuration": "7.0.0",
-          "Microsoft.Extensions.Logging": "7.0.0",
-          "System.DirectoryServices.AccountManagement": "7.0.1",
-          "System.IdentityModel.Tokens.Jwt": "7.5.1",
-          "System.Security.Cryptography.Cng": "5.0.0",
-          "WebCore.Contracts": "1.0.1",
-          "DigitalData.Core.Contracts": "1.0.1.0"
-        },
-        "runtime": {
-          "DigitalData.Core.Application.dll": {}
-        }
-      },
-      "AutoMapper/13.0.1": {
-        "dependencies": {
-          "Microsoft.Extensions.Options": "7.0.0"
-        },
-        "runtime": {
-          "lib/net6.0/AutoMapper.dll": {
-            "assemblyVersion": "13.0.0.0",
-            "fileVersion": "13.0.1.0"
-          }
-        }
-      },
-      "Microsoft.Extensions.Caching.Abstractions/7.0.0": {
-        "dependencies": {
-          "Microsoft.Extensions.Primitives": "7.0.0"
-        },
-        "runtime": {
-          "lib/net7.0/Microsoft.Extensions.Caching.Abstractions.dll": {
-            "assemblyVersion": "7.0.0.0",
-            "fileVersion": "7.0.22.51805"
-          }
-        }
-      },
-      "Microsoft.Extensions.Caching.Memory/7.0.0": {
-        "dependencies": {
-          "Microsoft.Extensions.Caching.Abstractions": "7.0.0",
-          "Microsoft.Extensions.DependencyInjection.Abstractions": "7.0.0",
-          "Microsoft.Extensions.Logging.Abstractions": "7.0.0",
-          "Microsoft.Extensions.Options": "7.0.0",
-          "Microsoft.Extensions.Primitives": "7.0.0"
-        },
-        "runtime": {
-          "lib/net7.0/Microsoft.Extensions.Caching.Memory.dll": {
-            "assemblyVersion": "7.0.0.0",
-            "fileVersion": "7.0.22.51805"
-          }
-        }
-      },
-      "Microsoft.Extensions.Configuration/7.0.0": {
-        "dependencies": {
-          "Microsoft.Extensions.Configuration.Abstractions": "7.0.0",
-          "Microsoft.Extensions.Primitives": "7.0.0"
-        },
-        "runtime": {
-          "lib/net7.0/Microsoft.Extensions.Configuration.dll": {
-            "assemblyVersion": "7.0.0.0",
-            "fileVersion": "7.0.22.51805"
-          }
-        }
-      },
-      "Microsoft.Extensions.Configuration.Abstractions/7.0.0": {
-        "dependencies": {
-          "Microsoft.Extensions.Primitives": "7.0.0"
-        },
-        "runtime": {
-          "lib/net7.0/Microsoft.Extensions.Configuration.Abstractions.dll": {
-            "assemblyVersion": "7.0.0.0",
-            "fileVersion": "7.0.22.51805"
-          }
-        }
-      },
-      "Microsoft.Extensions.Configuration.Binder/7.0.4": {
-        "dependencies": {
-          "Microsoft.Extensions.Configuration.Abstractions": "7.0.0"
-        },
-        "runtime": {
-          "lib/net7.0/Microsoft.Extensions.Configuration.Binder.dll": {
-            "assemblyVersion": "7.0.0.0",
-            "fileVersion": "7.0.423.11508"
-          }
-        }
-      },
-      "Microsoft.Extensions.DependencyInjection/7.0.0": {
-        "dependencies": {
-          "Microsoft.Extensions.DependencyInjection.Abstractions": "7.0.0"
-        },
-        "runtime": {
-          "lib/net7.0/Microsoft.Extensions.DependencyInjection.dll": {
-            "assemblyVersion": "7.0.0.0",
-            "fileVersion": "7.0.22.51805"
-          }
-        }
-      },
-      "Microsoft.Extensions.DependencyInjection.Abstractions/7.0.0": {
-        "runtime": {
-          "lib/net7.0/Microsoft.Extensions.DependencyInjection.Abstractions.dll": {
-            "assemblyVersion": "7.0.0.0",
-            "fileVersion": "7.0.22.51805"
-          }
-        }
-      },
-      "Microsoft.Extensions.Logging/7.0.0": {
-        "dependencies": {
-          "Microsoft.Extensions.DependencyInjection": "7.0.0",
-          "Microsoft.Extensions.DependencyInjection.Abstractions": "7.0.0",
-          "Microsoft.Extensions.Logging.Abstractions": "7.0.0",
-          "Microsoft.Extensions.Options": "7.0.0"
-        },
-        "runtime": {
-          "lib/net7.0/Microsoft.Extensions.Logging.dll": {
-            "assemblyVersion": "7.0.0.0",
-            "fileVersion": "7.0.22.51805"
-          }
-        }
-      },
-      "Microsoft.Extensions.Logging.Abstractions/7.0.0": {
-        "runtime": {
-          "lib/net7.0/Microsoft.Extensions.Logging.Abstractions.dll": {
-            "assemblyVersion": "7.0.0.0",
-            "fileVersion": "7.0.22.51805"
-          }
-        }
-      },
-      "Microsoft.Extensions.Options/7.0.0": {
-        "dependencies": {
-          "Microsoft.Extensions.DependencyInjection.Abstractions": "7.0.0",
-          "Microsoft.Extensions.Primitives": "7.0.0"
-        },
-        "runtime": {
-          "lib/net7.0/Microsoft.Extensions.Options.dll": {
-            "assemblyVersion": "7.0.0.0",
-            "fileVersion": "7.0.22.51805"
-          }
-        }
-      },
-      "Microsoft.Extensions.Primitives/7.0.0": {
-        "runtime": {
-          "lib/net7.0/Microsoft.Extensions.Primitives.dll": {
-            "assemblyVersion": "7.0.0.0",
-            "fileVersion": "7.0.22.51805"
-          }
-        }
-      },
-      "Microsoft.IdentityModel.Abstractions/7.5.1": {
-        "runtime": {
-          "lib/net6.0/Microsoft.IdentityModel.Abstractions.dll": {
-            "assemblyVersion": "7.5.1.0",
-            "fileVersion": "7.5.1.50405"
-          }
-        }
-      },
-      "Microsoft.IdentityModel.JsonWebTokens/7.5.1": {
-        "dependencies": {
-          "Microsoft.IdentityModel.Tokens": "7.5.1"
-        },
-        "runtime": {
-          "lib/net6.0/Microsoft.IdentityModel.JsonWebTokens.dll": {
-            "assemblyVersion": "7.5.1.0",
-            "fileVersion": "7.5.1.50405"
-          }
-        }
-      },
-      "Microsoft.IdentityModel.Logging/7.5.1": {
-        "dependencies": {
-          "Microsoft.IdentityModel.Abstractions": "7.5.1"
-        },
-        "runtime": {
-          "lib/net6.0/Microsoft.IdentityModel.Logging.dll": {
-            "assemblyVersion": "7.5.1.0",
-            "fileVersion": "7.5.1.50405"
-          }
-        }
-      },
-      "Microsoft.IdentityModel.Tokens/7.5.1": {
-        "dependencies": {
-          "Microsoft.IdentityModel.Logging": "7.5.1"
-        },
-        "runtime": {
-          "lib/net6.0/Microsoft.IdentityModel.Tokens.dll": {
-            "assemblyVersion": "7.5.1.0",
-            "fileVersion": "7.5.1.50405"
-          }
-        }
-      },
-      "Microsoft.Win32.SystemEvents/7.0.0": {
-        "runtime": {
-          "lib/net7.0/Microsoft.Win32.SystemEvents.dll": {
-            "assemblyVersion": "7.0.0.0",
-            "fileVersion": "7.0.22.51805"
-          }
-        },
-        "runtimeTargets": {
-          "runtimes/win/lib/net7.0/Microsoft.Win32.SystemEvents.dll": {
-            "rid": "win",
-            "assetType": "runtime",
-            "assemblyVersion": "7.0.0.0",
-            "fileVersion": "7.0.22.51805"
-          }
-        }
-      },
-      "System.Configuration.ConfigurationManager/7.0.0": {
-        "dependencies": {
-          "System.Diagnostics.EventLog": "7.0.0",
-          "System.Security.Cryptography.ProtectedData": "7.0.0",
-          "System.Security.Permissions": "7.0.0"
-        },
-        "runtime": {
-          "lib/net7.0/System.Configuration.ConfigurationManager.dll": {
-            "assemblyVersion": "7.0.0.0",
-            "fileVersion": "7.0.22.51805"
-          }
-        }
-      },
-      "System.Diagnostics.EventLog/7.0.0": {
-        "runtime": {
-          "lib/net7.0/System.Diagnostics.EventLog.dll": {
-            "assemblyVersion": "7.0.0.0",
-            "fileVersion": "7.0.22.51805"
-          }
-        },
-        "runtimeTargets": {
-          "runtimes/win/lib/net7.0/System.Diagnostics.EventLog.Messages.dll": {
-            "rid": "win",
-            "assetType": "runtime",
-            "assemblyVersion": "7.0.0.0",
-            "fileVersion": "0.0.0.0"
-          },
-          "runtimes/win/lib/net7.0/System.Diagnostics.EventLog.dll": {
-            "rid": "win",
-            "assetType": "runtime",
-            "assemblyVersion": "7.0.0.0",
-            "fileVersion": "7.0.22.51805"
-          }
-        }
-      },
-      "System.DirectoryServices/7.0.1": {
-        "dependencies": {
-          "System.Security.Permissions": "7.0.0"
-        },
-        "runtime": {
-          "lib/net7.0/System.DirectoryServices.dll": {
-            "assemblyVersion": "4.0.0.0",
-            "fileVersion": "7.0.323.6910"
-          }
-        },
-        "runtimeTargets": {
-          "runtimes/win/lib/net7.0/System.DirectoryServices.dll": {
-            "rid": "win",
-            "assetType": "runtime",
-            "assemblyVersion": "4.0.0.0",
-            "fileVersion": "7.0.323.6910"
-          }
-        }
-      },
-      "System.DirectoryServices.AccountManagement/7.0.1": {
-        "dependencies": {
-          "System.Configuration.ConfigurationManager": "7.0.0",
-          "System.DirectoryServices": "7.0.1",
-          "System.DirectoryServices.Protocols": "7.0.1"
-        },
-        "runtime": {
-          "lib/net7.0/System.DirectoryServices.AccountManagement.dll": {
-            "assemblyVersion": "4.0.0.0",
-            "fileVersion": "7.0.1123.42427"
-          }
-        },
-        "runtimeTargets": {
-          "runtimes/win/lib/net7.0/System.DirectoryServices.AccountManagement.dll": {
-            "rid": "win",
-            "assetType": "runtime",
-            "assemblyVersion": "4.0.0.0",
-            "fileVersion": "7.0.1123.42427"
-          }
-        }
-      },
-      "System.DirectoryServices.Protocols/7.0.1": {
-        "runtime": {
-          "lib/net7.0/System.DirectoryServices.Protocols.dll": {
-            "assemblyVersion": "7.0.0.1",
-            "fileVersion": "7.0.723.27404"
-          }
-        },
-        "runtimeTargets": {
-          "runtimes/linux/lib/net7.0/System.DirectoryServices.Protocols.dll": {
-            "rid": "linux",
-            "assetType": "runtime",
-            "assemblyVersion": "7.0.0.1",
-            "fileVersion": "7.0.723.27404"
-          },
-          "runtimes/osx/lib/net7.0/System.DirectoryServices.Protocols.dll": {
-            "rid": "osx",
-            "assetType": "runtime",
-            "assemblyVersion": "7.0.0.1",
-            "fileVersion": "7.0.723.27404"
-          },
-          "runtimes/win/lib/net7.0/System.DirectoryServices.Protocols.dll": {
-            "rid": "win",
-            "assetType": "runtime",
-            "assemblyVersion": "7.0.0.1",
-            "fileVersion": "7.0.723.27404"
-          }
-        }
-      },
-      "System.Drawing.Common/7.0.0": {
-        "dependencies": {
-          "Microsoft.Win32.SystemEvents": "7.0.0"
-        },
-        "runtime": {
-          "lib/net7.0/System.Drawing.Common.dll": {
-            "assemblyVersion": "7.0.0.0",
-            "fileVersion": "7.0.22.51805"
-          }
-        },
-        "runtimeTargets": {
-          "runtimes/win/lib/net7.0/System.Drawing.Common.dll": {
-            "rid": "win",
-            "assetType": "runtime",
-            "assemblyVersion": "7.0.0.0",
-            "fileVersion": "7.0.22.51805"
-          }
-        }
-      },
-      "System.Formats.Asn1/5.0.0": {},
-      "System.IdentityModel.Tokens.Jwt/7.5.1": {
-        "dependencies": {
-          "Microsoft.IdentityModel.JsonWebTokens": "7.5.1",
-          "Microsoft.IdentityModel.Tokens": "7.5.1"
-        },
-        "runtime": {
-          "lib/net6.0/System.IdentityModel.Tokens.Jwt.dll": {
-            "assemblyVersion": "7.5.1.0",
-            "fileVersion": "7.5.1.50405"
-          }
-        }
-      },
-      "System.Security.Cryptography.Cng/5.0.0": {
-        "dependencies": {
-          "System.Formats.Asn1": "5.0.0"
-        }
-      },
-      "System.Security.Cryptography.ProtectedData/7.0.0": {
-        "runtime": {
-          "lib/net7.0/System.Security.Cryptography.ProtectedData.dll": {
-            "assemblyVersion": "7.0.0.0",
-            "fileVersion": "7.0.22.51805"
-          }
-        },
-        "runtimeTargets": {
-          "runtimes/win/lib/net7.0/System.Security.Cryptography.ProtectedData.dll": {
-            "rid": "win",
-            "assetType": "runtime",
-            "assemblyVersion": "7.0.0.0",
-            "fileVersion": "7.0.22.51805"
-          }
-        }
-      },
-      "System.Security.Permissions/7.0.0": {
-        "dependencies": {
-          "System.Windows.Extensions": "7.0.0"
-        },
-        "runtime": {
-          "lib/net7.0/System.Security.Permissions.dll": {
-            "assemblyVersion": "7.0.0.0",
-            "fileVersion": "7.0.22.51805"
-          }
-        }
-      },
-      "System.Windows.Extensions/7.0.0": {
-        "dependencies": {
-          "System.Drawing.Common": "7.0.0"
-        },
-        "runtime": {
-          "lib/net7.0/System.Windows.Extensions.dll": {
-            "assemblyVersion": "7.0.0.0",
-            "fileVersion": "7.0.22.51805"
-          }
-        },
-        "runtimeTargets": {
-          "runtimes/win/lib/net7.0/System.Windows.Extensions.dll": {
-            "rid": "win",
-            "assetType": "runtime",
-            "assemblyVersion": "7.0.0.0",
-            "fileVersion": "7.0.22.51805"
-          }
-        }
-      },
-      "WebCore.Contracts/1.0.1": {
-        "dependencies": {
-          "Microsoft.Extensions.Caching.Memory": "7.0.0",
-          "Microsoft.Extensions.Configuration.Binder": "7.0.4",
-          "System.DirectoryServices": "7.0.1",
-          "System.DirectoryServices.AccountManagement": "7.0.1",
-          "System.IdentityModel.Tokens.Jwt": "7.5.1"
-        },
-        "runtime": {
-          "DigitalData.Core.Contracts.dll": {}
-        }
-      },
-      "DigitalData.Core.Contracts/1.0.1.0": {
-        "runtime": {
-          "DigitalData.Core.Contracts.dll": {
-            "assemblyVersion": "1.0.1.0",
-            "fileVersion": "1.0.1.0"
-          }
-        }
-      }
-    }
-  },
-  "libraries": {
-    "DigitalData.Core.Application/1.0.0": {
-      "type": "project",
-      "serviceable": false,
-      "sha512": ""
-    },
-    "AutoMapper/13.0.1": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-/Fx1SbJ16qS7dU4i604Sle+U9VLX+WSNVJggk6MupKVkYvvBm4XqYaeFuf67diHefHKHs50uQIS2YEDFhPCakQ==",
-      "path": "automapper/13.0.1",
-      "hashPath": "automapper.13.0.1.nupkg.sha512"
-    },
-    "Microsoft.Extensions.Caching.Abstractions/7.0.0": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-IeimUd0TNbhB4ded3AbgBLQv2SnsiVugDyGV1MvspQFVlA07nDC7Zul7kcwH5jWN3JiTcp/ySE83AIJo8yfKjg==",
-      "path": "microsoft.extensions.caching.abstractions/7.0.0",
-      "hashPath": "microsoft.extensions.caching.abstractions.7.0.0.nupkg.sha512"
-    },
-    "Microsoft.Extensions.Caching.Memory/7.0.0": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-xpidBs2KCE2gw1JrD0quHE72kvCaI3xFql5/Peb2GRtUuZX+dYPoK/NTdVMiM67Svym0M0Df9A3xyU0FbMQhHw==",
-      "path": "microsoft.extensions.caching.memory/7.0.0",
-      "hashPath": "microsoft.extensions.caching.memory.7.0.0.nupkg.sha512"
-    },
-    "Microsoft.Extensions.Configuration/7.0.0": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-tldQUBWt/xeH2K7/hMPPo5g8zuLc3Ro9I5d4o/XrxvxOCA2EZBtW7bCHHTc49fcBtvB8tLAb/Qsmfrq+2SJ4vA==",
-      "path": "microsoft.extensions.configuration/7.0.0",
-      "hashPath": "microsoft.extensions.configuration.7.0.0.nupkg.sha512"
-    },
-    "Microsoft.Extensions.Configuration.Abstractions/7.0.0": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-f34u2eaqIjNO9YLHBz8rozVZ+TcFiFs0F3r7nUJd7FRkVSxk8u4OpoK226mi49MwexHOR2ibP9MFvRUaLilcQQ==",
-      "path": "microsoft.extensions.configuration.abstractions/7.0.0",
-      "hashPath": "microsoft.extensions.configuration.abstractions.7.0.0.nupkg.sha512"
-    },
-    "Microsoft.Extensions.Configuration.Binder/7.0.4": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-8+XPvJnHZsYgHOQlcMuQe7QNF5KdVKHH1F/wW3nd8/u81Gk/XFAYMDP0Lpz18h7/AM95M662vvqMorcYxCBB4w==",
-      "path": "microsoft.extensions.configuration.binder/7.0.4",
-      "hashPath": "microsoft.extensions.configuration.binder.7.0.4.nupkg.sha512"
-    },
-    "Microsoft.Extensions.DependencyInjection/7.0.0": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-elNeOmkeX3eDVG6pYVeV82p29hr+UKDaBhrZyWvWLw/EVZSYEkZlQdkp0V39k/Xehs2Qa0mvoCvkVj3eQxNQ1Q==",
-      "path": "microsoft.extensions.dependencyinjection/7.0.0",
-      "hashPath": "microsoft.extensions.dependencyinjection.7.0.0.nupkg.sha512"
-    },
-    "Microsoft.Extensions.DependencyInjection.Abstractions/7.0.0": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-h3j/QfmFN4S0w4C2A6X7arXij/M/OVw3uQHSOFxnND4DyAzO1F9eMX7Eti7lU/OkSthEE0WzRsfT/Dmx86jzCw==",
-      "path": "microsoft.extensions.dependencyinjection.abstractions/7.0.0",
-      "hashPath": "microsoft.extensions.dependencyinjection.abstractions.7.0.0.nupkg.sha512"
-    },
-    "Microsoft.Extensions.Logging/7.0.0": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-Nw2muoNrOG5U5qa2ZekXwudUn2BJcD41e65zwmDHb1fQegTX66UokLWZkJRpqSSHXDOWZ5V0iqhbxOEky91atA==",
-      "path": "microsoft.extensions.logging/7.0.0",
-      "hashPath": "microsoft.extensions.logging.7.0.0.nupkg.sha512"
-    },
-    "Microsoft.Extensions.Logging.Abstractions/7.0.0": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-kmn78+LPVMOWeITUjIlfxUPDsI0R6G0RkeAMBmQxAJ7vBJn4q2dTva7pWi65ceN5vPGjJ9q/Uae2WKgvfktJAw==",
-      "path": "microsoft.extensions.logging.abstractions/7.0.0",
-      "hashPath": "microsoft.extensions.logging.abstractions.7.0.0.nupkg.sha512"
-    },
-    "Microsoft.Extensions.Options/7.0.0": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-lP1yBnTTU42cKpMozuafbvNtQ7QcBjr/CcK3bYOGEMH55Fjt+iecXjT6chR7vbgCMqy3PG3aNQSZgo/EuY/9qQ==",
-      "path": "microsoft.extensions.options/7.0.0",
-      "hashPath": "microsoft.extensions.options.7.0.0.nupkg.sha512"
-    },
-    "Microsoft.Extensions.Primitives/7.0.0": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-um1KU5kxcRp3CNuI8o/GrZtD4AIOXDk+RLsytjZ9QPok3ttLUelLKpilVPuaFT3TFjOhSibUAso0odbOaCDj3Q==",
-      "path": "microsoft.extensions.primitives/7.0.0",
-      "hashPath": "microsoft.extensions.primitives.7.0.0.nupkg.sha512"
-    },
-    "Microsoft.IdentityModel.Abstractions/7.5.1": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-PT16ZFbPIiMsYv07oy3zOjqUOJ7xutGBkJTOX0+IbNyU6+O6X7aIxjq9EaSSRLWbekRgamgtmfg8Xjw6A6Ua9g==",
-      "path": "microsoft.identitymodel.abstractions/7.5.1",
-      "hashPath": "microsoft.identitymodel.abstractions.7.5.1.nupkg.sha512"
-    },
-    "Microsoft.IdentityModel.JsonWebTokens/7.5.1": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-93CGSa8RPdZU8zfvA3nf9NGKUqEnQrE12VzYlMqKh72ddhzusosqLNEUgH/YhFWBLRFOnY1RCgHMV7pR+sAx2w==",
-      "path": "microsoft.identitymodel.jsonwebtokens/7.5.1",
-      "hashPath": "microsoft.identitymodel.jsonwebtokens.7.5.1.nupkg.sha512"
-    },
-    "Microsoft.IdentityModel.Logging/7.5.1": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-PnpAQX20BAiDIPYmWUyQSlEaWD8BLXzHpiDGTCT568Cs0ReOeyzNe401LzCeiv6ilug/KefVeV1CeqtCHTo8dw==",
-      "path": "microsoft.identitymodel.logging/7.5.1",
-      "hashPath": "microsoft.identitymodel.logging.7.5.1.nupkg.sha512"
-    },
-    "Microsoft.IdentityModel.Tokens/7.5.1": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-Q3DKpyFViP84IUlTFKH/zIkswIrmSh2Vd/eFDo4wlOHy4DYxoweZEEw4kDEiKt9VCX6o7SddK3HK2xDYyFpexA==",
-      "path": "microsoft.identitymodel.tokens/7.5.1",
-      "hashPath": "microsoft.identitymodel.tokens.7.5.1.nupkg.sha512"
-    },
-    "Microsoft.Win32.SystemEvents/7.0.0": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-2nXPrhdAyAzir0gLl8Yy8S5Mnm/uBSQQA7jEsILOS1MTyS7DbmV1NgViMtvV1sfCD1ebITpNwb1NIinKeJgUVQ==",
-      "path": "microsoft.win32.systemevents/7.0.0",
-      "hashPath": "microsoft.win32.systemevents.7.0.0.nupkg.sha512"
-    },
-    "System.Configuration.ConfigurationManager/7.0.0": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-WvRUdlL1lB0dTRZSs5XcQOd5q9MYNk90GkbmRmiCvRHThWiojkpGqWdmEDJdXyHbxG/BhE5hmVbMfRLXW9FJVA==",
-      "path": "system.configuration.configurationmanager/7.0.0",
-      "hashPath": "system.configuration.configurationmanager.7.0.0.nupkg.sha512"
-    },
-    "System.Diagnostics.EventLog/7.0.0": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-eUDP47obqQm3SFJfP6z+Fx2nJ4KKTQbXB4Q9Uesnzw9SbYdhjyoGXuvDn/gEmFY6N5Z3bFFbpAQGA7m6hrYJCw==",
-      "path": "system.diagnostics.eventlog/7.0.0",
-      "hashPath": "system.diagnostics.eventlog.7.0.0.nupkg.sha512"
-    },
-    "System.DirectoryServices/7.0.1": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-Z4FVdUJEVXbf7/f/hU6cFZDtxN5ozUVKJMzXoHmC+GCeTcqzlxqmWtxurejxG3K+kZ6H0UKwNshoK1CYnmJ1sg==",
-      "path": "system.directoryservices/7.0.1",
-      "hashPath": "system.directoryservices.7.0.1.nupkg.sha512"
-    },
-    "System.DirectoryServices.AccountManagement/7.0.1": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-UNytHYwA5IF55WQhashsMG57ize83JUGJxD8YJlOyO9ZlMTOD4Nt7y+A6mvmrU/swDoYWaVL+TNwE6hk9lyvbA==",
-      "path": "system.directoryservices.accountmanagement/7.0.1",
-      "hashPath": "system.directoryservices.accountmanagement.7.0.1.nupkg.sha512"
-    },
-    "System.DirectoryServices.Protocols/7.0.1": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-t9hsL+UYRzNs30pnT2Tdx6ngX8McFUjru0a0ekNgu/YXfkXN+dx5OvSEv0/p7H2q3pdJLH7TJPWX7e55J8QB9A==",
-      "path": "system.directoryservices.protocols/7.0.1",
-      "hashPath": "system.directoryservices.protocols.7.0.1.nupkg.sha512"
-    },
-    "System.Drawing.Common/7.0.0": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-KIX+oBU38pxkKPxvLcLfIkOV5Ien8ReN78wro7OF5/erwcmortzeFx+iBswlh2Vz6gVne0khocQudGwaO1Ey6A==",
-      "path": "system.drawing.common/7.0.0",
-      "hashPath": "system.drawing.common.7.0.0.nupkg.sha512"
-    },
-    "System.Formats.Asn1/5.0.0": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-MTvUIktmemNB+El0Fgw9egyqT9AYSIk6DTJeoDSpc3GIHxHCMo8COqkWT1mptX5tZ1SlQ6HJZ0OsSvMth1c12w==",
-      "path": "system.formats.asn1/5.0.0",
-      "hashPath": "system.formats.asn1.5.0.0.nupkg.sha512"
-    },
-    "System.IdentityModel.Tokens.Jwt/7.5.1": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-UUw+E0R73lZLlXgneYIJQxNs1kfbcxjVzw64JQyiwjqCd4HMpAbjn+xRo86QZT84uHq8/MkqvfH82tgjgPzpuw==",
-      "path": "system.identitymodel.tokens.jwt/7.5.1",
-      "hashPath": "system.identitymodel.tokens.jwt.7.5.1.nupkg.sha512"
-    },
-    "System.Security.Cryptography.Cng/5.0.0": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-jIMXsKn94T9JY7PvPq/tMfqa6GAaHpElRDpmG+SuL+D3+sTw2M8VhnibKnN8Tq+4JqbPJ/f+BwtLeDMEnzAvRg==",
-      "path": "system.security.cryptography.cng/5.0.0",
-      "hashPath": "system.security.cryptography.cng.5.0.0.nupkg.sha512"
-    },
-    "System.Security.Cryptography.ProtectedData/7.0.0": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-xSPiLNlHT6wAHtugASbKAJwV5GVqQK351crnILAucUioFqqieDN79evO1rku1ckt/GfjIn+b17UaSskoY03JuA==",
-      "path": "system.security.cryptography.protecteddata/7.0.0",
-      "hashPath": "system.security.cryptography.protecteddata.7.0.0.nupkg.sha512"
-    },
-    "System.Security.Permissions/7.0.0": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-Vmp0iRmCEno9BWiskOW5pxJ3d9n+jUqKxvX4GhLwFhnQaySZmBN2FuC0N5gjFHgyFMUjC5sfIJ8KZfoJwkcMmA==",
-      "path": "system.security.permissions/7.0.0",
-      "hashPath": "system.security.permissions.7.0.0.nupkg.sha512"
-    },
-    "System.Windows.Extensions/7.0.0": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-bR4qdCmssMMbo9Fatci49An5B1UaVJZHKNq70PRgzoLYIlitb8Tj7ns/Xt5Pz1CkERiTjcVBDU2y1AVrPBYkaw==",
-      "path": "system.windows.extensions/7.0.0",
-      "hashPath": "system.windows.extensions.7.0.0.nupkg.sha512"
-    },
-    "WebCore.Contracts/1.0.1": {
-      "type": "project",
-      "serviceable": false,
-      "sha512": ""
-    },
-    "DigitalData.Core.Contracts/1.0.1.0": {
-      "type": "reference",
-      "serviceable": false,
-      "sha512": ""
-    }
-  }
-}

DigitalData.Core.Application/obj/DigitalData.Core.Application.csproj.nuget.g.targets

@@ -1,6 +1,9 @@
 <?xml version="1.0" encoding="utf-8" standalone="no"?>
 <Project ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ImportGroup Condition=" '$(ExcludeRestorePackageImports)' != 'true' ">
+  <ImportGroup Condition=" '$(TargetFramework)' == 'net7.0' AND '$(ExcludeRestorePackageImports)' != 'true' ">
+    <Import Project="$(NuGetPackageRoot)microsoft.extensions.logging.abstractions\7.0.0\buildTransitive\net6.0\Microsoft.Extensions.Logging.Abstractions.targets" Condition="Exists('$(NuGetPackageRoot)microsoft.extensions.logging.abstractions\7.0.0\buildTransitive\net6.0\Microsoft.Extensions.Logging.Abstractions.targets')" />
+  </ImportGroup>
+  <ImportGroup Condition=" '$(TargetFramework)' == 'net8.0' AND '$(ExcludeRestorePackageImports)' != 'true' ">
     <Import Project="$(NuGetPackageRoot)microsoft.extensions.logging.abstractions\7.0.0\buildTransitive\net6.0\Microsoft.Extensions.Logging.Abstractions.targets" Condition="Exists('$(NuGetPackageRoot)microsoft.extensions.logging.abstractions\7.0.0\buildTransitive\net6.0\Microsoft.Extensions.Logging.Abstractions.targets')" />
   </ImportGroup>
 </Project>

DigitalData.Core.Application/obj/Release/DigitalData.Core.Application.1.0.0.nuspec

@@ -1,25 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>DigitalData.Core.Application</id>
-    <version>1.0.0</version>
-    <authors>DigitalData.Core.Application</authors>
-    <description>Package Description</description>
-    <repository type="git" commit="82da3586a5e28ae5fbd4242f05f60f9e5327e5f2" />
-    <dependencies>
-      <group targetFramework="net7.0">
-        <dependency id="WebCore.Contracts" version="1.0.1" exclude="Build,Analyzers" />
-        <dependency id="AutoMapper" version="13.0.1" exclude="Build,Analyzers" />
-        <dependency id="Microsoft.Extensions.Caching.Abstractions" version="7.0.0" exclude="Build,Analyzers" />
-        <dependency id="Microsoft.Extensions.Configuration" version="7.0.0" exclude="Build,Analyzers" />
-        <dependency id="Microsoft.Extensions.Logging" version="7.0.0" exclude="Build,Analyzers" />
-        <dependency id="System.DirectoryServices.AccountManagement" version="7.0.1" exclude="Build,Analyzers" />
-        <dependency id="System.IdentityModel.Tokens.Jwt" version="7.5.1" exclude="Build,Analyzers" />
-        <dependency id="System.Security.Cryptography.Cng" version="5.0.0" exclude="Build,Analyzers" />
-      </group>
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="E:\TekH\Visual Studio\WebCoreModules\DigitalData.Core.Application\bin\Release\net7.0\DigitalData.Core.Application.dll" target="lib\net7.0\DigitalData.Core.Application.dll" />
-  </files>
-</package>

DigitalData.Core.Application/obj/Release/net7.0/DigitalData.Core.Application.AssemblyInfo.cs

@@ -1,22 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by a tool.
-//
-//     Changes to this file may cause incorrect behavior and will be lost if
-//     the code is regenerated.
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-using System;
-using System.Reflection;
-
-[assembly: System.Reflection.AssemblyCompanyAttribute("DigitalData.Core.Application")]
-[assembly: System.Reflection.AssemblyConfigurationAttribute("Release")]
-[assembly: System.Reflection.AssemblyFileVersionAttribute("1.0.0.0")]
-[assembly: System.Reflection.AssemblyInformationalVersionAttribute("1.0.0+82da3586a5e28ae5fbd4242f05f60f9e5327e5f2")]
-[assembly: System.Reflection.AssemblyProductAttribute("DigitalData.Core.Application")]
-[assembly: System.Reflection.AssemblyTitleAttribute("DigitalData.Core.Application")]
-[assembly: System.Reflection.AssemblyVersionAttribute("1.0.0.0")]
-
-// Generated by the MSBuild WriteCodeFragment class.
-

DigitalData.Core.Application/obj/Release/net7.0/DigitalData.Core.Application.AssemblyInfoInputs.cache

@@ -1 +0,0 @@
-7fd24cdeb8bda1c95d6354d38f1aa5d605dcfbd4182684332a8fe63df25f10bc

DigitalData.Core.Application/obj/Release/net7.0/DigitalData.Core.Application.csproj.CoreCompileInputs.cache

@@ -1 +0,0 @@
-efb6a18662ffe4848a4883610b82bf9126376ab578f7a4cd62a1b8c356d18bc4

DigitalData.Core.Application/obj/Release/net7.0/DigitalData.Core.Application.csproj.FileListAbsolute.txt

@@ -1,16 +0,0 @@
-E:\TekH\Visual Studio\WebCoreModules\DigitalData.Core.Application\bin\Release\net7.0\DigitalData.Core.Application.deps.json
-E:\TekH\Visual Studio\WebCoreModules\DigitalData.Core.Application\bin\Release\net7.0\DigitalData.Core.Application.dll
-E:\TekH\Visual Studio\WebCoreModules\DigitalData.Core.Application\bin\Release\net7.0\DigitalData.Core.Application.pdb
-E:\TekH\Visual Studio\WebCoreModules\DigitalData.Core.Application\bin\Release\net7.0\DigitalData.Core.Contracts.dll
-E:\TekH\Visual Studio\WebCoreModules\DigitalData.Core.Application\bin\Release\net7.0\DigitalData.Core.Contracts.pdb
-E:\TekH\Visual Studio\WebCoreModules\DigitalData.Core.Application\obj\Release\net7.0\DigitalData.Core.Application.csproj.AssemblyReference.cache
-E:\TekH\Visual Studio\WebCoreModules\DigitalData.Core.Application\obj\Release\net7.0\DigitalData.Core.Application.GeneratedMSBuildEditorConfig.editorconfig
-E:\TekH\Visual Studio\WebCoreModules\DigitalData.Core.Application\obj\Release\net7.0\DigitalData.Core.Application.AssemblyInfoInputs.cache
-E:\TekH\Visual Studio\WebCoreModules\DigitalData.Core.Application\obj\Release\net7.0\DigitalData.Core.Application.AssemblyInfo.cs
-E:\TekH\Visual Studio\WebCoreModules\DigitalData.Core.Application\obj\Release\net7.0\DigitalData.Core.Application.csproj.CoreCompileInputs.cache
-E:\TekH\Visual Studio\WebCoreModules\DigitalData.Core.Application\obj\Release\net7.0\DigitalD.553292A0.Up2Date
-E:\TekH\Visual Studio\WebCoreModules\DigitalData.Core.Application\obj\Release\net7.0\DigitalData.Core.Application.dll
-E:\TekH\Visual Studio\WebCoreModules\DigitalData.Core.Application\obj\Release\net7.0\refint\DigitalData.Core.Application.dll
-E:\TekH\Visual Studio\WebCoreModules\DigitalData.Core.Application\obj\Release\net7.0\DigitalData.Core.Application.pdb
-E:\TekH\Visual Studio\WebCoreModules\DigitalData.Core.Application\obj\Release\net7.0\ref\DigitalData.Core.Application.dll
-E:\TekH\Visual Studio\WebCoreModules\DigitalData.Core.Application\bin\Release\net7.0\icon.png

DigitalData.Core.Client/BaseHttpClientService.cs

@@ -0,0 +1,147 @@
+using DigitalData.Core.Abstractions.Client;
+using System.Diagnostics.CodeAnalysis;
+using System.Net;
+using System.Web;
+
+namespace DigitalData.Core.Client
+{
+    public class BaseHttpClientService : IBaseHttpClientService
+    {
+        protected readonly HttpClient _client;
+        protected readonly CookieContainer _cookies;
+
+        [StringSyntax("Uri")]
+        protected readonly string _uri;
+
+        protected readonly string _path;
+
+        protected IEnumerable<KeyValuePair<string, object>>? _headers;
+
+        protected IEnumerable<KeyValuePair<string, object?>>? _queryParams;
+
+        internal BaseHttpClientService(HttpClient client, CookieContainer cookieContainer, IHttpClientOptions clientOptions)
+        {
+            _client = client;
+            _cookies = cookieContainer;
+            _uri = clientOptions.Uri.Trim(URI_TRIM_CHARS);
+            _path = clientOptions.Path?.Trim(URI_TRIM_CHARS) ?? string.Empty;
+            _headers = clientOptions.Headers;
+            _queryParams = clientOptions.QueryParams;
+        }
+
+        public CookieCollection GetCookies(string path = "") => _cookies.GetCookies(uri: new Uri(UriCombine(_uri, path, path.Trim(URI_TRIM_CHARS))));
+
+        public async Task<HttpResponseMessage> FetchAsync(
+            string? scheme = null,
+            int? port = null,
+            string path = "",
+            IEnumerable<KeyValuePair<string, object?>>? queryParams = null,
+            HttpMethod? method = null,
+            HttpContent? body = null,
+            IEnumerable<KeyValuePair<string, object>>? form = null,
+            IEnumerable<KeyValuePair<string, object>>? headers = null,
+            bool sendWithCookie = true,
+            bool saveCookie = true
+        )
+        {
+            // merge with default headers
+            if(_headers is not null)
+            {
+                if (headers is null)
+                    headers = _headers;
+                else
+                {
+                    var mergedHeaders = headers.ToList();
+                    mergedHeaders.AddRange(_headers);
+                    headers = mergedHeaders;
+                }
+            }
+
+            // Add default query parameters
+            if(_queryParams is not null)
+            {
+                if (queryParams is null)
+                    queryParams = _queryParams;
+                else
+                {
+                    var mergedQueryParams = queryParams.ToList();
+                    mergedQueryParams.AddRange(_queryParams);
+                    queryParams = mergedQueryParams;
+                }
+            }
+
+            // set default HTTP method as GET
+            method ??= HttpMethod.Get;
+
+            // create URL
+            var uriBuilder = new UriBuilder(_uri);
+            if (scheme is not null)
+                uriBuilder.Scheme = scheme;
+            if (port is int portInt)
+                uriBuilder.Port = portInt;
+            uriBuilder.Path = UriCombine(_path, path?.Trim(URI_TRIM_CHARS) ?? string.Empty);
+
+            // Add query parameters if provided
+            if (queryParams?.Any() ?? false)
+            {
+                var query = HttpUtility.ParseQueryString(uriBuilder.Query);
+
+                var flagParams = queryParams.Where(param => param.Value is null).Select(param => param.Key);
+
+                var valueParams = queryParams.Where(param => param.Value is not null);
+
+                foreach (var param in valueParams)
+                    query[param.Key] = param.Value switch
+                    {
+                        bool b => b.ToString().ToLower(),
+                        _ => param.Value.ToString()
+                    };
+
+                if (flagParams.Any())
+                    uriBuilder.Query = string.Join(QUERY_SEPARATOR, query.ToString(), string.Join(QUERY_SEPARATOR, flagParams));
+                else uriBuilder.Query = query.ToString();
+            }
+
+            var requestUri = uriBuilder.Uri;
+            
+            var requestMessage = new HttpRequestMessage(method, requestUri);
+
+            // Add headers if provided
+            headers?.ForEach(header => requestMessage.Headers.Add(header.Key, header.Value.ToString()));
+
+            // Add cookie to request
+            if (sendWithCookie)
+            {
+                var cookieHeader = _cookies.GetCookieHeader(requestUri);
+                if (!string.IsNullOrWhiteSpace(cookieHeader))
+                {
+                    requestMessage.Headers.Add("Cookie", cookieHeader);
+                }
+            }
+
+            // Add body content if provided
+            if (body != null && form != null)
+                throw new InvalidOperationException("Body content and form data cannot both be set.");
+            else if (body != null)
+                requestMessage.Content = body;
+            else if (form != null)
+                requestMessage.Content = new FormUrlEncodedContent(form.Select(e => KeyValuePair.Create(e.Key, e.Value.ToString())));
+
+            var response = await _client.SendAsync(requestMessage);
+
+            // Add response cookies to cookies
+            if (saveCookie)
+                if (response.Headers.TryGetValues("Set-Cookie", out var cookies))
+                    foreach (var cookie in cookies)
+                        _cookies.SetCookies(requestUri, cookie);
+
+            return response;
+        }
+
+        internal static readonly char[] URI_TRIM_CHARS = { '\\', '/', ' ' };
+
+        internal static string UriCombine(params string[] paths) => System.IO.Path.Combine(paths).Replace("\\", "/");
+
+        internal static readonly char QUERY_SEPARATOR = '&';
+    }
+}

DigitalData.Core.Client/DIExtensions.cs

@@ -0,0 +1,36 @@
+using DigitalData.Core.Abstractions.Client;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection.Extensions;
+using Microsoft.Extensions.Options;
+using System.Net;
+
+namespace DigitalData.Core.Client
+{
+    public static class DIExtensions
+    {
+        internal static IServiceCollection AddHttpClientServiceDefaults(this IServiceCollection services)
+        {
+            services.TryAddSingleton<HttpClient>();
+            services.TryAddSingleton<CookieContainer>();
+            return services;
+        }
+
+        public static IServiceCollection AddHttpClientService<THttpClientOptions>(this IServiceCollection services, IConfigurationSection section)
+            where THttpClientOptions : class, IHttpClientOptions
+        {
+            services.AddHttpClientServiceDefaults();            
+            services.TryAddSingleton<IHttpClientService<THttpClientOptions>, HttpClientService<THttpClientOptions>>();
+            return services.Configure<THttpClientOptions>(section);
+        }
+
+        public static IServiceCollection AddHttpClientService<THttpClientOptions>(this IServiceCollection services, THttpClientOptions options)
+            where THttpClientOptions : class, IHttpClientOptions
+        {
+            services.AddHttpClientServiceDefaults();
+            services.TryAddSingleton<IHttpClientService<THttpClientOptions>, HttpClientService<THttpClientOptions>>();
+            services.TryAddSingleton(Options.Create(options));
+            return services;
+        }
+    }
+}

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

@@ -0,0 +1,47 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFrameworks>net7.0;net8.0</TargetFrameworks>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <Description>This package provides HTTP client extension methods for the DigitalData.Core library, offering simplified and asynchronous methods for fetching and handling HTTP responses. It includes utility methods for sending GET requests, reading response content as text or JSON, and deserializing JSON into dynamic or strongly-typed objects using Newtonsoft.Json. These extensions facilitate efficient and easy-to-read HTTP interactions in client applications.</Description>
+    <PackageId>DigitalData.Core.Client</PackageId>
+    <Version>2.0.3</Version>
+    <Authors>Digital Data GmbH</Authors>
+    <Company>Digital Data GmbH</Company>
+    <Product>Digital Data GmbH</Product>
+    <Copyright>Copyright 2024</Copyright>
+    <PackageProjectUrl></PackageProjectUrl>
+    <PackageIcon>core_icon.png</PackageIcon>
+    <RepositoryUrl>http://git.dd:3000/AppStd/WebCoreModules.git</RepositoryUrl>
+    <PackageTags>digital data core http client json serilization</PackageTags>
+    <AssemblyVersion>2.0.3</AssemblyVersion>
+    <FileVersion>2.0.3</FileVersion>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <None Include="..\..\nuget-package-icons\core_icon.png">
+      <Pack>True</Pack>
+      <PackagePath>\</PackagePath>
+    </None>
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="7.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Options" Version="7.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Options.ConfigurationExtensions" Version="7.0.0" />
+    <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\DigitalData.Core.Abstractions\DigitalData.Core.Abstractions.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Update="Assets\icon.png">
+      <PackagePath>\</PackagePath>
+      <Pack>True</Pack>
+    </None>
+  </ItemGroup>
+
+</Project>

DigitalData.Core.Client/HttpClientService.cs

@@ -0,0 +1,14 @@
+using DigitalData.Core.Abstractions.Client;
+using Microsoft.Extensions.Options;
+using System.Net;
+
+namespace DigitalData.Core.Client
+{
+    public class HttpClientService<TClientOptions> : BaseHttpClientService, IHttpClientService<TClientOptions>, IBaseHttpClientService
+        where TClientOptions : class, IHttpClientOptions
+    {
+        public HttpClientService(HttpClient client, CookieContainer cookieContainer, IOptions<TClientOptions> clientOptions) : base(client, cookieContainer, clientOptions.Value)
+        {
+        }
+    }
+}

DigitalData.Core.Client/HttpExtensions.cs

@@ -0,0 +1,100 @@
+using Newtonsoft.Json;
+using System.Net.Http.Json;
+
+namespace DigitalData.Core.Client
+{
+    /// <summary>
+    /// Extension methods for HttpClient and HttpResponseMessage.
+    /// </summary>
+    public static class HttpExtensions
+    {
+        /// <summary>
+        /// Reads the content of the HTTP response message as a string.
+        /// </summary>
+        /// <param name="response">The HTTP response message.</param>
+        /// <returns>A task representing the response content as a string.</returns>
+        public static async Task<string> Text(this HttpResponseMessage response) => await response.Content.ReadAsStringAsync();
+
+        /// <summary>
+        /// Reads the content of the HTTP response message and deserializes it to a specified type.
+        /// </summary>
+        /// <typeparam name="T">The type to deserialize the response content to.</typeparam>
+        /// <param name="response">The HTTP response message.</param>
+        /// <returns>A task representing the deserialized response content.</returns>
+        public static async Task<T?> Json<T>(this HttpResponseMessage response) => await response.Content.ReadFromJsonAsync<T>();
+
+        /// <summary>
+        /// Reads the content of the HTTP response message and deserializes it to a dynamic object.
+        /// </summary>
+        /// <param name="response">The HTTP response message.</param>
+        /// <returns>A task representing the deserialized response content as a dynamic object.</returns>
+        public static async Task<dynamic> Json(this HttpResponseMessage response)
+        {
+            string json = await response.Content.ReadAsStringAsync();
+            return JsonConvert.DeserializeObject<dynamic>(json) ?? string.Empty;
+        }
+
+        /// <summary>
+        /// Reads the content of the HTTP response message and deserializes it to a list of dynamic objects.
+        /// </summary>
+        /// <param name="response">The HTTP response message.</param>
+        /// <returns>A task representing the deserialized response content as a list of dynamic objects.</returns>
+        public static async Task<IEnumerable<dynamic>> JsonList(this HttpResponseMessage response)
+        {
+            string json = await response.Content.ReadAsStringAsync();
+            return JsonConvert.DeserializeObject<dynamic>(json) ?? string.Empty;
+        }
+
+        /// <summary>
+        /// Executes an action when a task is completed.
+        /// </summary>
+        /// <typeparam name="T">The type of the task result.</typeparam>
+        /// <param name="task">The task to await.</param>
+        /// <param name="toDo">The action to execute when the task is completed.</param>
+        public static async void ThenAsync<T>(this Task<T> task, Action<T> toDo)
+        {
+            var then = await task;
+            toDo(then);
+        }
+
+        /// <summary>
+        /// Executes a function when a task is completed and returns the result.
+        /// </summary>
+        /// <typeparam name="T">The type of the task result.</typeparam>
+        /// <typeparam name="I">The return type of the function.</typeparam>
+        /// <param name="task">The task to await.</param>
+        /// <param name="toDo">The function to execute when the task is completed.</param>
+        /// <returns>A task representing the result of the function.</returns>
+        public static async Task<I> ThenAsync<T, I>(this Task<T> task, Func<T, I> toDo)
+        {
+            var then = await task;
+            return toDo(then);
+        }
+
+        /// <summary>
+        /// Executes an asynchronous function when a task is completed and returns the result.
+        /// </summary>
+        /// <typeparam name="T">The type of the task result.</typeparam>
+        /// <typeparam name="I">The return type of the asynchronous function.</typeparam>
+        /// <param name="task">The task to await.</param>
+        /// <param name="toDoAsync">The asynchronous function to execute when the task is completed.</param>
+        /// <returns>A task representing the result of the asynchronous function.</returns>
+        public static async Task<I> ThenAsync<T, I>(this Task<T> task, Func<T, Task<I>> toDoAsync)
+        {
+            var then = await task;
+            return await toDoAsync(then);
+        }
+
+        /// <summary>
+        /// Executes an action for each element in an enumerable collection.
+        /// </summary>
+        /// <typeparam name="T">The type of the elements in the collection.</typeparam>
+        /// <param name="values">The enumerable collection of elements.</param>
+        /// <param name="action">The action to execute for each element.</param>
+        public static void ForEach<T>(this IEnumerable<T> values, Action<T> action)
+        {
+            foreach (var value in values)
+                action(value);
+        }
+    }
+}

DigitalData.Core.Client/ServiceFactory.cs

@@ -0,0 +1,25 @@
+using DigitalData.Core.Abstractions.Client;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace DigitalData.Core.Client
+{
+    public static class ServiceFactory
+    {
+        private static readonly IServiceCollection _services = new ServiceCollection();
+        private static readonly Lazy<IServiceProvider> _lazyProvider = new(Build);
+
+        public static IServiceCollection Services => !_lazyProvider.IsValueCreated
+            ? _services
+            : throw new InvalidOperationException(
+                "Service provider has already been created. " +
+                "Further modifications to the service collection are not allowed. " +
+                "This is to ensure that the dependency injection container remains in a consistent state.");
+
+        private static IServiceProvider Build() => _services.BuildServiceProvider();
+
+        public static T Provide<T>() where T : notnull => _lazyProvider.Value.GetRequiredService<T>();
+
+        public static IHttpClientService<TOptions> ProvideHttpClientService<TOptions>() where TOptions : IHttpClientOptions
+            => _lazyProvider.Value.GetRequiredService<IHttpClientService<TOptions>>();
+    }
+}

DigitalData.Core.Contracts/DigitalData.Core.Contracts.csproj

@@ -1,37 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-	<PropertyGroup>
-		<TargetFramework>net7.0</TargetFramework>
-		<ImplicitUsings>enable</ImplicitUsings>
-		<Nullable>enable</Nullable>
-		<!-- NuGet Package Metadata -->
-		<PackageId>WebCore.Contracts</PackageId>
-		<Version>1.0.1</Version>
-		<Authors>Hakan Tek</Authors>
-		<Company>Digital Data</Company>
-		<Product>DigitalData.Core.Contracts</Product>
-		<Description>The interfaces of DigitalData.Core projects.</Description>
-		<PackageTags>data-management;interfaces</PackageTags>
-		<PackageIcon>icon.png</PackageIcon>
-	</PropertyGroup>
-
-	<ItemGroup>
-		<None Include="icon.png" Pack="true" PackagePath="" />
-		<PackageReference Include="Microsoft.Extensions.Caching.Memory" Version="7.0.0" />
-		<PackageReference Include="Microsoft.Extensions.Configuration.Binder" Version="7.0.4" />
-		<PackageReference Include="System.DirectoryServices" Version="7.0.1" />
-		<PackageReference Include="System.DirectoryServices.AccountManagement" Version="7.0.1" />
-		<PackageReference Include="System.IdentityModel.Tokens.Jwt" Version="7.5.1" />
-	</ItemGroup>
-
-	<ItemGroup>
-	  <ProjectReference Include="..\DigitalData.Core.DTO\DigitalData.Core.DTO.csproj" />
-	</ItemGroup>
-
-	<ItemGroup>
-	  <None Update="icon.png">
-	    <CopyToOutputDirectory>Never</CopyToOutputDirectory>
-	  </None>
-	</ItemGroup>
-
-</Project>

DigitalData.Core.Contracts/IFlag.cs

@@ -1,7 +0,0 @@
-namespace DigitalData.Core.Contracts
-{
-    internal interface IError
-    {
-        
-    }
-}

DigitalData.Core.Contracts/Properties/launchSettings.json

@@ -1,12 +0,0 @@
-{
-  "profiles": {
-    "DigitalData.Core.Contracts": {
-      "commandName": "Project",
-      "launchBrowser": true,
-      "environmentVariables": {
-        "ASPNETCORE_ENVIRONMENT": "Development"
-      },
-      "applicationUrl": "https://localhost:50074;http://localhost:50075"
-    }
-  }
-}

DigitalData.Core.Contracts/bin/Release/net7.0/DigitalData.Core.Contracts.deps.json

@@ -1,512 +0,0 @@
-{
-  "runtimeTarget": {
-    "name": ".NETCoreApp,Version=v7.0",
-    "signature": ""
-  },
-  "compilationOptions": {},
-  "targets": {
-    ".NETCoreApp,Version=v7.0": {
-      "DigitalData.Core.Contracts/1.0.1": {
-        "dependencies": {
-          "Microsoft.Extensions.Caching.Memory": "7.0.0",
-          "Microsoft.Extensions.Configuration.Binder": "7.0.4",
-          "System.DirectoryServices": "7.0.1",
-          "System.DirectoryServices.AccountManagement": "7.0.1",
-          "System.IdentityModel.Tokens.Jwt": "7.5.1"
-        },
-        "runtime": {
-          "DigitalData.Core.Contracts.dll": {}
-        }
-      },
-      "Microsoft.Extensions.Caching.Abstractions/7.0.0": {
-        "dependencies": {
-          "Microsoft.Extensions.Primitives": "7.0.0"
-        },
-        "runtime": {
-          "lib/net7.0/Microsoft.Extensions.Caching.Abstractions.dll": {
-            "assemblyVersion": "7.0.0.0",
-            "fileVersion": "7.0.22.51805"
-          }
-        }
-      },
-      "Microsoft.Extensions.Caching.Memory/7.0.0": {
-        "dependencies": {
-          "Microsoft.Extensions.Caching.Abstractions": "7.0.0",
-          "Microsoft.Extensions.DependencyInjection.Abstractions": "7.0.0",
-          "Microsoft.Extensions.Logging.Abstractions": "7.0.0",
-          "Microsoft.Extensions.Options": "7.0.0",
-          "Microsoft.Extensions.Primitives": "7.0.0"
-        },
-        "runtime": {
-          "lib/net7.0/Microsoft.Extensions.Caching.Memory.dll": {
-            "assemblyVersion": "7.0.0.0",
-            "fileVersion": "7.0.22.51805"
-          }
-        }
-      },
-      "Microsoft.Extensions.Configuration.Abstractions/7.0.0": {
-        "dependencies": {
-          "Microsoft.Extensions.Primitives": "7.0.0"
-        },
-        "runtime": {
-          "lib/net7.0/Microsoft.Extensions.Configuration.Abstractions.dll": {
-            "assemblyVersion": "7.0.0.0",
-            "fileVersion": "7.0.22.51805"
-          }
-        }
-      },
-      "Microsoft.Extensions.Configuration.Binder/7.0.4": {
-        "dependencies": {
-          "Microsoft.Extensions.Configuration.Abstractions": "7.0.0"
-        },
-        "runtime": {
-          "lib/net7.0/Microsoft.Extensions.Configuration.Binder.dll": {
-            "assemblyVersion": "7.0.0.0",
-            "fileVersion": "7.0.423.11508"
-          }
-        }
-      },
-      "Microsoft.Extensions.DependencyInjection.Abstractions/7.0.0": {
-        "runtime": {
-          "lib/net7.0/Microsoft.Extensions.DependencyInjection.Abstractions.dll": {
-            "assemblyVersion": "7.0.0.0",
-            "fileVersion": "7.0.22.51805"
-          }
-        }
-      },
-      "Microsoft.Extensions.Logging.Abstractions/7.0.0": {
-        "runtime": {
-          "lib/net7.0/Microsoft.Extensions.Logging.Abstractions.dll": {
-            "assemblyVersion": "7.0.0.0",
-            "fileVersion": "7.0.22.51805"
-          }
-        }
-      },
-      "Microsoft.Extensions.Options/7.0.0": {
-        "dependencies": {
-          "Microsoft.Extensions.DependencyInjection.Abstractions": "7.0.0",
-          "Microsoft.Extensions.Primitives": "7.0.0"
-        },
-        "runtime": {
-          "lib/net7.0/Microsoft.Extensions.Options.dll": {
-            "assemblyVersion": "7.0.0.0",
-            "fileVersion": "7.0.22.51805"
-          }
-        }
-      },
-      "Microsoft.Extensions.Primitives/7.0.0": {
-        "runtime": {
-          "lib/net7.0/Microsoft.Extensions.Primitives.dll": {
-            "assemblyVersion": "7.0.0.0",
-            "fileVersion": "7.0.22.51805"
-          }
-        }
-      },
-      "Microsoft.IdentityModel.Abstractions/7.5.1": {
-        "runtime": {
-          "lib/net6.0/Microsoft.IdentityModel.Abstractions.dll": {
-            "assemblyVersion": "7.5.1.0",
-            "fileVersion": "7.5.1.50405"
-          }
-        }
-      },
-      "Microsoft.IdentityModel.JsonWebTokens/7.5.1": {
-        "dependencies": {
-          "Microsoft.IdentityModel.Tokens": "7.5.1"
-        },
-        "runtime": {
-          "lib/net6.0/Microsoft.IdentityModel.JsonWebTokens.dll": {
-            "assemblyVersion": "7.5.1.0",
-            "fileVersion": "7.5.1.50405"
-          }
-        }
-      },
-      "Microsoft.IdentityModel.Logging/7.5.1": {
-        "dependencies": {
-          "Microsoft.IdentityModel.Abstractions": "7.5.1"
-        },
-        "runtime": {
-          "lib/net6.0/Microsoft.IdentityModel.Logging.dll": {
-            "assemblyVersion": "7.5.1.0",
-            "fileVersion": "7.5.1.50405"
-          }
-        }
-      },
-      "Microsoft.IdentityModel.Tokens/7.5.1": {
-        "dependencies": {
-          "Microsoft.IdentityModel.Logging": "7.5.1"
-        },
-        "runtime": {
-          "lib/net6.0/Microsoft.IdentityModel.Tokens.dll": {
-            "assemblyVersion": "7.5.1.0",
-            "fileVersion": "7.5.1.50405"
-          }
-        }
-      },
-      "Microsoft.Win32.SystemEvents/7.0.0": {
-        "runtime": {
-          "lib/net7.0/Microsoft.Win32.SystemEvents.dll": {
-            "assemblyVersion": "7.0.0.0",
-            "fileVersion": "7.0.22.51805"
-          }
-        },
-        "runtimeTargets": {
-          "runtimes/win/lib/net7.0/Microsoft.Win32.SystemEvents.dll": {
-            "rid": "win",
-            "assetType": "runtime",
-            "assemblyVersion": "7.0.0.0",
-            "fileVersion": "7.0.22.51805"
-          }
-        }
-      },
-      "System.Configuration.ConfigurationManager/7.0.0": {
-        "dependencies": {
-          "System.Diagnostics.EventLog": "7.0.0",
-          "System.Security.Cryptography.ProtectedData": "7.0.0",
-          "System.Security.Permissions": "7.0.0"
-        },
-        "runtime": {
-          "lib/net7.0/System.Configuration.ConfigurationManager.dll": {
-            "assemblyVersion": "7.0.0.0",
-            "fileVersion": "7.0.22.51805"
-          }
-        }
-      },
-      "System.Diagnostics.EventLog/7.0.0": {
-        "runtime": {
-          "lib/net7.0/System.Diagnostics.EventLog.dll": {
-            "assemblyVersion": "7.0.0.0",
-            "fileVersion": "7.0.22.51805"
-          }
-        },
-        "runtimeTargets": {
-          "runtimes/win/lib/net7.0/System.Diagnostics.EventLog.Messages.dll": {
-            "rid": "win",
-            "assetType": "runtime",
-            "assemblyVersion": "7.0.0.0",
-            "fileVersion": "0.0.0.0"
-          },
-          "runtimes/win/lib/net7.0/System.Diagnostics.EventLog.dll": {
-            "rid": "win",
-            "assetType": "runtime",
-            "assemblyVersion": "7.0.0.0",
-            "fileVersion": "7.0.22.51805"
-          }
-        }
-      },
-      "System.DirectoryServices/7.0.1": {
-        "dependencies": {
-          "System.Security.Permissions": "7.0.0"
-        },
-        "runtime": {
-          "lib/net7.0/System.DirectoryServices.dll": {
-            "assemblyVersion": "4.0.0.0",
-            "fileVersion": "7.0.323.6910"
-          }
-        },
-        "runtimeTargets": {
-          "runtimes/win/lib/net7.0/System.DirectoryServices.dll": {
-            "rid": "win",
-            "assetType": "runtime",
-            "assemblyVersion": "4.0.0.0",
-            "fileVersion": "7.0.323.6910"
-          }
-        }
-      },
-      "System.DirectoryServices.AccountManagement/7.0.1": {
-        "dependencies": {
-          "System.Configuration.ConfigurationManager": "7.0.0",
-          "System.DirectoryServices": "7.0.1",
-          "System.DirectoryServices.Protocols": "7.0.1"
-        },
-        "runtime": {
-          "lib/net7.0/System.DirectoryServices.AccountManagement.dll": {
-            "assemblyVersion": "4.0.0.0",
-            "fileVersion": "7.0.1123.42427"
-          }
-        },
-        "runtimeTargets": {
-          "runtimes/win/lib/net7.0/System.DirectoryServices.AccountManagement.dll": {
-            "rid": "win",
-            "assetType": "runtime",
-            "assemblyVersion": "4.0.0.0",
-            "fileVersion": "7.0.1123.42427"
-          }
-        }
-      },
-      "System.DirectoryServices.Protocols/7.0.1": {
-        "runtime": {
-          "lib/net7.0/System.DirectoryServices.Protocols.dll": {
-            "assemblyVersion": "7.0.0.1",
-            "fileVersion": "7.0.723.27404"
-          }
-        },
-        "runtimeTargets": {
-          "runtimes/linux/lib/net7.0/System.DirectoryServices.Protocols.dll": {
-            "rid": "linux",
-            "assetType": "runtime",
-            "assemblyVersion": "7.0.0.1",
-            "fileVersion": "7.0.723.27404"
-          },
-          "runtimes/osx/lib/net7.0/System.DirectoryServices.Protocols.dll": {
-            "rid": "osx",
-            "assetType": "runtime",
-            "assemblyVersion": "7.0.0.1",
-            "fileVersion": "7.0.723.27404"
-          },
-          "runtimes/win/lib/net7.0/System.DirectoryServices.Protocols.dll": {
-            "rid": "win",
-            "assetType": "runtime",
-            "assemblyVersion": "7.0.0.1",
-            "fileVersion": "7.0.723.27404"
-          }
-        }
-      },
-      "System.Drawing.Common/7.0.0": {
-        "dependencies": {
-          "Microsoft.Win32.SystemEvents": "7.0.0"
-        },
-        "runtime": {
-          "lib/net7.0/System.Drawing.Common.dll": {
-            "assemblyVersion": "7.0.0.0",
-            "fileVersion": "7.0.22.51805"
-          }
-        },
-        "runtimeTargets": {
-          "runtimes/win/lib/net7.0/System.Drawing.Common.dll": {
-            "rid": "win",
-            "assetType": "runtime",
-            "assemblyVersion": "7.0.0.0",
-            "fileVersion": "7.0.22.51805"
-          }
-        }
-      },
-      "System.IdentityModel.Tokens.Jwt/7.5.1": {
-        "dependencies": {
-          "Microsoft.IdentityModel.JsonWebTokens": "7.5.1",
-          "Microsoft.IdentityModel.Tokens": "7.5.1"
-        },
-        "runtime": {
-          "lib/net6.0/System.IdentityModel.Tokens.Jwt.dll": {
-            "assemblyVersion": "7.5.1.0",
-            "fileVersion": "7.5.1.50405"
-          }
-        }
-      },
-      "System.Security.Cryptography.ProtectedData/7.0.0": {
-        "runtime": {
-          "lib/net7.0/System.Security.Cryptography.ProtectedData.dll": {
-            "assemblyVersion": "7.0.0.0",
-            "fileVersion": "7.0.22.51805"
-          }
-        },
-        "runtimeTargets": {
-          "runtimes/win/lib/net7.0/System.Security.Cryptography.ProtectedData.dll": {
-            "rid": "win",
-            "assetType": "runtime",
-            "assemblyVersion": "7.0.0.0",
-            "fileVersion": "7.0.22.51805"
-          }
-        }
-      },
-      "System.Security.Permissions/7.0.0": {
-        "dependencies": {
-          "System.Windows.Extensions": "7.0.0"
-        },
-        "runtime": {
-          "lib/net7.0/System.Security.Permissions.dll": {
-            "assemblyVersion": "7.0.0.0",
-            "fileVersion": "7.0.22.51805"
-          }
-        }
-      },
-      "System.Windows.Extensions/7.0.0": {
-        "dependencies": {
-          "System.Drawing.Common": "7.0.0"
-        },
-        "runtime": {
-          "lib/net7.0/System.Windows.Extensions.dll": {
-            "assemblyVersion": "7.0.0.0",
-            "fileVersion": "7.0.22.51805"
-          }
-        },
-        "runtimeTargets": {
-          "runtimes/win/lib/net7.0/System.Windows.Extensions.dll": {
-            "rid": "win",
-            "assetType": "runtime",
-            "assemblyVersion": "7.0.0.0",
-            "fileVersion": "7.0.22.51805"
-          }
-        }
-      }
-    }
-  },
-  "libraries": {
-    "DigitalData.Core.Contracts/1.0.1": {
-      "type": "project",
-      "serviceable": false,
-      "sha512": ""
-    },
-    "Microsoft.Extensions.Caching.Abstractions/7.0.0": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-IeimUd0TNbhB4ded3AbgBLQv2SnsiVugDyGV1MvspQFVlA07nDC7Zul7kcwH5jWN3JiTcp/ySE83AIJo8yfKjg==",
-      "path": "microsoft.extensions.caching.abstractions/7.0.0",
-      "hashPath": "microsoft.extensions.caching.abstractions.7.0.0.nupkg.sha512"
-    },
-    "Microsoft.Extensions.Caching.Memory/7.0.0": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-xpidBs2KCE2gw1JrD0quHE72kvCaI3xFql5/Peb2GRtUuZX+dYPoK/NTdVMiM67Svym0M0Df9A3xyU0FbMQhHw==",
-      "path": "microsoft.extensions.caching.memory/7.0.0",
-      "hashPath": "microsoft.extensions.caching.memory.7.0.0.nupkg.sha512"
-    },
-    "Microsoft.Extensions.Configuration.Abstractions/7.0.0": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-f34u2eaqIjNO9YLHBz8rozVZ+TcFiFs0F3r7nUJd7FRkVSxk8u4OpoK226mi49MwexHOR2ibP9MFvRUaLilcQQ==",
-      "path": "microsoft.extensions.configuration.abstractions/7.0.0",
-      "hashPath": "microsoft.extensions.configuration.abstractions.7.0.0.nupkg.sha512"
-    },
-    "Microsoft.Extensions.Configuration.Binder/7.0.4": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-8+XPvJnHZsYgHOQlcMuQe7QNF5KdVKHH1F/wW3nd8/u81Gk/XFAYMDP0Lpz18h7/AM95M662vvqMorcYxCBB4w==",
-      "path": "microsoft.extensions.configuration.binder/7.0.4",
-      "hashPath": "microsoft.extensions.configuration.binder.7.0.4.nupkg.sha512"
-    },
-    "Microsoft.Extensions.DependencyInjection.Abstractions/7.0.0": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-h3j/QfmFN4S0w4C2A6X7arXij/M/OVw3uQHSOFxnND4DyAzO1F9eMX7Eti7lU/OkSthEE0WzRsfT/Dmx86jzCw==",
-      "path": "microsoft.extensions.dependencyinjection.abstractions/7.0.0",
-      "hashPath": "microsoft.extensions.dependencyinjection.abstractions.7.0.0.nupkg.sha512"
-    },
-    "Microsoft.Extensions.Logging.Abstractions/7.0.0": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-kmn78+LPVMOWeITUjIlfxUPDsI0R6G0RkeAMBmQxAJ7vBJn4q2dTva7pWi65ceN5vPGjJ9q/Uae2WKgvfktJAw==",
-      "path": "microsoft.extensions.logging.abstractions/7.0.0",
-      "hashPath": "microsoft.extensions.logging.abstractions.7.0.0.nupkg.sha512"
-    },
-    "Microsoft.Extensions.Options/7.0.0": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-lP1yBnTTU42cKpMozuafbvNtQ7QcBjr/CcK3bYOGEMH55Fjt+iecXjT6chR7vbgCMqy3PG3aNQSZgo/EuY/9qQ==",
-      "path": "microsoft.extensions.options/7.0.0",
-      "hashPath": "microsoft.extensions.options.7.0.0.nupkg.sha512"
-    },
-    "Microsoft.Extensions.Primitives/7.0.0": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-um1KU5kxcRp3CNuI8o/GrZtD4AIOXDk+RLsytjZ9QPok3ttLUelLKpilVPuaFT3TFjOhSibUAso0odbOaCDj3Q==",
-      "path": "microsoft.extensions.primitives/7.0.0",
-      "hashPath": "microsoft.extensions.primitives.7.0.0.nupkg.sha512"
-    },
-    "Microsoft.IdentityModel.Abstractions/7.5.1": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-PT16ZFbPIiMsYv07oy3zOjqUOJ7xutGBkJTOX0+IbNyU6+O6X7aIxjq9EaSSRLWbekRgamgtmfg8Xjw6A6Ua9g==",
-      "path": "microsoft.identitymodel.abstractions/7.5.1",
-      "hashPath": "microsoft.identitymodel.abstractions.7.5.1.nupkg.sha512"
-    },
-    "Microsoft.IdentityModel.JsonWebTokens/7.5.1": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-93CGSa8RPdZU8zfvA3nf9NGKUqEnQrE12VzYlMqKh72ddhzusosqLNEUgH/YhFWBLRFOnY1RCgHMV7pR+sAx2w==",
-      "path": "microsoft.identitymodel.jsonwebtokens/7.5.1",
-      "hashPath": "microsoft.identitymodel.jsonwebtokens.7.5.1.nupkg.sha512"
-    },
-    "Microsoft.IdentityModel.Logging/7.5.1": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-PnpAQX20BAiDIPYmWUyQSlEaWD8BLXzHpiDGTCT568Cs0ReOeyzNe401LzCeiv6ilug/KefVeV1CeqtCHTo8dw==",
-      "path": "microsoft.identitymodel.logging/7.5.1",
-      "hashPath": "microsoft.identitymodel.logging.7.5.1.nupkg.sha512"
-    },
-    "Microsoft.IdentityModel.Tokens/7.5.1": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-Q3DKpyFViP84IUlTFKH/zIkswIrmSh2Vd/eFDo4wlOHy4DYxoweZEEw4kDEiKt9VCX6o7SddK3HK2xDYyFpexA==",
-      "path": "microsoft.identitymodel.tokens/7.5.1",
-      "hashPath": "microsoft.identitymodel.tokens.7.5.1.nupkg.sha512"
-    },
-    "Microsoft.Win32.SystemEvents/7.0.0": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-2nXPrhdAyAzir0gLl8Yy8S5Mnm/uBSQQA7jEsILOS1MTyS7DbmV1NgViMtvV1sfCD1ebITpNwb1NIinKeJgUVQ==",
-      "path": "microsoft.win32.systemevents/7.0.0",
-      "hashPath": "microsoft.win32.systemevents.7.0.0.nupkg.sha512"
-    },
-    "System.Configuration.ConfigurationManager/7.0.0": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-WvRUdlL1lB0dTRZSs5XcQOd5q9MYNk90GkbmRmiCvRHThWiojkpGqWdmEDJdXyHbxG/BhE5hmVbMfRLXW9FJVA==",
-      "path": "system.configuration.configurationmanager/7.0.0",
-      "hashPath": "system.configuration.configurationmanager.7.0.0.nupkg.sha512"
-    },
-    "System.Diagnostics.EventLog/7.0.0": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-eUDP47obqQm3SFJfP6z+Fx2nJ4KKTQbXB4Q9Uesnzw9SbYdhjyoGXuvDn/gEmFY6N5Z3bFFbpAQGA7m6hrYJCw==",
-      "path": "system.diagnostics.eventlog/7.0.0",
-      "hashPath": "system.diagnostics.eventlog.7.0.0.nupkg.sha512"
-    },
-    "System.DirectoryServices/7.0.1": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-Z4FVdUJEVXbf7/f/hU6cFZDtxN5ozUVKJMzXoHmC+GCeTcqzlxqmWtxurejxG3K+kZ6H0UKwNshoK1CYnmJ1sg==",
-      "path": "system.directoryservices/7.0.1",
-      "hashPath": "system.directoryservices.7.0.1.nupkg.sha512"
-    },
-    "System.DirectoryServices.AccountManagement/7.0.1": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-UNytHYwA5IF55WQhashsMG57ize83JUGJxD8YJlOyO9ZlMTOD4Nt7y+A6mvmrU/swDoYWaVL+TNwE6hk9lyvbA==",
-      "path": "system.directoryservices.accountmanagement/7.0.1",
-      "hashPath": "system.directoryservices.accountmanagement.7.0.1.nupkg.sha512"
-    },
-    "System.DirectoryServices.Protocols/7.0.1": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-t9hsL+UYRzNs30pnT2Tdx6ngX8McFUjru0a0ekNgu/YXfkXN+dx5OvSEv0/p7H2q3pdJLH7TJPWX7e55J8QB9A==",
-      "path": "system.directoryservices.protocols/7.0.1",
-      "hashPath": "system.directoryservices.protocols.7.0.1.nupkg.sha512"
-    },
-    "System.Drawing.Common/7.0.0": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-KIX+oBU38pxkKPxvLcLfIkOV5Ien8ReN78wro7OF5/erwcmortzeFx+iBswlh2Vz6gVne0khocQudGwaO1Ey6A==",
-      "path": "system.drawing.common/7.0.0",
-      "hashPath": "system.drawing.common.7.0.0.nupkg.sha512"
-    },
-    "System.IdentityModel.Tokens.Jwt/7.5.1": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-UUw+E0R73lZLlXgneYIJQxNs1kfbcxjVzw64JQyiwjqCd4HMpAbjn+xRo86QZT84uHq8/MkqvfH82tgjgPzpuw==",
-      "path": "system.identitymodel.tokens.jwt/7.5.1",
-      "hashPath": "system.identitymodel.tokens.jwt.7.5.1.nupkg.sha512"
-    },
-    "System.Security.Cryptography.ProtectedData/7.0.0": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-xSPiLNlHT6wAHtugASbKAJwV5GVqQK351crnILAucUioFqqieDN79evO1rku1ckt/GfjIn+b17UaSskoY03JuA==",
-      "path": "system.security.cryptography.protecteddata/7.0.0",
-      "hashPath": "system.security.cryptography.protecteddata.7.0.0.nupkg.sha512"
-    },
-    "System.Security.Permissions/7.0.0": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-Vmp0iRmCEno9BWiskOW5pxJ3d9n+jUqKxvX4GhLwFhnQaySZmBN2FuC0N5gjFHgyFMUjC5sfIJ8KZfoJwkcMmA==",
-      "path": "system.security.permissions/7.0.0",
-      "hashPath": "system.security.permissions.7.0.0.nupkg.sha512"
-    },
-    "System.Windows.Extensions/7.0.0": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-bR4qdCmssMMbo9Fatci49An5B1UaVJZHKNq70PRgzoLYIlitb8Tj7ns/Xt5Pz1CkERiTjcVBDU2y1AVrPBYkaw==",
-      "path": "system.windows.extensions/7.0.0",
-      "hashPath": "system.windows.extensions.7.0.0.nupkg.sha512"
-    }
-  }
-}

DigitalData.Core.Contracts/obj/Debug/WebCore.Contracts.1.0.1.nuspec

@@ -1,24 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>WebCore.Contracts</id>
-    <version>1.0.1</version>
-    <authors>Hakan Tek</authors>
-    <icon>icon.png</icon>
-    <description>The interfaces of DigitalData.Core projects.</description>
-    <tags>data-management interfaces</tags>
-    <dependencies>
-      <group targetFramework="net7.0">
-        <dependency id="Microsoft.Extensions.Caching.Memory" version="7.0.0" exclude="Build,Analyzers" />
-        <dependency id="Microsoft.Extensions.Configuration.Binder" version="7.0.4" exclude="Build,Analyzers" />
-        <dependency id="System.DirectoryServices" version="7.0.1" exclude="Build,Analyzers" />
-        <dependency id="System.DirectoryServices.AccountManagement" version="7.0.1" exclude="Build,Analyzers" />
-        <dependency id="System.IdentityModel.Tokens.Jwt" version="7.5.1" exclude="Build,Analyzers" />
-      </group>
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="E:\TekH\Visual Studio\WebCoreModules\DigitalData.Core.Contracts\bin\Debug\net7.0\DigitalData.Core.Contracts.dll" target="lib\net7.0\DigitalData.Core.Contracts.dll" />
-    <file src="E:\TekH\Visual Studio\WebCoreModules\DigitalData.Core.Contracts\icon.png" target="icon.png" />
-  </files>
-</package>

DigitalData.Core.Contracts/obj/Debug/net7.0/.NETCoreApp,Version=v7.0.AssemblyAttributes.cs

@@ -1,4 +0,0 @@
-// <autogenerated />
-using System;
-using System.Reflection;
-[assembly: global::System.Runtime.Versioning.TargetFrameworkAttribute(".NETCoreApp,Version=v7.0", FrameworkDisplayName = ".NET 7.0")]

DigitalData.Core.Contracts/obj/Debug/net7.0/DigitalData.Core.Contracts.GlobalUsings.g.cs

@@ -1,8 +0,0 @@
-// <auto-generated/>
-global using global::System;
-global using global::System.Collections.Generic;
-global using global::System.IO;
-global using global::System.Linq;
-global using global::System.Net.Http;
-global using global::System.Threading;
-global using global::System.Threading.Tasks;

DigitalData.Core.Contracts/obj/DigitalData.Core.Contracts.csproj.nuget.g.props

@@ -1,16 +0,0 @@
-<?xml version="1.0" encoding="utf-8" standalone="no"?>
-<Project ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Condition=" '$(ExcludeRestorePackageImports)' != 'true' ">
-    <RestoreSuccess Condition=" '$(RestoreSuccess)' == '' ">True</RestoreSuccess>
-    <RestoreTool Condition=" '$(RestoreTool)' == '' ">NuGet</RestoreTool>
-    <ProjectAssetsFile Condition=" '$(ProjectAssetsFile)' == '' ">$(MSBuildThisFileDirectory)project.assets.json</ProjectAssetsFile>
-    <NuGetPackageRoot Condition=" '$(NuGetPackageRoot)' == '' ">$(UserProfile)\.nuget\packages\</NuGetPackageRoot>
-    <NuGetPackageFolders Condition=" '$(NuGetPackageFolders)' == '' ">C:\Users\tekh\.nuget\packages\;D:\ProgramFiles\DevExpress 21.2\Components\Offline Packages</NuGetPackageFolders>
-    <NuGetProjectStyle Condition=" '$(NuGetProjectStyle)' == '' ">PackageReference</NuGetProjectStyle>
-    <NuGetToolVersion Condition=" '$(NuGetToolVersion)' == '' ">6.9.1</NuGetToolVersion>
-  </PropertyGroup>
-  <ItemGroup Condition=" '$(ExcludeRestorePackageImports)' != 'true' ">
-    <SourceRoot Include="C:\Users\tekh\.nuget\packages\" />
-    <SourceRoot Include="D:\ProgramFiles\DevExpress 21.2\Components\Offline Packages\" />
-  </ItemGroup>
-</Project>

DigitalData.Core.Contracts/obj/DigitalData.Core.Contracts.csproj.nuget.g.targets

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="utf-8" standalone="no"?>
-<Project ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ImportGroup Condition=" '$(ExcludeRestorePackageImports)' != 'true' ">
-    <Import Project="$(NuGetPackageRoot)microsoft.extensions.logging.abstractions\7.0.0\buildTransitive\net6.0\Microsoft.Extensions.Logging.Abstractions.targets" Condition="Exists('$(NuGetPackageRoot)microsoft.extensions.logging.abstractions\7.0.0\buildTransitive\net6.0\Microsoft.Extensions.Logging.Abstractions.targets')" />
-  </ImportGroup>
-</Project>

DigitalData.Core.Contracts/obj/DigitalData.Core.CultureServices.csproj.nuget.dgspec.json

@@ -1,80 +0,0 @@
-{
-  "format": 1,
-  "restore": {
-    "E:\\TekH\\Visual Studio\\DDWeb\\DigitalData.Core\\DigitalData.Core.CultureServices\\DigitalData.Core.CultureServices.csproj": {}
-  },
-  "projects": {
-    "E:\\TekH\\Visual Studio\\DDWeb\\DigitalData.Core\\DigitalData.Core.CultureServices\\DigitalData.Core.CultureServices.csproj": {
-      "version": "1.0.0",
-      "restore": {
-        "projectUniqueName": "E:\\TekH\\Visual Studio\\DDWeb\\DigitalData.Core\\DigitalData.Core.CultureServices\\DigitalData.Core.CultureServices.csproj",
-        "projectName": "DigitalData.Core.Contracts",
-        "projectPath": "E:\\TekH\\Visual Studio\\DDWeb\\DigitalData.Core\\DigitalData.Core.CultureServices\\DigitalData.Core.CultureServices.csproj",
-        "packagesPath": "C:\\Users\\tekh\\.nuget\\packages\\",
-        "outputPath": "E:\\TekH\\Visual Studio\\DDWeb\\DigitalData.Core\\DigitalData.Core.Contracts\\obj\\",
-        "projectStyle": "PackageReference",
-        "fallbackFolders": [
-          "D:\\ProgramFiles\\DevExpress 21.2\\Components\\Offline Packages",
-          "D:\\ProgramFiles\\DevExpress 22.1\\Components\\Offline Packages",
-          "C:\\Program Files\\dotnet\\sdk\\NuGetFallbackFolder"
-        ],
-        "configFilePaths": [
-          "C:\\Users\\tekh\\AppData\\Roaming\\NuGet\\NuGet.Config",
-          "C:\\Program Files (x86)\\NuGet\\Config\\DevExpress 19.2.config",
-          "C:\\Program Files (x86)\\NuGet\\Config\\DevExpress 21.2.config",
-          "C:\\Program Files (x86)\\NuGet\\Config\\DevExpress 22.1.config",
-          "C:\\Program Files (x86)\\NuGet\\Config\\Microsoft.VisualStudio.Offline.config"
-        ],
-        "originalTargetFrameworks": [
-          "net7.0"
-        ],
-        "sources": {
-          "C:\\Program Files (x86)\\Microsoft SDKs\\NuGetPackages\\": {},
-          "D:\\ProgramFiles\\DevExpress 19.2\\Components\\System\\Components\\Packages": {},
-          "D:\\ProgramFiles\\DevExpress 21.2\\Components\\System\\Components\\Packages": {},
-          "D:\\ProgramFiles\\DevExpress 22.1\\Components\\System\\Components\\Packages": {},
-          "https://api.nuget.org/v3/index.json": {}
-        },
-        "frameworks": {
-          "net7.0": {
-            "targetAlias": "net7.0",
-            "projectReferences": {}
-          }
-        },
-        "warningProperties": {
-          "warnAsError": [
-            "NU1605"
-          ]
-        }
-      },
-      "frameworks": {
-        "net7.0": {
-          "targetAlias": "net7.0",
-          "dependencies": {
-            "Microsoft.Extensions.Localization": {
-              "target": "Package",
-              "version": "[7.0.16, )"
-            }
-          },
-          "imports": [
-            "net461",
-            "net462",
-            "net47",
-            "net471",
-            "net472",
-            "net48",
-            "net481"
-          ],
-          "assetTargetFallback": true,
-          "warn": true,
-          "frameworkReferences": {
-            "Microsoft.NETCore.App": {
-              "privateAssets": "all"
-            }
-          },
-          "runtimeIdentifierGraphPath": "C:\\Program Files\\dotnet\\sdk\\7.0.202\\RuntimeIdentifierGraph.json"
-        }
-      }
-    }
-  }
-}

DigitalData.Core.Contracts/obj/DigitalData.Core.CultureServices.csproj.nuget.g.props

@@ -1,18 +0,0 @@
-<?xml version="1.0" encoding="utf-8" standalone="no"?>
-<Project ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Condition=" '$(ExcludeRestorePackageImports)' != 'true' ">
-    <RestoreSuccess Condition=" '$(RestoreSuccess)' == '' ">True</RestoreSuccess>
-    <RestoreTool Condition=" '$(RestoreTool)' == '' ">NuGet</RestoreTool>
-    <ProjectAssetsFile Condition=" '$(ProjectAssetsFile)' == '' ">$(MSBuildThisFileDirectory)project.assets.json</ProjectAssetsFile>
-    <NuGetPackageRoot Condition=" '$(NuGetPackageRoot)' == '' ">$(UserProfile)\.nuget\packages\</NuGetPackageRoot>
-    <NuGetPackageFolders Condition=" '$(NuGetPackageFolders)' == '' ">C:\Users\tekh\.nuget\packages\;D:\ProgramFiles\DevExpress 21.2\Components\Offline Packages;D:\ProgramFiles\DevExpress 22.1\Components\Offline Packages;C:\Program Files\dotnet\sdk\NuGetFallbackFolder</NuGetPackageFolders>
-    <NuGetProjectStyle Condition=" '$(NuGetProjectStyle)' == '' ">PackageReference</NuGetProjectStyle>
-    <NuGetToolVersion Condition=" '$(NuGetToolVersion)' == '' ">6.5.0</NuGetToolVersion>
-  </PropertyGroup>
-  <ItemGroup Condition=" '$(ExcludeRestorePackageImports)' != 'true' ">
-    <SourceRoot Include="C:\Users\tekh\.nuget\packages\" />
-    <SourceRoot Include="D:\ProgramFiles\DevExpress 21.2\Components\Offline Packages\" />
-    <SourceRoot Include="D:\ProgramFiles\DevExpress 22.1\Components\Offline Packages\" />
-    <SourceRoot Include="C:\Program Files\dotnet\sdk\NuGetFallbackFolder\" />
-  </ItemGroup>
-</Project>

DigitalData.Core.Contracts/obj/DigitalData.Core.CultureServices.csproj.nuget.g.targets

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="utf-8" standalone="no"?>
-<Project ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ImportGroup Condition=" '$(ExcludeRestorePackageImports)' != 'true' ">
-    <Import Project="$(NuGetPackageRoot)microsoft.extensions.logging.abstractions\7.0.1\buildTransitive\net6.0\Microsoft.Extensions.Logging.Abstractions.targets" Condition="Exists('$(NuGetPackageRoot)microsoft.extensions.logging.abstractions\7.0.1\buildTransitive\net6.0\Microsoft.Extensions.Logging.Abstractions.targets')" />
-  </ImportGroup>
-</Project>

DigitalData.Core.Contracts/obj/Release/WebCore.Contracts.1.0.0.nuspec

@@ -1,23 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>WebCore.Contracts</id>
-    <version>1.0.0</version>
-    <authors>Hakan Tek</authors>
-    <description>The interfaces of DigitalData.Core projects.</description>
-    <tags>data-management interfaces</tags>
-    <repository type="git" commit="82da3586a5e28ae5fbd4242f05f60f9e5327e5f2" />
-    <dependencies>
-      <group targetFramework="net7.0">
-        <dependency id="Microsoft.Extensions.Caching.Memory" version="7.0.0" exclude="Build,Analyzers" />
-        <dependency id="Microsoft.Extensions.Configuration.Binder" version="7.0.4" exclude="Build,Analyzers" />
-        <dependency id="System.DirectoryServices" version="7.0.1" exclude="Build,Analyzers" />
-        <dependency id="System.DirectoryServices.AccountManagement" version="7.0.1" exclude="Build,Analyzers" />
-        <dependency id="System.IdentityModel.Tokens.Jwt" version="7.5.1" exclude="Build,Analyzers" />
-      </group>
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="E:\TekH\Visual Studio\WebCoreModules\DigitalData.Core.Contracts\bin\Release\net7.0\DigitalData.Core.Contracts.dll" target="lib\net7.0\DigitalData.Core.Contracts.dll" />
-  </files>
-</package>

DigitalData.Core.Contracts/obj/Release/WebCore.Contracts.1.0.1.nuspec

@@ -1,25 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>WebCore.Contracts</id>
-    <version>1.0.1</version>
-    <authors>Hakan Tek</authors>
-    <icon>icon.png</icon>
-    <description>The interfaces of DigitalData.Core projects.</description>
-    <tags>data-management interfaces</tags>
-    <repository type="git" commit="82da3586a5e28ae5fbd4242f05f60f9e5327e5f2" />
-    <dependencies>
-      <group targetFramework="net7.0">
-        <dependency id="Microsoft.Extensions.Caching.Memory" version="7.0.0" exclude="Build,Analyzers" />
-        <dependency id="Microsoft.Extensions.Configuration.Binder" version="7.0.4" exclude="Build,Analyzers" />
-        <dependency id="System.DirectoryServices" version="7.0.1" exclude="Build,Analyzers" />
-        <dependency id="System.DirectoryServices.AccountManagement" version="7.0.1" exclude="Build,Analyzers" />
-        <dependency id="System.IdentityModel.Tokens.Jwt" version="7.5.1" exclude="Build,Analyzers" />
-      </group>
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="E:\TekH\Visual Studio\WebCoreModules\DigitalData.Core.Contracts\bin\Release\net7.0\DigitalData.Core.Contracts.dll" target="lib\net7.0\DigitalData.Core.Contracts.dll" />
-    <file src="E:\TekH\Visual Studio\WebCoreModules\DigitalData.Core.Contracts\icon.png" target="icon.png" />
-  </files>
-</package>

DigitalData.Core.Contracts/obj/Release/YourPackageName.1.0.0.nuspec

@@ -1,23 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>YourPackageName</id>
-    <version>1.0.0</version>
-    <authors>Hakan Tek</authors>
-    <description>The interfaces of DigitalData.Core projects.</description>
-    <tags>data-management interfaces</tags>
-    <repository type="git" commit="82da3586a5e28ae5fbd4242f05f60f9e5327e5f2" />
-    <dependencies>
-      <group targetFramework="net7.0">
-        <dependency id="Microsoft.Extensions.Caching.Memory" version="7.0.0" exclude="Build,Analyzers" />
-        <dependency id="Microsoft.Extensions.Configuration.Binder" version="7.0.4" exclude="Build,Analyzers" />
-        <dependency id="System.DirectoryServices" version="7.0.1" exclude="Build,Analyzers" />
-        <dependency id="System.DirectoryServices.AccountManagement" version="7.0.1" exclude="Build,Analyzers" />
-        <dependency id="System.IdentityModel.Tokens.Jwt" version="7.5.1" exclude="Build,Analyzers" />
-      </group>
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="E:\TekH\Visual Studio\WebCoreModules\DigitalData.Core.Contracts\bin\Release\net7.0\DigitalData.Core.Contracts.dll" target="lib\net7.0\DigitalData.Core.Contracts.dll" />
-  </files>
-</package>

DigitalData.Core.Contracts/obj/Release/net7.0/.NETCoreApp,Version=v7.0.AssemblyAttributes.cs

@@ -1,4 +0,0 @@
-// <autogenerated />
-using System;
-using System.Reflection;
-[assembly: global::System.Runtime.Versioning.TargetFrameworkAttribute(".NETCoreApp,Version=v7.0", FrameworkDisplayName = ".NET 7.0")]

DigitalData.Core.Contracts/obj/Release/net7.0/DigitalData.Core.Contracts.AssemblyInfo.cs

@@ -1,23 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by a tool.
-//
-//     Changes to this file may cause incorrect behavior and will be lost if
-//     the code is regenerated.
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-using System;
-using System.Reflection;
-
-[assembly: System.Reflection.AssemblyCompanyAttribute("Digital Data")]
-[assembly: System.Reflection.AssemblyConfigurationAttribute("Release")]
-[assembly: System.Reflection.AssemblyDescriptionAttribute("The interfaces of DigitalData.Core projects.")]
-[assembly: System.Reflection.AssemblyFileVersionAttribute("1.0.1.0")]
-[assembly: System.Reflection.AssemblyInformationalVersionAttribute("1.0.1+82da3586a5e28ae5fbd4242f05f60f9e5327e5f2")]
-[assembly: System.Reflection.AssemblyProductAttribute("DigitalData.Core.Contracts")]
-[assembly: System.Reflection.AssemblyTitleAttribute("DigitalData.Core.Contracts")]
-[assembly: System.Reflection.AssemblyVersionAttribute("1.0.1.0")]
-
-// Generated by the MSBuild WriteCodeFragment class.
-

DigitalData.Core.Contracts/obj/Release/net7.0/DigitalData.Core.Contracts.AssemblyInfoInputs.cache

@@ -1 +0,0 @@
-67eed8e486ad8cc100aa877b8e2de3753411edbcab6dc19b2cab9976d7aeed44

DigitalData.Core.Contracts/obj/Release/net7.0/DigitalData.Core.Contracts.GeneratedMSBuildEditorConfig.editorconfig

@@ -1,13 +0,0 @@
-is_global = true
-build_property.TargetFramework = net7.0
-build_property.TargetPlatformMinVersion = 
-build_property.UsingMicrosoftNETSdkWeb = 
-build_property.ProjectTypeGuids = 
-build_property.InvariantGlobalization = 
-build_property.PlatformNeutralAssembly = 
-build_property.EnforceExtendedAnalyzerRules = 
-build_property._SupportedPlatformList = Linux,macOS,Windows
-build_property.RootNamespace = DigitalData.Core.Contracts
-build_property.ProjectDir = E:\TekH\Visual Studio\WebCoreModules\DigitalData.Core.Contracts\
-build_property.EnableComHosting = 
-build_property.EnableGeneratedComInterfaceComImportInterop = 

DigitalData.Core.Contracts/obj/Release/net7.0/DigitalData.Core.Contracts.GlobalUsings.g.cs

@@ -1,8 +0,0 @@
-// <auto-generated/>
-global using global::System;
-global using global::System.Collections.Generic;
-global using global::System.IO;
-global using global::System.Linq;
-global using global::System.Net.Http;
-global using global::System.Threading;
-global using global::System.Threading.Tasks;

DigitalData.Core.Contracts/obj/Release/net7.0/DigitalData.Core.Contracts.csproj.CoreCompileInputs.cache

@@ -1 +0,0 @@
-50de9f7d3c1b480cb044dac5fd55004f68ae502a937a09ac85e539d84e2dece2

DigitalData.Core.Contracts/obj/Release/net7.0/DigitalData.Core.Contracts.csproj.FileListAbsolute.txt

@@ -1,13 +0,0 @@
-E:\TekH\Visual Studio\WebCoreModules\DigitalData.Core.Contracts\bin\Release\net7.0\DigitalData.Core.Contracts.deps.json
-E:\TekH\Visual Studio\WebCoreModules\DigitalData.Core.Contracts\bin\Release\net7.0\DigitalData.Core.Contracts.dll
-E:\TekH\Visual Studio\WebCoreModules\DigitalData.Core.Contracts\bin\Release\net7.0\DigitalData.Core.Contracts.pdb
-E:\TekH\Visual Studio\WebCoreModules\DigitalData.Core.Contracts\obj\Release\net7.0\DigitalData.Core.Contracts.csproj.AssemblyReference.cache
-E:\TekH\Visual Studio\WebCoreModules\DigitalData.Core.Contracts\obj\Release\net7.0\DigitalData.Core.Contracts.GeneratedMSBuildEditorConfig.editorconfig
-E:\TekH\Visual Studio\WebCoreModules\DigitalData.Core.Contracts\obj\Release\net7.0\DigitalData.Core.Contracts.AssemblyInfoInputs.cache
-E:\TekH\Visual Studio\WebCoreModules\DigitalData.Core.Contracts\obj\Release\net7.0\DigitalData.Core.Contracts.AssemblyInfo.cs
-E:\TekH\Visual Studio\WebCoreModules\DigitalData.Core.Contracts\obj\Release\net7.0\DigitalData.Core.Contracts.csproj.CoreCompileInputs.cache
-E:\TekH\Visual Studio\WebCoreModules\DigitalData.Core.Contracts\obj\Release\net7.0\DigitalData.Core.Contracts.dll
-E:\TekH\Visual Studio\WebCoreModules\DigitalData.Core.Contracts\obj\Release\net7.0\refint\DigitalData.Core.Contracts.dll
-E:\TekH\Visual Studio\WebCoreModules\DigitalData.Core.Contracts\obj\Release\net7.0\DigitalData.Core.Contracts.pdb
-E:\TekH\Visual Studio\WebCoreModules\DigitalData.Core.Contracts\obj\Release\net7.0\ref\DigitalData.Core.Contracts.dll
-E:\TekH\Visual Studio\WebCoreModules\DigitalData.Core.Contracts\bin\Release\net7.0\icon.png

DigitalData.Core.CultureServices/DIExtensions.cs

@@ -1,20 +0,0 @@
-using DigitalData.Common.CultureServices;
-using DigitalData.Core.Contracts.CultureServices;
-using Microsoft.Extensions.DependencyInjection;
-
-namespace DigitalData.Core.CultureServices
-{
-    public static class DIExtensions
-    {
-        /// <summary>
-        /// Registers the KeyTranslationService and its dependencies in the dependency injection container.
-        /// </summary>
-        /// <param name="services">The IServiceCollection instance to register the services with.</param>
-        public static IServiceCollection AddKeyTranslationService(this IServiceCollection services)
-        {
-            services.AddTransient<IKeyTranslationService, KeyTranslationService>();
-            return services;
-        }
-    }
-
-}

DigitalData.Core.CultureServices/DigitalData.Core.CultureServices.csproj

@@ -1,17 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <TargetFramework>net7.0</TargetFramework>
-    <ImplicitUsings>enable</ImplicitUsings>
-    <Nullable>enable</Nullable>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Microsoft.Extensions.Localization" Version="7.0.16" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\DigitalData.Core.Contracts\DigitalData.Core.Contracts.csproj" />
-  </ItemGroup>
-
-</Project>