Clean Refactoring

CatalogueCQRS/Backend.API/Backend.API.csproj

   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="AutoMapper" Version="10.1.1" />
-    <PackageReference Include="AutoMapper.Extensions.Microsoft.DependencyInjection" Version="8.1.1" />
-    <PackageReference Include="MediatR.Extensions.Microsoft.DependencyInjection" Version="7.0.0" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="5.0.13" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="5.0.13">
-      <PrivateAssets>all</PrivateAssets>
-      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
-    </PackageReference>
     <PackageReference Include="Microsoft.VisualStudio.Azure.Containers.Tools.Targets" Version="1.11.1" />
-    <PackageReference Include="Pomelo.EntityFrameworkCore.MySql" Version="5.0.0-alpha.2" />
     <PackageReference Include="Swashbuckle.AspNetCore.Swagger" Version="6.2.3" />
     <PackageReference Include="Swashbuckle.AspNetCore.SwaggerGen" Version="6.2.3" />
     <PackageReference Include="Swashbuckle.AspNetCore.SwaggerUI" Version="6.2.3" />
   </ItemGroup>
 
   <ItemGroup>
-    <ProjectReference Include="..\Backend.Common\Backend.Common.csproj" />
-    <ProjectReference Include="..\Mediator\Mediator.csproj" />
+    <ProjectReference Include="..\Backend.Common\Backend.Domain.csproj" />
+    <ProjectReference Include="..\Backend.Data\Backend.Infrastructure.csproj" />
+    <ProjectReference Include="..\Backend.EFCore\Backend.Persistence.csproj" />
+    <ProjectReference Include="..\Backend.Services\Backend.ApplicationCore.csproj" />
   </ItemGroup>
 
 

CatalogueCQRS/Backend.API/Config/DependencyInjectionHandler.cs

+using Mediator;
+using MediatR;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.Extensions.DependencyInjection;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Threading.Tasks;
+
+namespace Backend.API.Config
+{
+    internal static class DependencyInjectionHandler
+    {
+        internal static IServiceCollection AddMediaRHandlerDependency(this IServiceCollection services)
+        {
+            services.AddMediatR(Assembly.GetExecutingAssembly());
+            services.AddMediatR(typeof(GetTypeProprieteListHandler).Assembly);
+            services.AddMediatR(typeof(AddTypeProprieteHandler).Assembly);
+            services.AddMediatR(typeof(RemoveTypeProprieteHandler).Assembly);
+
+            services.AddMediatR(typeof(GetProprieteListHandler).Assembly);
+            services.AddMediatR(typeof(AddProprieteHandler).Assembly);
+            services.AddMediatR(typeof(RemoveProprieteHandler).Assembly);
+
+            services.AddMediatR(typeof(GetProduitListHandler).Assembly);
+            services.AddMediatR(typeof(AddProduitHandler).Assembly);
+            services.AddMediatR(typeof(RemoveProduitHandler).Assembly);
+
+            services.AddMediatR(typeof(GetCommandeListHandler).Assembly);
+            services.AddMediatR(typeof(AddCommandeHandler).Assembly);
+            services.AddMediatR(typeof(RemoveCommandeHandler).Assembly);
+
+            services.AddMediatR(typeof(GetLigneCommandeListHandler).Assembly);
+            services.AddMediatR(typeof(AddLigneCommandeHandler).Assembly);
+            services.AddMediatR(typeof(RemoveLigneCommandeHandler).Assembly);
+
+            return services;
+        }
+
+    }
+}

CatalogueCQRS/Backend.API/Config/DependencyInjectionRepository.cs

+using Backend.ApplicationCore.Interfaces.IRepositories;
+using Backend.Infrastructure.Repositories;
+using Backend.Persistence.Config;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Backend.API.Config
+{
+    internal static class DependencyInjectionRepository
+    {
+        internal static IServiceCollection AddDataDependencyInjectionRepository(this IServiceCollection services)
+        {
+            services.AddScoped<IApplicationDatabaseContext, ApplicationDatabaseContext>();
+            services.AddScoped<ICommandeRepository, CommandeRepository>();
+            services.AddScoped<ILigneCommandeRepository, LigneCommandeRepository>();
+            services.AddScoped<IProduitRepository, ProduitRepository>();
+            services.AddScoped<IProprieteRepository, ProprieteRepository>();
+            services.AddScoped<ITypeProprieteRepository, TypeProprieteRepository>();
+
+            return services;
+        }
+
+    }
+}

CatalogueCQRS/Backend.API/Config/DependencyInjectionService.cs

+using Backend.ApplicationCore.Interfaces.IServices;
+using Backend.ApplicationCore.Services;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.DependencyInjection;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Threading.Tasks;
+
+namespace Backend.API.Config
+{
+    internal static class DependencyInjectionService
+    {
+        internal static IServiceCollection AddDependencyInjectionService(this IServiceCollection services)
+        {
+            services.AddScoped<ITypeProprieteService, TypeProprieteService>();
+            services.AddScoped<IProprieteService, ProprieteService>();
+            services.AddScoped<IProduitService, ProduitService>();
+            services.AddScoped<ICommandeService, CommandeService>();
+            services.AddScoped<ILigneCommandeService, LigneCommandeService>();
+            services.AddSingleton<IHttpContextAccessor, HttpContextAccessor>();
+
+            return services;
+        }
+
+    }
+}

CatalogueCQRS/Backend.API/Config/SwaggerExtensions.cs

+using Microsoft.AspNetCore.Builder;
+using Microsoft.Extensions.DependencyInjection;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Threading.Tasks;
+
+namespace Backend.API.Config
+{
+    internal static class SwaggerExtensions
+    {
+        internal static IServiceCollection AddSwaggerDocumentation(this IServiceCollection services)
+        {
+            services.AddSwaggerGen(options =>
+            {
+                options.SwaggerDoc("v1", new Microsoft.OpenApi.Models.OpenApiInfo
+                {
+                    Title = "Sample CQRS Catalogue.Backend.API",
+                    Version = "v1",
+                    Description = "Sample .NET Core REST API CQRS implementation using Clean Architecture.",
+                });
+
+                var baseDirectory = AppDomain.CurrentDomain.BaseDirectory;
+                var commentsFileName = Assembly.GetExecutingAssembly().GetName().Name + ".XML";
+                var commentsFile = Path.Combine(baseDirectory, commentsFileName);
+               // options.IncludeXmlComments(commentsFile);
+            });
+
+            return services;
+        }
+
+        internal static IApplicationBuilder UseSwaggerDocumentation(this IApplicationBuilder app)
+        {
+            app.UseSwagger();
+
+            app.UseSwaggerUI(c =>
+            {
+                c.SwaggerEndpoint("/swagger/v1/swagger.json", "Sample CQRS API V1");
+            });
+
+            return app;
+        }
+    }
+}

CatalogueCQRS/Backend.API/Controllers/CommandeController.cs

-using Backend.Common;
+
+using Backend.Domain;
 using Backend.Models;
 using Mediator;
 using MediatR;
     [Route("api/[controller]")]
     public class CommandeController : ControllerBase
     {
-        private const string getAllCommande = "getAll";
-        private const string postCreateOrUpdate = "createOrUpdate";
-        private const string deleteById = "deleteById/{id}";
+        private const string c_getAllCommande = "getAll"; 
+        private const string c_postCreateOrUpdate = "createOrUpdate";
+        private const string c_deleteById = "deleteById/{id}";
 
         private readonly ILogger<CommandeController> _log;
         private readonly IMediator _mediator;
         /// get all type propriete
         /// </summary>
         /// <returns></returns>
-        [HttpGet(getAllCommande)]
+        [HttpGet(c_getAllCommande)]
         [ProducesResponseType(StatusCodes.Status200OK)]
         [ProducesResponseType(StatusCodes.Status500InternalServerError)]
-        public async Task<IActionResult> GetAll()
+        public async Task<IActionResult> GetAllAsync()
         {
             _log.LogDebug($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Request to get all Type");
             if (_mediator == null)
             {
-                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_5XX}");
-                return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.HTTP_ERROR_5XX);
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_5XX}");
+                return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.S_HTTP_ERROR_5XX);
             }
             try
             {
                 }
                 else
                 {
-                    _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_5XX}");
-                    return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.HTTP_ERROR_5XX);
+                    _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_5XX}");
+                    return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.S_HTTP_ERROR_5XX);
                 }
             }
             catch (Exception ex)
         /// </summary>
         /// <param name="cmd"></param>
         /// <returns></returns>
-        [HttpPost(postCreateOrUpdate)]
+        [HttpPost(c_postCreateOrUpdate)]
         [ProducesResponseType(StatusCodes.Status200OK)]
         [ProducesResponseType(StatusCodes.Status400BadRequest)]
         [ProducesResponseType(StatusCodes.Status500InternalServerError)]
-        public async Task<IActionResult> CreateOrUpdate([FromBody] AddCommandeCommand cmd)
+        public async Task<IActionResult> CreateOrUpdateAsync([FromBody] AddCommandeCommand cmd)
         {
             _log.LogDebug($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Request to create or update Type");
             if (_mediator == null)
             {
-                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_5XX}");
-                return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.HTTP_ERROR_5XX);
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_5XX}");
+                return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.S_HTTP_ERROR_5XX);
             }
             if(cmd != null)
             {
                     }
                     else
                     {
-                        _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_5XX}");
-                        return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.HTTP_ERROR_5XX);
+                        _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_5XX}");
+                        return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.S_HTTP_ERROR_5XX);
                     }
                 }
                 catch (Exception ex)
             }
             else
             {
-                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_4XX}");
-                return StatusCode(StatusCodes.Status400BadRequest, ErrorsConstants.HTTP_ERROR_4XX);
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_4XX}");
+                return StatusCode(StatusCodes.Status400BadRequest, ErrorsConstants.S_HTTP_ERROR_4XX);
             }
            
         }
         /// </summary>
         /// <param name="id"></param>
         /// <returns></returns>
-        [HttpDelete(deleteById)]
+        [HttpDelete(c_deleteById)]
         [ProducesResponseType(StatusCodes.Status200OK)]
         [ProducesResponseType(StatusCodes.Status400BadRequest)]
         [ProducesResponseType(StatusCodes.Status500InternalServerError)]
-        public async Task<IActionResult> DeleteById([FromRoute] Guid id)
+        public async Task<IActionResult> DeleteByIdAsync([FromRoute] Guid id)
         {
             _log.LogDebug($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Request to delete type by: {id}");
             if (_mediator == null)
             {
-                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_5XX}");
-                return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.HTTP_ERROR_5XX);
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_5XX}");
+                return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.S_HTTP_ERROR_5XX);
             }
             if (id != null)
             {
                     }
                     else
                     {
-                        _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_5XX}");
-                        return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.HTTP_ERROR_5XX);
+                        _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_5XX}");
+                        return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.S_HTTP_ERROR_5XX);
                     }
                 }
                 catch (Exception ex)
             }
             else
             {
-                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_4XX}");
-                return StatusCode(StatusCodes.Status400BadRequest, ErrorsConstants.HTTP_ERROR_4XX);
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_4XX}");
+                return StatusCode(StatusCodes.Status400BadRequest, ErrorsConstants.S_HTTP_ERROR_4XX);
             }
 
         }

CatalogueCQRS/Backend.API/Controllers/LigneCommandeController.cs

-using Backend.Common;
+
+using Backend.Domain;
 using Backend.Models;
 using Mediator;
 using MediatR;
     [Route("api/[controller]")]
     public class LigneCommandeController : ControllerBase
     {
-        private const string getAllLigneCommande = "getAll";
-        private const string postCreateOrUpdate = "createOrUpdate";
-        private const string deleteById = "deleteById/{id}";
+        private const string c_getAllLigneCommande = "getAll";
+        private const string c_postCreateOrUpdate = "createOrUpdate";
+        private const string c_deleteById = "deleteById/{id}";
 
         private readonly ILogger<LigneCommandeController> _log;
         private readonly IMediator _mediator;
         /// get all type propriete
         /// </summary>
         /// <returns></returns>
-        [HttpGet(getAllLigneCommande)]
+        [HttpGet(c_getAllLigneCommande)]
         [ProducesResponseType(StatusCodes.Status200OK)]
         [ProducesResponseType(StatusCodes.Status500InternalServerError)]
-        public async Task<IActionResult> GetAll()
+        public async Task<IActionResult> GetAllAsync()
         {
-            _log.LogDebug($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Request to get all Type");
+            _log.LogDebug($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Request to get all Ligne commande");
             if (_mediator == null)
             {
-                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_5XX}");
-                return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.HTTP_ERROR_5XX);
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_5XX}");
+                return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.S_HTTP_ERROR_5XX);
             }
             try
             {
                 }
                 else
                 {
-                    _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_5XX}");
-                    return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.HTTP_ERROR_5XX);
+                    _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_5XX}");
+                    return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.S_HTTP_ERROR_5XX);
                 }
             }
             catch (Exception ex)
         }
 
         /// <summary>
-        /// create or update type
+        /// create or update ligne commande id?
         /// </summary>
         /// <param name="cmd"></param>
         /// <returns></returns>
-        [HttpPost(postCreateOrUpdate)]
+        [HttpPost(c_postCreateOrUpdate)]
         [ProducesResponseType(StatusCodes.Status200OK)]
         [ProducesResponseType(StatusCodes.Status400BadRequest)]
         [ProducesResponseType(StatusCodes.Status500InternalServerError)]
-        public async Task<IActionResult> CreateOrUpdate([FromBody] AddLigneCommandeCommand cmd)
+        public async Task<IActionResult> CreateOrUpdateAsync([FromBody] AddLigneCommandeCommand cmd)
         {
-            _log.LogDebug($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Request to create or update Type");
+            _log.LogDebug($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Request to create or update Ligne commande");
             if (_mediator == null)
             {
-                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_5XX}");
-                return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.HTTP_ERROR_5XX);
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_5XX}");
+                return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.S_HTTP_ERROR_5XX);
             }
             if(cmd != null)
             {
                     }
                     else
                     {
-                        _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_5XX}");
-                        return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.HTTP_ERROR_5XX);
+                        _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_5XX}");
+                        return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.S_HTTP_ERROR_5XX);
                     }
                 }
                 catch (Exception ex)
             }
             else
             {
-                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_4XX}");
-                return StatusCode(StatusCodes.Status400BadRequest, ErrorsConstants.HTTP_ERROR_4XX);
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_4XX}");
+                return StatusCode(StatusCodes.Status400BadRequest, ErrorsConstants.S_HTTP_ERROR_4XX);
             }
            
         }
         /// </summary>
         /// <param name="id"></param>
         /// <returns></returns>
-        [HttpDelete(deleteById)]
+        [HttpDelete(c_deleteById)]
         [ProducesResponseType(StatusCodes.Status200OK)]
         [ProducesResponseType(StatusCodes.Status400BadRequest)]
         [ProducesResponseType(StatusCodes.Status500InternalServerError)]
-        public async Task<IActionResult> DeleteById([FromRoute] Guid id)
+        public async Task<IActionResult> DeleteByIdAsync([FromRoute] Guid id)
         {
-            _log.LogDebug($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Request to delete type by: {id}");
+            _log.LogDebug($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Request to delete ligne commande by: {id}");
             if (_mediator == null)
             {
-                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_5XX}");
-                return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.HTTP_ERROR_5XX);
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_5XX}");
+                return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.S_HTTP_ERROR_5XX);
             }
             if (id != null)
             {
                     }
                     else
                     {
-                        _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_5XX}");
-                        return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.HTTP_ERROR_5XX);
+                        _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_5XX}");
+                        return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.S_HTTP_ERROR_5XX);
                     }
                 }
                 catch (Exception ex)
             }
             else
             {
-                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_4XX}");
-                return StatusCode(StatusCodes.Status400BadRequest, ErrorsConstants.HTTP_ERROR_4XX);
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_4XX}");
+                return StatusCode(StatusCodes.Status400BadRequest, ErrorsConstants.S_HTTP_ERROR_4XX);
             }
 
         }

CatalogueCQRS/Backend.API/Controllers/ProduitController.cs

-using Backend.Common;
+
+using Backend.Domain;
 using Backend.Models;
 using Mediator;
 using MediatR;
     [Route("api/[controller]")]
     public class ProduitController : ControllerBase
     {
-        private const string getAllProduit = "getAll";
-        private const string postCreateOrUpdate = "createOrUpdate";
-        private const string deleteById = "deleteById/{id}";
+        private const string c_getAllProduit = "getAll";
+        private const string c_postCreateOrUpdate = "createOrUpdate";
+        private const string c_deleteById = "deleteById/{id}";
 
         private readonly ILogger<ProduitController> _log;
         private readonly IMediator _mediator;
         /// get all type propriete
         /// </summary>
         /// <returns></returns>
-        [HttpGet(getAllProduit)]
+        [HttpGet(c_getAllProduit)]
         [ProducesResponseType(StatusCodes.Status200OK)]
         [ProducesResponseType(StatusCodes.Status500InternalServerError)]
-        public async Task<IActionResult> GetAll()
+        public async Task<IActionResult> GetAllAsync()
         {
-            _log.LogDebug($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Request to get all Type");
+            _log.LogDebug($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Request to get all produit");
             if (_mediator == null)
             {
-                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_5XX}");
-                return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.HTTP_ERROR_5XX);
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_5XX}");
+                return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.S_HTTP_ERROR_5XX);
             }
             try
             {
                 }
                 else
                 {
-                    _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_5XX}");
-                    return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.HTTP_ERROR_5XX);
+                    _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_5XX}");
+                    return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.S_HTTP_ERROR_5XX);
                 }
             }
             catch (Exception ex)
         /// </summary>
         /// <param name="cmd"></param>
         /// <returns></returns>
-        [HttpPost(postCreateOrUpdate)]
+        [HttpPost(c_postCreateOrUpdate)]
         [ProducesResponseType(StatusCodes.Status200OK)]
         [ProducesResponseType(StatusCodes.Status400BadRequest)]
         [ProducesResponseType(StatusCodes.Status500InternalServerError)]
-        public async Task<IActionResult> CreateOrUpdate([FromBody] AddProduitCommand cmd)
+        public async Task<IActionResult> CreateOrUpdateAsync([FromBody] AddProduitCommand cmd)
         {
-            _log.LogDebug($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Request to create or update Type");
+            _log.LogDebug($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Request to create or update Produit");
             if (_mediator == null)
             {
-                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_5XX}");
-                return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.HTTP_ERROR_5XX);
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_5XX}");
+                return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.S_HTTP_ERROR_5XX);
             }
             if(cmd != null)
             {
                     }
                     else
                     {
-                        _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_5XX}");
-                        return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.HTTP_ERROR_5XX);
+                        _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_5XX}");
+                        return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.S_HTTP_ERROR_5XX);
                     }
                 }
                 catch (Exception ex)
             }
             else
             {
-                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_4XX}");
-                return StatusCode(StatusCodes.Status400BadRequest, ErrorsConstants.HTTP_ERROR_4XX);
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_4XX}");
+                return StatusCode(StatusCodes.Status400BadRequest, ErrorsConstants.S_HTTP_ERROR_4XX);
             }
            
         }
         /// </summary>
         /// <param name="id"></param>
         /// <returns></returns>
-        [HttpDelete(deleteById)]
+        [HttpDelete(c_deleteById)]
         [ProducesResponseType(StatusCodes.Status200OK)]
         [ProducesResponseType(StatusCodes.Status400BadRequest)]
         [ProducesResponseType(StatusCodes.Status500InternalServerError)]
-        public async Task<IActionResult> DeleteById([FromRoute] Guid id)
+        public async Task<IActionResult> DeleteByIdAsync([FromRoute] Guid id)
         {
             _log.LogDebug($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Request to delete type by: {id}");
             if (_mediator == null)
             {
-                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_5XX}");
-                return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.HTTP_ERROR_5XX);
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_5XX}");
+                return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.S_HTTP_ERROR_5XX);
             }
             if (id != null)
             {
                     }
                     else
                     {
-                        _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_5XX}");
-                        return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.HTTP_ERROR_5XX);
+                        _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_5XX}");
+                        return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.S_HTTP_ERROR_5XX);
                     }
                 }
                 catch (Exception ex)
             }
             else
             {
-                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_4XX}");
-                return StatusCode(StatusCodes.Status400BadRequest, ErrorsConstants.HTTP_ERROR_4XX);
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_4XX}");
+                return StatusCode(StatusCodes.Status400BadRequest, ErrorsConstants.S_HTTP_ERROR_4XX);
             }
 
         }

CatalogueCQRS/Backend.API/Controllers/ProprieteController.cs

-using Backend.Common;
+
+using Backend.Domain;
 using Backend.Models;
 using Mediator;
 using MediatR;
     [Route("api/[controller]")]
     public class ProprieteController : ControllerBase
     {
-        private const string getAllPropriete = "getAll";
-        private const string postCreateOrUpdate = "createOrUpdate";
-        private const string deleteById = "deleteById/{id}";
+        private const string c_getAllPropriete = "getAll";
+        private const string c_postCreateOrUpdate = "createOrUpdate";
+        private const string c_deleteById = "deleteById/{id}";
 
         private readonly ILogger<ProprieteController> _log;
         private readonly IMediator _mediator;
         /// get all type propriete
         /// </summary>
         /// <returns></returns>
-        [HttpGet(getAllPropriete)]
+        [HttpGet(c_getAllPropriete)]
         [ProducesResponseType(StatusCodes.Status200OK)]
         [ProducesResponseType(StatusCodes.Status500InternalServerError)]
-        public async Task<IActionResult> GetAll()
+        public async Task<IActionResult> GetAllAsync()
         {
-            _log.LogDebug($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Request to get all Type");
+            _log.LogDebug($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Request to get all Propriete");
             if (_mediator == null)
             {
-                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_5XX}");
-                return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.HTTP_ERROR_5XX);
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_5XX}");
+                return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.S_HTTP_ERROR_5XX);
             }
             try
             {
                 }
                 else
                 {
-                    _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_5XX}");
-                    return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.HTTP_ERROR_5XX);
+                    _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_5XX}");
+                    return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.S_HTTP_ERROR_5XX);
                 }
             }
             catch (Exception ex)
         }
 
         /// <summary>
-        /// create or update type
+        /// create or update propriete
         /// </summary>
         /// <param name="cmd"></param>
         /// <returns></returns>
-        [HttpPost(postCreateOrUpdate)]
+        [HttpPost(c_postCreateOrUpdate)]
         [ProducesResponseType(StatusCodes.Status200OK)]
         [ProducesResponseType(StatusCodes.Status400BadRequest)]
         [ProducesResponseType(StatusCodes.Status500InternalServerError)]
-        public async Task<IActionResult> CreateOrUpdate([FromBody] AddProprieteCommand cmd)
+        public async Task<IActionResult> CreateOrUpdateAsync([FromBody] AddProprieteCommand cmd)
         {
             _log.LogDebug($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Request to create or update Type");
             if (_mediator == null)
             {
-                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_5XX}");
-                return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.HTTP_ERROR_5XX);
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_5XX}");
+                return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.S_HTTP_ERROR_5XX);
             }
             if(cmd != null)
             {
                     }
                     else
                     {
-                        _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_5XX}");
-                        return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.HTTP_ERROR_5XX);
+                        _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_5XX}");
+                        return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.S_HTTP_ERROR_5XX);
                     }
                 }
                 catch (Exception ex)
             }
             else
             {
-                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_4XX}");
-                return StatusCode(StatusCodes.Status400BadRequest, ErrorsConstants.HTTP_ERROR_4XX);
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_4XX}");
+                return StatusCode(StatusCodes.Status400BadRequest, ErrorsConstants.S_HTTP_ERROR_4XX);
             }
            
         }
         /// </summary>
         /// <param name="id"></param>
         /// <returns></returns>
-        [HttpDelete(deleteById)]
+        [HttpDelete(c_deleteById)]
         [ProducesResponseType(StatusCodes.Status200OK)]
         [ProducesResponseType(StatusCodes.Status400BadRequest)]
         [ProducesResponseType(StatusCodes.Status500InternalServerError)]
-        public async Task<IActionResult> DeleteById([FromRoute] Guid id)
+        public async Task<IActionResult> DeleteByIdAsync([FromRoute] Guid id)
         {
-            _log.LogDebug($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Request to delete type by: {id}");
+            _log.LogDebug($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Request to delete propriete by: {id}");
             if (_mediator == null)
             {
-                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_5XX}");
-                return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.HTTP_ERROR_5XX);
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_5XX}");
+                return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.S_HTTP_ERROR_5XX);
             }
             if (id != null)
             {
                     }
                     else
                     {
-                        _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_5XX}");
-                        return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.HTTP_ERROR_5XX);
+                        _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_5XX}");
+                        return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.S_HTTP_ERROR_5XX);
                     }
                 }
                 catch (Exception ex)
             }
             else
             {
-                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_4XX}");
-                return StatusCode(StatusCodes.Status400BadRequest, ErrorsConstants.HTTP_ERROR_4XX);
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_4XX}");
+                return StatusCode(StatusCodes.Status400BadRequest, ErrorsConstants.S_HTTP_ERROR_4XX);
             }
 
         }

CatalogueCQRS/Backend.API/Controllers/TypeProprieteController.cs

-using Backend.Common;
+using Backend.Domain;
 using Backend.Models;
 using Mediator;
 using MediatR;
     [Route("api/[controller]")]
     public class TypeProprieteController : ControllerBase
     {
-        private const string getAllTypePropriete = "getAll";
-        private const string postCreateOrUpdate = "createOrUpdate";
-        private const string deleteById = "deleteById/{id}";
+        private const string c_getAllTypePropriete = "getAll";
+        private const string c_postCreateOrUpdate = "createOrUpdate";
+        private const string c_deleteById = "deleteById/{id}"; 
 
         private readonly ILogger<TypeProprieteController> _log;
         private readonly IMediator _mediator;
         /// get all type propriete
         /// </summary>
         /// <returns></returns>
-        [HttpGet(getAllTypePropriete)]
+        [HttpGet(c_getAllTypePropriete)]
         [ProducesResponseType(StatusCodes.Status200OK)]
         [ProducesResponseType(StatusCodes.Status500InternalServerError)]
-        public async Task<IActionResult> GetAll()
+        public async Task<IActionResult> GetAllAsync()
         {
-            _log.LogDebug($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Request to get all Type");
+            _log.LogDebug($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Request to get all TypePropriete");
             if (_mediator == null)
             {
-                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_5XX}");
-                return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.HTTP_ERROR_5XX);
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_5XX}");
+                return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.S_HTTP_ERROR_5XX);
             }
             try
             {
                 }
                 else
                 {
-                    _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_5XX}");
-                    return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.HTTP_ERROR_5XX);
+                    _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_5XX}");
+                    return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.S_HTTP_ERROR_5XX);
                 }
             }
             catch (Exception ex)
         }
 
         /// <summary>
-        /// create or update type
+        /// create or update typePropriete
         /// </summary>
         /// <param name="cmd"></param>
         /// <returns></returns>
-        [HttpPost(postCreateOrUpdate)]
+        [HttpPost(c_postCreateOrUpdate)] 
         [ProducesResponseType(StatusCodes.Status200OK)]
         [ProducesResponseType(StatusCodes.Status400BadRequest)]
         [ProducesResponseType(StatusCodes.Status500InternalServerError)]
-        public async Task<IActionResult> CreateOrUpdate([FromBody] AddTypeProprieteCommand cmd)
+        public async Task<IActionResult> CreateOrUpdateAsync([FromBody] AddTypeProprieteCommand cmd)
         {
             _log.LogDebug($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Request to create or update Type");
             if (_mediator == null)
             {
-                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_5XX}");
-                return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.HTTP_ERROR_5XX);
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_5XX}");
+                return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.S_HTTP_ERROR_5XX);
             }
-            if(cmd != null)
+            if (cmd != null)
             {
                 try
                 {
                     }
                     else
                     {
-                        _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_5XX}");
-                        return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.HTTP_ERROR_5XX);
+                        _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_5XX}");
+                        return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.S_HTTP_ERROR_5XX);
                     }
                 }
                 catch (Exception ex)
             }
             else
             {
-                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_4XX}");
-                return StatusCode(StatusCodes.Status400BadRequest, ErrorsConstants.HTTP_ERROR_4XX);
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_4XX}");
+                return StatusCode(StatusCodes.Status400BadRequest, ErrorsConstants.S_HTTP_ERROR_4XX);
             }
-           
+
         }
 
         /// <summary>
         /// </summary>
         /// <param name="id"></param>
         /// <returns></returns>
-        [HttpDelete(deleteById)]
+        [HttpDelete(c_deleteById)]
         [ProducesResponseType(StatusCodes.Status200OK)]
         [ProducesResponseType(StatusCodes.Status400BadRequest)]
         [ProducesResponseType(StatusCodes.Status500InternalServerError)]
-        public async Task<IActionResult> DeleteById([FromRoute] Guid id)
+        public async Task<IActionResult> DeleteByIdAsync([FromRoute] Guid id)
         {
             _log.LogDebug($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Request to delete type by: {id}");
             if (_mediator == null)
             {
-                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_5XX}");
-                return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.HTTP_ERROR_5XX);
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_5XX}");
+                return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.S_HTTP_ERROR_5XX);
             }
             if (id != null)
             {
                     }
                     else
                     {
-                        _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_5XX}");
-                        return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.HTTP_ERROR_5XX);
+                        _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_5XX}");
+                        return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.S_HTTP_ERROR_5XX);
                     }
                 }
                 catch (Exception ex)
             }
             else
             {
-                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_4XX}");
-                return StatusCode(StatusCodes.Status400BadRequest, ErrorsConstants.HTTP_ERROR_4XX);
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_4XX}");
+                return StatusCode(StatusCodes.Status400BadRequest, ErrorsConstants.S_HTTP_ERROR_4XX);
             }
 
         }
     }
-}
+}

CatalogueCQRS/Backend.API/Startup.cs

-using Backend.Data;
-using Backend.Data.Config;
-using Backend.Data.Interfaces;
-using Backend.Data.Repositories;
-using Backend.Services;
-using Backend.Services.Interface;
-using Backend.Services.Mapper;
-using Mediator;
-using MediatR;
+using Backend.API.Config;
+using Backend.ApplicationCore.Mapper;
+using Backend.Persistence.Config;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Hosting;
-using Microsoft.AspNetCore.Http;
-using Microsoft.AspNetCore.Mvc;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.DependencyInjection.Extensions;
 using Microsoft.Extensions.Hosting;
-using Microsoft.Extensions.Logging;
-using Microsoft.OpenApi.Models;
 using System;
-using System.Reflection;
-using System.Threading.Tasks;
 
 namespace Backend.API
 {
         {
             services.AddControllers();
             services.AddOptions();
-
-            AddDataDependencyInjectionService(services);
-
-            AddDataDependencyInjectionRepository(services);
-
+            services.AddDependencyInjectionService();
+            services.AddDataDependencyInjectionRepository();
+            services.AddMediaRHandlerDependency();
+            services.AddAutoMapperConfig();
+            services.AddSwaggerDocumentation();
             AddDatabase(services);
-
-            AddMediaRHandlerDependency(services);
-
-            services.AddAutoMapper(typeof(AutoMapperProfile));
-
-            services.AddSwaggerGen(c =>
-            {
-                c.SwaggerDoc("v2", new OpenApiInfo { Title = "Catalogue.Backend.API", Version = Assembly.GetEntryAssembly().GetCustomAttribute<AssemblyInformationalVersionAttribute>().InformationalVersion });
-            });
-
-        }
-
-        private static void AddDataDependencyInjectionService(IServiceCollection services)
-        {
-            services.AddScoped<ITypeProprieteService, TypeProprieteService>();
-            services.AddScoped<IProprieteService, ProprieteService>();
-            services.AddScoped<IProduitService, ProduitService>();
-            services.AddScoped<ICommandeService, CommandeService>();
-            services.AddScoped<ILigneCommandeService, LigneCommandeService>();
-            services.AddSingleton<IHttpContextAccessor, HttpContextAccessor>();
         }
 
-        private static void AddMediaRHandlerDependency(IServiceCollection services)
-        {
-            services.AddMediatR(Assembly.GetExecutingAssembly());
-            services.AddMediatR(typeof(GetTypeProprieteListHandler).Assembly);
-            services.AddMediatR(typeof(AddTypeProprieteHandler).Assembly);
-            services.AddMediatR(typeof(RemoveTypeProprieteHandler).Assembly);
-
-            services.AddMediatR(typeof(GetProprieteListHandler).Assembly);
-            services.AddMediatR(typeof(AddProprieteHandler).Assembly);
-            services.AddMediatR(typeof(RemoveProprieteHandler).Assembly);
-
-            services.AddMediatR(typeof(GetProduitListHandler).Assembly);
-            services.AddMediatR(typeof(AddProduitHandler).Assembly);
-            services.AddMediatR(typeof(RemoveProduitHandler).Assembly);
 
-            services.AddMediatR(typeof(GetCommandeListHandler).Assembly);
-            services.AddMediatR(typeof(AddCommandeHandler).Assembly);
-            services.AddMediatR(typeof(RemoveCommandeHandler).Assembly);
 
-            services.AddMediatR(typeof(GetLigneCommandeListHandler).Assembly);
-            services.AddMediatR(typeof(AddLigneCommandeHandler).Assembly);
-            services.AddMediatR(typeof(RemoveLigneCommandeHandler).Assembly);
-        }
-
-        private static void AddDataDependencyInjectionRepository(IServiceCollection services)
-        {
-            services.AddScoped<IApplicationDatabaseContext, ApplicationDatabaseContext>();
-            services.AddScoped<ICommandeRepository, CommandeRepository>();
-            services.AddScoped<ILigneCommandeRepository, LigneCommandeRepository>();
-            services.AddScoped<IProduitRepository, ProduitRepository>();
-            services.AddScoped<IProprieteRepository, ProprieteRepository>();
-            services.AddScoped<ITypeProprieteRepository, TypeProprieteRepository>();
-        }
         protected virtual void AddDatabase(IServiceCollection services)
         {
             if (services != null)
                 endpoints.MapControllers();
             });
             app.UseApplicationDatabase(serviceProvider);
-            app.UseSwagger();
-            app.UseSwaggerUI(c => {
-                c.SwaggerEndpoint("/swagger/v2/swagger.json", "Catalogue.Backend.API");
-            });
+            app.UseSwaggerDocumentation();
         }
 
     

CatalogueCQRS/Backend.API/bin/Debug/netcoreapp3.1/Backend.API.deps.json

     ".NETCoreApp,Version=v3.1": {
       "Backend.API/1.0.0": {
         "dependencies": {
-          "AutoMapper": "10.1.1",
-          "AutoMapper.Extensions.Microsoft.DependencyInjection": "8.1.1",
-          "Backend.Common": "1.0.0",
-          "MediatR.Extensions.Microsoft.DependencyInjection": "7.0.0",
-          "Mediator": "1.0.0",
-          "Microsoft.EntityFrameworkCore": "5.0.13",
-          "Microsoft.EntityFrameworkCore.Tools": "5.0.13",
+          "Backend.ApplicationCore": "1.0.0",
+          "Backend.Domain": "1.0.0",
+          "Backend.Infrastructure": "1.0.0",
+          "Backend.Persistence": "1.0.0",
           "Microsoft.VisualStudio.Azure.Containers.Tools.Targets": "1.11.1",
-          "Pomelo.EntityFrameworkCore.MySql": "5.0.0-alpha.2",
           "Swashbuckle.AspNetCore.Swagger": "6.2.3",
           "Swashbuckle.AspNetCore.SwaggerGen": "6.2.3",
           "Swashbuckle.AspNetCore.SwaggerUI": "6.2.3",
       "AutoMapper.Extensions.Microsoft.DependencyInjection/8.1.1": {
         "dependencies": {
           "AutoMapper": "10.1.1",
-          "Microsoft.Extensions.DependencyInjection.Abstractions": "5.0.0",
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "6.0.0",
           "Microsoft.Extensions.Options": "5.0.0"
         },
         "runtime": {
           "lib/netstandard2.0/Google.Protobuf.dll": {}
         }
       },
-      "Humanizer.Core/2.8.26": {
-        "runtime": {
-          "lib/netstandard2.0/Humanizer.dll": {
-            "assemblyVersion": "2.8.0.0",
-            "fileVersion": "2.8.26.1919"
-          }
-        }
-      },
       "K4os.Compression.LZ4/1.1.11": {
         "dependencies": {
           "System.Memory": "4.5.3"
       "MediatR.Extensions.Microsoft.DependencyInjection/7.0.0": {
         "dependencies": {
           "MediatR": "7.0.0",
-          "Microsoft.Extensions.DependencyInjection.Abstractions": "5.0.0"
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "6.0.0"
         },
         "runtime": {
           "lib/netstandard2.0/MediatR.Extensions.Microsoft.DependencyInjection.dll": {
       },
       "Microsoft.AspNetCore.Identity.EntityFrameworkCore/5.0.10": {
         "dependencies": {
-          "Microsoft.EntityFrameworkCore.Relational": "5.0.13",
+          "Microsoft.EntityFrameworkCore.Relational": "5.0.10",
           "Microsoft.Extensions.Identity.Stores": "5.0.10"
         },
         "runtime": {
         }
       },
       "Microsoft.EntityFrameworkCore.Analyzers/5.0.13": {},
-      "Microsoft.EntityFrameworkCore.Design/5.0.13": {
-        "dependencies": {
-          "Humanizer.Core": "2.8.26",
-          "Microsoft.CSharp": "4.7.0",
-          "Microsoft.EntityFrameworkCore.Relational": "5.0.13"
-        },
-        "runtime": {
-          "lib/netstandard2.1/Microsoft.EntityFrameworkCore.Design.dll": {
-            "assemblyVersion": "5.0.13.0",
-            "fileVersion": "5.0.1321.56013"
-          }
-        }
-      },
-      "Microsoft.EntityFrameworkCore.Relational/5.0.13": {
+      "Microsoft.EntityFrameworkCore.Relational/5.0.10": {
         "dependencies": {
           "Microsoft.EntityFrameworkCore": "5.0.13",
           "Microsoft.Extensions.Configuration.Abstractions": "6.0.0"
         },
         "runtime": {
           "lib/netstandard2.1/Microsoft.EntityFrameworkCore.Relational.dll": {
-            "assemblyVersion": "5.0.13.0",
-            "fileVersion": "5.0.1321.56013"
+            "assemblyVersion": "5.0.10.0",
+            "fileVersion": "5.0.1021.41011"
           }
         },
         "compile": {
           "lib/netstandard2.1/Microsoft.EntityFrameworkCore.Relational.dll": {}
         }
       },
-      "Microsoft.EntityFrameworkCore.Tools/5.0.13": {
-        "dependencies": {
-          "Microsoft.EntityFrameworkCore.Design": "5.0.13"
-        }
-      },
       "Microsoft.Extensions.Caching.Abstractions/5.0.0": {
         "dependencies": {
           "Microsoft.Extensions.Primitives": "6.0.0"
       "Microsoft.Extensions.Caching.Memory/5.0.0": {
         "dependencies": {
           "Microsoft.Extensions.Caching.Abstractions": "5.0.0",
-          "Microsoft.Extensions.DependencyInjection.Abstractions": "5.0.0",
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "6.0.0",
           "Microsoft.Extensions.Logging.Abstractions": "5.0.0",
           "Microsoft.Extensions.Options": "5.0.0",
           "Microsoft.Extensions.Primitives": "6.0.0"
       },
       "Microsoft.Extensions.DependencyInjection/5.0.2": {
         "dependencies": {
-          "Microsoft.Extensions.DependencyInjection.Abstractions": "5.0.0"
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "6.0.0"
         },
         "runtime": {
           "lib/netstandard2.1/Microsoft.Extensions.DependencyInjection.dll": {
           "lib/netstandard2.1/Microsoft.Extensions.DependencyInjection.dll": {}
         }
       },
-      "Microsoft.Extensions.DependencyInjection.Abstractions/5.0.0": {
+      "Microsoft.Extensions.DependencyInjection.Abstractions/6.0.0": {
         "runtime": {
-          "lib/netstandard2.0/Microsoft.Extensions.DependencyInjection.Abstractions.dll": {
-            "assemblyVersion": "5.0.0.0",
-            "fileVersion": "5.0.20.51904"
+          "lib/netstandard2.1/Microsoft.Extensions.DependencyInjection.Abstractions.dll": {
+            "assemblyVersion": "6.0.0.0",
+            "fileVersion": "6.0.21.52210"
           }
         },
         "compile": {
-          "lib/netstandard2.0/Microsoft.Extensions.DependencyInjection.Abstractions.dll": {}
+          "lib/netstandard2.1/Microsoft.Extensions.DependencyInjection.Abstractions.dll": {}
         }
       },
       "Microsoft.Extensions.Identity.Core/5.0.10": {
       "Microsoft.Extensions.Logging/5.0.0": {
         "dependencies": {
           "Microsoft.Extensions.DependencyInjection": "5.0.2",
-          "Microsoft.Extensions.DependencyInjection.Abstractions": "5.0.0",
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "6.0.0",
           "Microsoft.Extensions.Logging.Abstractions": "5.0.0",
           "Microsoft.Extensions.Options": "5.0.0",
           "System.Diagnostics.DiagnosticSource": "5.0.1"
       },
       "Microsoft.Extensions.Options/5.0.0": {
         "dependencies": {
-          "Microsoft.Extensions.DependencyInjection.Abstractions": "5.0.0",
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "6.0.0",
           "Microsoft.Extensions.Primitives": "6.0.0"
         },
         "runtime": {
       },
       "MySql.Data.EntityFrameworkCore/8.0.22": {
         "dependencies": {
-          "Microsoft.EntityFrameworkCore.Relational": "5.0.13",
+          "Microsoft.EntityFrameworkCore.Relational": "5.0.10",
           "MySql.Data": "8.0.22"
         },
         "runtime": {
       },
       "Pomelo.EntityFrameworkCore.MySql/5.0.0-alpha.2": {
         "dependencies": {
-          "Microsoft.EntityFrameworkCore.Relational": "5.0.13",
+          "Microsoft.EntityFrameworkCore.Relational": "5.0.10",
           "MySqlConnector": "1.1.0"
         },
         "runtime": {
           "ref/netstandard1.3/System.Xml.XPath.XmlDocument.dll": {}
         }
       },
-      "Backend.Common/1.0.0": {
-        "runtime": {
-          "Backend.Common.dll": {}
-        },
-        "compile": {
-          "Backend.Common.dll": {}
-        }
-      },
-      "Backend.Data/1.0.0": {
+      "Backend.ApplicationCore/1.0.0": {
         "dependencies": {
-          "Microsoft.AspNet.Identity.EntityFramework": "2.2.3",
-          "Microsoft.AspNetCore.Http.Abstractions": "2.2.0",
-          "Microsoft.AspNetCore.Identity.EntityFrameworkCore": "5.0.10",
-          "Microsoft.EntityFrameworkCore": "5.0.13",
-          "Microsoft.Extensions.Configuration.Abstractions": "6.0.0",
-          "MySql.Data.EntityFrameworkCore": "8.0.22",
-          "Pomelo.EntityFrameworkCore.MySql": "5.0.0-alpha.2",
-          "System.Data.SqlClient": "4.8.3"
+          "AutoMapper": "10.1.1",
+          "AutoMapper.Extensions.Microsoft.DependencyInjection": "8.1.1",
+          "Backend.Domain": "1.0.0",
+          "MediatR": "7.0.0",
+          "MediatR.Extensions.Microsoft.DependencyInjection": "7.0.0",
+          "Microsoft.EntityFrameworkCore": "5.0.13"
         },
         "runtime": {
-          "Backend.Data.dll": {}
+          "Backend.ApplicationCore.dll": {}
         },
         "compile": {
-          "Backend.Data.dll": {}
+          "Backend.ApplicationCore.dll": {}
         }
       },
-      "Backend.Models/1.0.0": {
+      "Backend.Domain/1.0.0": {
         "runtime": {
-          "Backend.Models.dll": {}
+          "Backend.Domain.dll": {}
         },
         "compile": {
-          "Backend.Models.dll": {}
+          "Backend.Domain.dll": {}
         }
       },
-      "Backend.Services/1.0.0": {
+      "Backend.Infrastructure/1.0.0": {
         "dependencies": {
-          "AutoMapper": "10.1.1",
-          "Backend.Common": "1.0.0",
-          "Backend.Data": "1.0.0",
-          "Backend.Models": "1.0.0"
+          "Backend.ApplicationCore": "1.0.0",
+          "Backend.Domain": "1.0.0"
         },
         "runtime": {
-          "Backend.Services.dll": {}
+          "Backend.Infrastructure.dll": {}
         },
         "compile": {
-          "Backend.Services.dll": {}
+          "Backend.Infrastructure.dll": {}
         }
       },
-      "Mediator/1.0.0": {
+      "Backend.Persistence/1.0.0": {
         "dependencies": {
-          "Backend.Common": "1.0.0",
-          "Backend.Models": "1.0.0",
-          "Backend.Services": "1.0.0",
-          "MediatR": "7.0.0",
-          "MediatR.Extensions.Microsoft.DependencyInjection": "7.0.0"
+          "Backend.ApplicationCore": "1.0.0",
+          "Microsoft.AspNet.Identity.EntityFramework": "2.2.3",
+          "Microsoft.AspNetCore.Http.Abstractions": "2.2.0",
+          "Microsoft.AspNetCore.Identity.EntityFrameworkCore": "5.0.10",
+          "Microsoft.EntityFrameworkCore": "5.0.13",
+          "Microsoft.Extensions.Configuration.Abstractions": "6.0.0",
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "6.0.0",
+          "MySql.Data.EntityFrameworkCore": "8.0.22",
+          "Pomelo.EntityFrameworkCore.MySql": "5.0.0-alpha.2",
+          "System.Data.SqlClient": "4.8.3"
         },
         "runtime": {
-          "Mediator.dll": {}
+          "Backend.Persistence.dll": {}
         },
         "compile": {
-          "Mediator.dll": {}
+          "Backend.Persistence.dll": {}
         }
       },
       "Microsoft.AspNetCore.Antiforgery/3.1.0.0": {
       "path": "google.protobuf/3.11.4",
       "hashPath": "google.protobuf.3.11.4.nupkg.sha512"
     },
-    "Humanizer.Core/2.8.26": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-OiKusGL20vby4uDEswj2IgkdchC1yQ6rwbIkZDVBPIR6al2b7n3pC91elBul9q33KaBgRKhbZH3+2Ur4fnWx2A==",
-      "path": "humanizer.core/2.8.26",
-      "hashPath": "humanizer.core.2.8.26.nupkg.sha512"
-    },
     "K4os.Compression.LZ4/1.1.11": {
       "type": "package",
       "serviceable": true,
       "path": "microsoft.entityframeworkcore.analyzers/5.0.13",
       "hashPath": "microsoft.entityframeworkcore.analyzers.5.0.13.nupkg.sha512"
     },
-    "Microsoft.EntityFrameworkCore.Design/5.0.13": {
+    "Microsoft.EntityFrameworkCore.Relational/5.0.10": {
       "type": "package",
       "serviceable": true,
-      "sha512": "sha512-T9Qq5RebYkx2EEU7ahHNediObrIE5dsRKt6mTkVwqrVqX1Kp+/HD02T1ZMdI1H62WLHH4QIdcCfjgsKgenTQFg==",
-      "path": "microsoft.entityframeworkcore.design/5.0.13",
-      "hashPath": "microsoft.entityframeworkcore.design.5.0.13.nupkg.sha512"
-    },
-    "Microsoft.EntityFrameworkCore.Relational/5.0.13": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-Qs7N0HFemByf04PZHvn2ZFytveLZyZKCmuNcMus1f53uNarypvWifrOC7L/wYylm/j8vs3qcc7jgb/yox1sbtg==",
-      "path": "microsoft.entityframeworkcore.relational/5.0.13",
-      "hashPath": "microsoft.entityframeworkcore.relational.5.0.13.nupkg.sha512"
-    },
-    "Microsoft.EntityFrameworkCore.Tools/5.0.13": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-i/46k4pfCBMb2LVjLqHAbBO8WsAaB+CKbe8oF9ZBTtjVqyEJAxSpn8IZcvajY2KJmM7lc3zgyUdaommvxH2ClA==",
-      "path": "microsoft.entityframeworkcore.tools/5.0.13",
-      "hashPath": "microsoft.entityframeworkcore.tools.5.0.13.nupkg.sha512"
+      "sha512": "sha512-3l7GA+0y5E3kDOl85KRHhC0zXYA/CyQBQqDXvFGkqYzdPMRyWQkaQz2+yN4CN/SC+TVa48FPIAc2Wim8aWAliQ==",
+      "path": "microsoft.entityframeworkcore.relational/5.0.10",
+      "hashPath": "microsoft.entityframeworkcore.relational.5.0.10.nupkg.sha512"
     },
     "Microsoft.Extensions.Caching.Abstractions/5.0.0": {
       "type": "package",
       "path": "microsoft.extensions.dependencyinjection/5.0.2",
       "hashPath": "microsoft.extensions.dependencyinjection.5.0.2.nupkg.sha512"
     },
-    "Microsoft.Extensions.DependencyInjection.Abstractions/5.0.0": {
+    "Microsoft.Extensions.DependencyInjection.Abstractions/6.0.0": {
       "type": "package",
       "serviceable": true,
-      "sha512": "sha512-ORj7Zh81gC69TyvmcUm9tSzytcy8AVousi+IVRAI8nLieQjOFryRusSFh7+aLk16FN9pQNqJAiMd7BTKINK0kA==",
-      "path": "microsoft.extensions.dependencyinjection.abstractions/5.0.0",
-      "hashPath": "microsoft.extensions.dependencyinjection.abstractions.5.0.0.nupkg.sha512"
+      "sha512": "sha512-xlzi2IYREJH3/m6+lUrQlujzX8wDitm4QGnUu6kUXTQAWPuZY8i+ticFJbzfqaetLA6KR/rO6Ew/HuYD+bxifg==",
+      "path": "microsoft.extensions.dependencyinjection.abstractions/6.0.0",
+      "hashPath": "microsoft.extensions.dependencyinjection.abstractions.6.0.0.nupkg.sha512"
     },
     "Microsoft.Extensions.Identity.Core/5.0.10": {
       "type": "package",
       "path": "system.xml.xpath.xmldocument/4.0.1",
       "hashPath": "system.xml.xpath.xmldocument.4.0.1.nupkg.sha512"
     },
-    "Backend.Common/1.0.0": {
-      "type": "project",
-      "serviceable": false,
-      "sha512": ""
-    },
-    "Backend.Data/1.0.0": {
+    "Backend.ApplicationCore/1.0.0": {
       "type": "project",
       "serviceable": false,
       "sha512": ""
     },
-    "Backend.Models/1.0.0": {
+    "Backend.Domain/1.0.0": {
       "type": "project",
       "serviceable": false,
       "sha512": ""
     },
-    "Backend.Services/1.0.0": {
+    "Backend.Infrastructure/1.0.0": {
       "type": "project",
       "serviceable": false,
       "sha512": ""
     },
-    "Mediator/1.0.0": {
+    "Backend.Persistence/1.0.0": {
       "type": "project",
       "serviceable": false,
       "sha512": ""

CatalogueCQRS/Backend.API/obj/Backend.API.csproj.nuget.dgspec.json

           "netcoreapp3.1": {
             "targetAlias": "netcoreapp3.1",
             "projectReferences": {
-              "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Common\\Backend.Common.csproj": {
-                "projectPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Common\\Backend.Common.csproj"
+              "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Common\\Backend.Domain.csproj": {
+                "projectPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Common\\Backend.Domain.csproj"
               },
-              "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Mediator\\Mediator.csproj": {
-                "projectPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Mediator\\Mediator.csproj"
+              "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Data\\Backend.Infrastructure.csproj": {
+                "projectPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Data\\Backend.Infrastructure.csproj"
+              },
+              "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.EFCore\\Backend.Persistence.csproj": {
+                "projectPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.EFCore\\Backend.Persistence.csproj"
+              },
+              "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Services\\Backend.ApplicationCore.csproj": {
+                "projectPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Services\\Backend.ApplicationCore.csproj"
               }
             }
           }
         "netcoreapp3.1": {
           "targetAlias": "netcoreapp3.1",
           "dependencies": {
-            "AutoMapper": {
-              "target": "Package",
-              "version": "[10.1.1, )"
-            },
-            "AutoMapper.Extensions.Microsoft.DependencyInjection": {
-              "target": "Package",
-              "version": "[8.1.1, )"
-            },
-            "MediatR.Extensions.Microsoft.DependencyInjection": {
-              "target": "Package",
-              "version": "[7.0.0, )"
-            },
-            "Microsoft.EntityFrameworkCore": {
-              "target": "Package",
-              "version": "[5.0.13, )"
-            },
-            "Microsoft.EntityFrameworkCore.Tools": {
-              "include": "Runtime, Build, Native, ContentFiles, Analyzers, BuildTransitive",
-              "suppressParent": "All",
-              "target": "Package",
-              "version": "[5.0.13, )"
-            },
             "Microsoft.VisualStudio.Azure.Containers.Tools.Targets": {
               "target": "Package",
               "version": "[1.11.1, )"
             },
-            "Pomelo.EntityFrameworkCore.MySql": {
-              "target": "Package",
-              "version": "[5.0.0-alpha.2, )"
-            },
             "Swashbuckle.AspNetCore.Swagger": {
               "target": "Package",
               "version": "[6.2.3, )"
         }
       }
     },
-    "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Common\\Backend.Common.csproj": {
+    "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Common\\Backend.Domain.csproj": {
       "version": "1.0.0",
       "restore": {
-        "projectUniqueName": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Common\\Backend.Common.csproj",
-        "projectName": "Backend.Common",
-        "projectPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Common\\Backend.Common.csproj",
+        "projectUniqueName": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Common\\Backend.Domain.csproj",
+        "projectName": "Backend.Domain",
+        "projectPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Common\\Backend.Domain.csproj",
         "packagesPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\.nuget\\packages\\",
         "outputPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Common\\obj\\",
         "projectStyle": "PackageReference",
         }
       }
     },
-    "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Data\\Backend.Data.csproj": {
+    "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Data\\Backend.Infrastructure.csproj": {
       "version": "1.0.0",
       "restore": {
-        "projectUniqueName": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Data\\Backend.Data.csproj",
-        "projectName": "Backend.Data",
-        "projectPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Data\\Backend.Data.csproj",
+        "projectUniqueName": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Data\\Backend.Infrastructure.csproj",
+        "projectName": "Backend.Infrastructure",
+        "projectPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Data\\Backend.Infrastructure.csproj",
         "packagesPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\.nuget\\packages\\",
         "outputPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Data\\obj\\",
         "projectStyle": "PackageReference",
         "frameworks": {
           "netcoreapp3.1": {
             "targetAlias": "netcoreapp3.1",
-            "projectReferences": {}
-          }
-        },
-        "warningProperties": {
-          "warnAsError": [
-            "NU1605"
-          ]
-        }
-      },
-      "frameworks": {
-        "netcoreapp3.1": {
-          "targetAlias": "netcoreapp3.1",
-          "dependencies": {
-            "Microsoft.AspNet.Identity.EntityFramework": {
-              "target": "Package",
-              "version": "[2.2.3, )"
-            },
-            "Microsoft.AspNetCore.Http.Abstractions": {
-              "target": "Package",
-              "version": "[2.2.0, )"
-            },
-            "Microsoft.AspNetCore.Identity.EntityFrameworkCore": {
-              "target": "Package",
-              "version": "[5.0.10, )"
-            },
-            "Microsoft.EntityFrameworkCore": {
-              "target": "Package",
-              "version": "[5.0.10, )"
-            },
-            "Microsoft.Extensions.Configuration.Abstractions": {
-              "target": "Package",
-              "version": "[6.0.0, )"
-            },
-            "MySql.Data.EntityFrameworkCore": {
-              "target": "Package",
-              "version": "[8.0.22, )"
-            },
-            "Pomelo.EntityFrameworkCore.MySql": {
-              "target": "Package",
-              "version": "[5.0.0-alpha.2, )"
-            },
-            "System.Data.SqlClient": {
-              "target": "Package",
-              "version": "[4.8.3, )"
-            }
-          },
-          "imports": [
-            "net461",
-            "net462",
-            "net47",
-            "net471",
-            "net472",
-            "net48"
-          ],
-          "assetTargetFallback": true,
-          "warn": true,
-          "frameworkReferences": {
-            "Microsoft.NETCore.App": {
-              "privateAssets": "all"
+            "projectReferences": {
+              "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Common\\Backend.Domain.csproj": {
+                "projectPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Common\\Backend.Domain.csproj"
+              },
+              "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Services\\Backend.ApplicationCore.csproj": {
+                "projectPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Services\\Backend.ApplicationCore.csproj"
+              }
             }
-          },
-          "runtimeIdentifierGraphPath": "C:\\Program Files\\dotnet\\sdk\\5.0.403\\RuntimeIdentifierGraph.json"
-        }
-      }
-    },
-    "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Models\\Backend.Models.csproj": {
-      "version": "1.0.0",
-      "restore": {
-        "projectUniqueName": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Models\\Backend.Models.csproj",
-        "projectName": "Backend.Models",
-        "projectPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Models\\Backend.Models.csproj",
-        "packagesPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\.nuget\\packages\\",
-        "outputPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Models\\obj\\",
-        "projectStyle": "PackageReference",
-        "configFilePaths": [
-          "C:\\Users\\Alex ONDOA BALEGNAMA\\AppData\\Roaming\\NuGet\\NuGet.Config",
-          "C:\\Program Files (x86)\\NuGet\\Config\\Microsoft.VisualStudio.Offline.config"
-        ],
-        "originalTargetFrameworks": [
-          "netcoreapp3.1"
-        ],
-        "sources": {
-          "C:\\Program Files (x86)\\Microsoft SDKs\\NuGetPackages\\": {},
-          "https://api.nuget.org/v3/index.json": {},
-          "https://packagesource": {}
-        },
-        "frameworks": {
-          "netcoreapp3.1": {
-            "targetAlias": "netcoreapp3.1",
-            "projectReferences": {}
           }
         },
         "warningProperties": {
         }
       }
     },
-    "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Services\\Backend.Services.csproj": {
+    "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.EFCore\\Backend.Persistence.csproj": {
       "version": "1.0.0",
       "restore": {
-        "projectUniqueName": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Services\\Backend.Services.csproj",
-        "projectName": "Backend.Services",
-        "projectPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Services\\Backend.Services.csproj",
+        "projectUniqueName": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.EFCore\\Backend.Persistence.csproj",
+        "projectName": "Backend.Persistence",
+        "projectPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.EFCore\\Backend.Persistence.csproj",
         "packagesPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\.nuget\\packages\\",
-        "outputPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Services\\obj\\",
+        "outputPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.EFCore\\obj\\",
         "projectStyle": "PackageReference",
         "configFilePaths": [
           "C:\\Users\\Alex ONDOA BALEGNAMA\\AppData\\Roaming\\NuGet\\NuGet.Config",
           "netcoreapp3.1": {
             "targetAlias": "netcoreapp3.1",
             "projectReferences": {
-              "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Common\\Backend.Common.csproj": {
-                "projectPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Common\\Backend.Common.csproj"
-              },
-              "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Data\\Backend.Data.csproj": {
-                "projectPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Data\\Backend.Data.csproj"
-              },
-              "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Models\\Backend.Models.csproj": {
-                "projectPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Models\\Backend.Models.csproj"
+              "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Services\\Backend.ApplicationCore.csproj": {
+                "projectPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Services\\Backend.ApplicationCore.csproj"
               }
             }
           }
         "netcoreapp3.1": {
           "targetAlias": "netcoreapp3.1",
           "dependencies": {
-            "AutoMapper": {
+            "Microsoft.AspNet.Identity.EntityFramework": {
               "target": "Package",
-              "version": "[10.1.1, )"
+              "version": "[2.2.3, )"
+            },
+            "Microsoft.AspNetCore.Http.Abstractions": {
+              "target": "Package",
+              "version": "[2.2.0, )"
+            },
+            "Microsoft.AspNetCore.Identity.EntityFrameworkCore": {
+              "target": "Package",
+              "version": "[5.0.10, )"
+            },
+            "Microsoft.EntityFrameworkCore": {
+              "target": "Package",
+              "version": "[5.0.13, )"
+            },
+            "Microsoft.Extensions.Configuration.Abstractions": {
+              "target": "Package",
+              "version": "[6.0.0, )"
+            },
+            "Microsoft.Extensions.DependencyInjection.Abstractions": {
+              "target": "Package",
+              "version": "[6.0.0, )"
+            },
+            "MySql.Data.EntityFrameworkCore": {
+              "target": "Package",
+              "version": "[8.0.22, )"
+            },
+            "Pomelo.EntityFrameworkCore.MySql": {
+              "target": "Package",
+              "version": "[5.0.0-alpha.2, )"
+            },
+            "System.Data.SqlClient": {
+              "target": "Package",
+              "version": "[4.8.3, )"
             }
           },
           "imports": [
         }
       }
     },
-    "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Mediator\\Mediator.csproj": {
+    "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Services\\Backend.ApplicationCore.csproj": {
       "version": "1.0.0",
       "restore": {
-        "projectUniqueName": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Mediator\\Mediator.csproj",
-        "projectName": "Mediator",
-        "projectPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Mediator\\Mediator.csproj",
+        "projectUniqueName": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Services\\Backend.ApplicationCore.csproj",
+        "projectName": "Backend.ApplicationCore",
+        "projectPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Services\\Backend.ApplicationCore.csproj",
         "packagesPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\.nuget\\packages\\",
-        "outputPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Mediator\\obj\\",
+        "outputPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Services\\obj\\",
         "projectStyle": "PackageReference",
         "configFilePaths": [
           "C:\\Users\\Alex ONDOA BALEGNAMA\\AppData\\Roaming\\NuGet\\NuGet.Config",
           "netcoreapp3.1": {
             "targetAlias": "netcoreapp3.1",
             "projectReferences": {
-              "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Common\\Backend.Common.csproj": {
-                "projectPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Common\\Backend.Common.csproj"
-              },
-              "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Models\\Backend.Models.csproj": {
-                "projectPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Models\\Backend.Models.csproj"
-              },
-              "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Services\\Backend.Services.csproj": {
-                "projectPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Services\\Backend.Services.csproj"
+              "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Common\\Backend.Domain.csproj": {
+                "projectPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Common\\Backend.Domain.csproj"
               }
             }
           }
         "netcoreapp3.1": {
           "targetAlias": "netcoreapp3.1",
           "dependencies": {
+            "AutoMapper": {
+              "target": "Package",
+              "version": "[10.1.1, )"
+            },
+            "AutoMapper.Extensions.Microsoft.DependencyInjection": {
+              "target": "Package",
+              "version": "[8.1.1, )"
+            },
             "MediatR": {
               "target": "Package",
               "version": "[7.0.0, )"
             "MediatR.Extensions.Microsoft.DependencyInjection": {
               "target": "Package",
               "version": "[7.0.0, )"
+            },
+            "Microsoft.EntityFrameworkCore": {
+              "target": "Package",
+              "version": "[5.0.13, )"
             }
           },
           "imports": [

CatalogueCQRS/Backend.API/obj/Backend.API.csproj.nuget.g.props

   </PropertyGroup>
   <ImportGroup Condition=" '$(ExcludeRestorePackageImports)' != 'true' ">
     <Import Project="$(NuGetPackageRoot)microsoft.visualstudio.azure.containers.tools.targets\1.11.1\build\Microsoft.VisualStudio.Azure.Containers.Tools.Targets.props" Condition="Exists('$(NuGetPackageRoot)microsoft.visualstudio.azure.containers.tools.targets\1.11.1\build\Microsoft.VisualStudio.Azure.Containers.Tools.Targets.props')" />
-    <Import Project="$(NuGetPackageRoot)microsoft.entityframeworkcore.design\5.0.13\build\netcoreapp3.0\Microsoft.EntityFrameworkCore.Design.props" Condition="Exists('$(NuGetPackageRoot)microsoft.entityframeworkcore.design\5.0.13\build\netcoreapp3.0\Microsoft.EntityFrameworkCore.Design.props')" />
   </ImportGroup>
   <PropertyGroup Condition=" '$(ExcludeRestorePackageImports)' != 'true' ">
     <PkgMicrosoft_VisualStudio_Azure_Containers_Tools_Targets Condition=" '$(PkgMicrosoft_VisualStudio_Azure_Containers_Tools_Targets)' == '' ">C:\Users\Alex ONDOA BALEGNAMA\.nuget\packages\microsoft.visualstudio.azure.containers.tools.targets\1.11.1</PkgMicrosoft_VisualStudio_Azure_Containers_Tools_Targets>
-    <PkgMicrosoft_EntityFrameworkCore_Tools Condition=" '$(PkgMicrosoft_EntityFrameworkCore_Tools)' == '' ">C:\Users\Alex ONDOA BALEGNAMA\.nuget\packages\microsoft.entityframeworkcore.tools\5.0.13</PkgMicrosoft_EntityFrameworkCore_Tools>
     <PkgEntityFramework Condition=" '$(PkgEntityFramework)' == '' ">C:\Users\Alex ONDOA BALEGNAMA\.nuget\packages\entityframework\6.1.0</PkgEntityFramework>
   </PropertyGroup>
 </Project>

CatalogueCQRS/Backend.API/obj/Debug/netcoreapp3.1/Backend.API.csproj.CoreCompileInputs.cache

-c5ca32b5928f1d07475c1989500f6b626cf78b74
+dabb2f105efe36cf384678feec31f6fdf2df0214

CatalogueCQRS/Backend.API/obj/Debug/netcoreapp3.1/Backend.API.csproj.FileListAbsolute.txt

 C:\Users\Alex ONDOA BALEGNAMA\source\repos\Backend\CatalogueCQRS\Backend.API\bin\Debug\netcoreapp3.1\EntityFramework.SqlServer.dll
 C:\Users\Alex ONDOA BALEGNAMA\source\repos\Backend\CatalogueCQRS\Backend.API\bin\Debug\netcoreapp3.1\EntityFramework.dll
 C:\Users\Alex ONDOA BALEGNAMA\source\repos\Backend\CatalogueCQRS\Backend.API\bin\Debug\netcoreapp3.1\Google.Protobuf.dll
-C:\Users\Alex ONDOA BALEGNAMA\source\repos\Backend\CatalogueCQRS\Backend.API\bin\Debug\netcoreapp3.1\Humanizer.dll
 C:\Users\Alex ONDOA BALEGNAMA\source\repos\Backend\CatalogueCQRS\Backend.API\bin\Debug\netcoreapp3.1\K4os.Compression.LZ4.dll
 C:\Users\Alex ONDOA BALEGNAMA\source\repos\Backend\CatalogueCQRS\Backend.API\bin\Debug\netcoreapp3.1\K4os.Compression.LZ4.Streams.dll
 C:\Users\Alex ONDOA BALEGNAMA\source\repos\Backend\CatalogueCQRS\Backend.API\bin\Debug\netcoreapp3.1\K4os.Hash.xxHash.dll
 C:\Users\Alex ONDOA BALEGNAMA\source\repos\Backend\CatalogueCQRS\Backend.API\bin\Debug\netcoreapp3.1\Microsoft.AspNetCore.Identity.EntityFrameworkCore.dll
 C:\Users\Alex ONDOA BALEGNAMA\source\repos\Backend\CatalogueCQRS\Backend.API\bin\Debug\netcoreapp3.1\Microsoft.EntityFrameworkCore.dll
 C:\Users\Alex ONDOA BALEGNAMA\source\repos\Backend\CatalogueCQRS\Backend.API\bin\Debug\netcoreapp3.1\Microsoft.EntityFrameworkCore.Abstractions.dll
-C:\Users\Alex ONDOA BALEGNAMA\source\repos\Backend\CatalogueCQRS\Backend.API\bin\Debug\netcoreapp3.1\Microsoft.EntityFrameworkCore.Design.dll
 C:\Users\Alex ONDOA BALEGNAMA\source\repos\Backend\CatalogueCQRS\Backend.API\bin\Debug\netcoreapp3.1\Microsoft.EntityFrameworkCore.Relational.dll
 C:\Users\Alex ONDOA BALEGNAMA\source\repos\Backend\CatalogueCQRS\Backend.API\bin\Debug\netcoreapp3.1\Microsoft.Extensions.Caching.Abstractions.dll
 C:\Users\Alex ONDOA BALEGNAMA\source\repos\Backend\CatalogueCQRS\Backend.API\bin\Debug\netcoreapp3.1\Microsoft.Extensions.Caching.Memory.dll
 C:\Users\Alex ONDOA BALEGNAMA\source\repos\Backend\CatalogueCQRS\Backend.API\bin\Debug\netcoreapp3.1\runtimes\unix\lib\netcoreapp2.1\System.Data.SqlClient.dll
 C:\Users\Alex ONDOA BALEGNAMA\source\repos\Backend\CatalogueCQRS\Backend.API\bin\Debug\netcoreapp3.1\runtimes\win\lib\netcoreapp2.1\System.Data.SqlClient.dll
 C:\Users\Alex ONDOA BALEGNAMA\source\repos\Backend\CatalogueCQRS\Backend.API\bin\Debug\netcoreapp3.1\runtimes\win\lib\netstandard2.0\System.Security.Cryptography.ProtectedData.dll
-C:\Users\Alex ONDOA BALEGNAMA\source\repos\Backend\CatalogueCQRS\Backend.API\bin\Debug\netcoreapp3.1\Backend.Common.dll
-C:\Users\Alex ONDOA BALEGNAMA\source\repos\Backend\CatalogueCQRS\Backend.API\bin\Debug\netcoreapp3.1\Backend.Data.dll
-C:\Users\Alex ONDOA BALEGNAMA\source\repos\Backend\CatalogueCQRS\Backend.API\bin\Debug\netcoreapp3.1\Backend.Models.dll
-C:\Users\Alex ONDOA BALEGNAMA\source\repos\Backend\CatalogueCQRS\Backend.API\bin\Debug\netcoreapp3.1\Backend.Services.dll
-C:\Users\Alex ONDOA BALEGNAMA\source\repos\Backend\CatalogueCQRS\Backend.API\bin\Debug\netcoreapp3.1\Mediator.dll
-C:\Users\Alex ONDOA BALEGNAMA\source\repos\Backend\CatalogueCQRS\Backend.API\bin\Debug\netcoreapp3.1\Backend.Common.pdb
-C:\Users\Alex ONDOA BALEGNAMA\source\repos\Backend\CatalogueCQRS\Backend.API\bin\Debug\netcoreapp3.1\Mediator.pdb
-C:\Users\Alex ONDOA BALEGNAMA\source\repos\Backend\CatalogueCQRS\Backend.API\bin\Debug\netcoreapp3.1\Backend.Data.pdb
-C:\Users\Alex ONDOA BALEGNAMA\source\repos\Backend\CatalogueCQRS\Backend.API\bin\Debug\netcoreapp3.1\Backend.Models.pdb
-C:\Users\Alex ONDOA BALEGNAMA\source\repos\Backend\CatalogueCQRS\Backend.API\bin\Debug\netcoreapp3.1\Backend.Services.pdb
+C:\Users\Alex ONDOA BALEGNAMA\source\repos\Backend\CatalogueCQRS\Backend.API\bin\Debug\netcoreapp3.1\Backend.ApplicationCore.dll
+C:\Users\Alex ONDOA BALEGNAMA\source\repos\Backend\CatalogueCQRS\Backend.API\bin\Debug\netcoreapp3.1\Backend.Domain.dll
+C:\Users\Alex ONDOA BALEGNAMA\source\repos\Backend\CatalogueCQRS\Backend.API\bin\Debug\netcoreapp3.1\Backend.Infrastructure.dll
+C:\Users\Alex ONDOA BALEGNAMA\source\repos\Backend\CatalogueCQRS\Backend.API\bin\Debug\netcoreapp3.1\Backend.Persistence.dll
+C:\Users\Alex ONDOA BALEGNAMA\source\repos\Backend\CatalogueCQRS\Backend.API\bin\Debug\netcoreapp3.1\Backend.Domain.pdb
+C:\Users\Alex ONDOA BALEGNAMA\source\repos\Backend\CatalogueCQRS\Backend.API\bin\Debug\netcoreapp3.1\Backend.Infrastructure.pdb
+C:\Users\Alex ONDOA BALEGNAMA\source\repos\Backend\CatalogueCQRS\Backend.API\bin\Debug\netcoreapp3.1\Backend.Persistence.pdb
+C:\Users\Alex ONDOA BALEGNAMA\source\repos\Backend\CatalogueCQRS\Backend.API\bin\Debug\netcoreapp3.1\Backend.ApplicationCore.pdb
 C:\Users\Alex ONDOA BALEGNAMA\source\repos\Backend\CatalogueCQRS\Backend.API\obj\Debug\netcoreapp3.1\Backend.API.csproj.AssemblyReference.cache
 C:\Users\Alex ONDOA BALEGNAMA\source\repos\Backend\CatalogueCQRS\Backend.API\obj\Debug\netcoreapp3.1\Backend.API.GeneratedMSBuildEditorConfig.editorconfig
 C:\Users\Alex ONDOA BALEGNAMA\source\repos\Backend\CatalogueCQRS\Backend.API\obj\Debug\netcoreapp3.1\Backend.API.AssemblyInfoInputs.cache

CatalogueCQRS/Backend.API/obj/project.assets.json

           "lib/netstandard2.0/Google.Protobuf.dll": {}
         }
       },
-      "Humanizer.Core/2.8.26": {
-        "type": "package",
-        "compile": {
-          "lib/netstandard2.0/_._": {}
-        },
-        "runtime": {
-          "lib/netstandard2.0/Humanizer.dll": {}
-        }
-      },
       "K4os.Compression.LZ4/1.1.11": {
         "type": "package",
         "dependencies": {
           "lib/netstandard2.0/_._": {}
         }
       },
-      "Microsoft.EntityFrameworkCore.Design/5.0.13": {
-        "type": "package",
-        "dependencies": {
-          "Humanizer.Core": "2.8.26",
-          "Microsoft.CSharp": "4.7.0",
-          "Microsoft.EntityFrameworkCore.Relational": "5.0.13"
-        },
-        "compile": {
-          "lib/netstandard2.1/_._": {}
-        },
-        "runtime": {
-          "lib/netstandard2.1/Microsoft.EntityFrameworkCore.Design.dll": {}
-        },
-        "build": {
-          "build/netcoreapp3.0/Microsoft.EntityFrameworkCore.Design.props": {}
-        }
-      },
-      "Microsoft.EntityFrameworkCore.Relational/5.0.13": {
+      "Microsoft.EntityFrameworkCore.Relational/5.0.10": {
         "type": "package",
         "dependencies": {
-          "Microsoft.EntityFrameworkCore": "5.0.13",
+          "Microsoft.EntityFrameworkCore": "5.0.10",
           "Microsoft.Extensions.Configuration.Abstractions": "5.0.0"
         },
         "compile": {
           "lib/netstandard2.1/Microsoft.EntityFrameworkCore.Relational.dll": {}
         }
       },
-      "Microsoft.EntityFrameworkCore.Tools/5.0.13": {
-        "type": "package",
-        "dependencies": {
-          "Microsoft.EntityFrameworkCore.Design": "5.0.13"
-        },
-        "compile": {
-          "lib/netstandard2.1/_._": {}
-        },
-        "runtime": {
-          "lib/netstandard2.1/_._": {}
-        }
-      },
       "Microsoft.Extensions.Caching.Abstractions/5.0.0": {
         "type": "package",
         "dependencies": {
           "lib/netstandard2.1/Microsoft.Extensions.DependencyInjection.dll": {}
         }
       },
-      "Microsoft.Extensions.DependencyInjection.Abstractions/5.0.0": {
+      "Microsoft.Extensions.DependencyInjection.Abstractions/6.0.0": {
         "type": "package",
         "compile": {
-          "lib/netstandard2.0/Microsoft.Extensions.DependencyInjection.Abstractions.dll": {}
+          "lib/netstandard2.1/Microsoft.Extensions.DependencyInjection.Abstractions.dll": {}
         },
         "runtime": {
-          "lib/netstandard2.0/Microsoft.Extensions.DependencyInjection.Abstractions.dll": {}
+          "lib/netstandard2.1/Microsoft.Extensions.DependencyInjection.Abstractions.dll": {}
+        },
+        "build": {
+          "buildTransitive/netcoreapp3.1/_._": {}
         }
       },
       "Microsoft.Extensions.Identity.Core/5.0.10": {
           "lib/netstandard1.3/System.Xml.XPath.XmlDocument.dll": {}
         }
       },
-      "Backend.Common/1.0.0": {
-        "type": "project",
-        "framework": ".NETCoreApp,Version=v3.1",
-        "compile": {
-          "bin/placeholder/Backend.Common.dll": {}
-        },
-        "runtime": {
-          "bin/placeholder/Backend.Common.dll": {}
-        }
-      },
-      "Backend.Data/1.0.0": {
+      "Backend.ApplicationCore/1.0.0": {
         "type": "project",
         "framework": ".NETCoreApp,Version=v3.1",
         "dependencies": {
-          "Microsoft.AspNet.Identity.EntityFramework": "2.2.3",
-          "Microsoft.AspNetCore.Http.Abstractions": "2.2.0",
-          "Microsoft.AspNetCore.Identity.EntityFrameworkCore": "5.0.10",
-          "Microsoft.EntityFrameworkCore": "5.0.10",
-          "Microsoft.Extensions.Configuration.Abstractions": "6.0.0",
-          "MySql.Data.EntityFrameworkCore": "8.0.22",
-          "Pomelo.EntityFrameworkCore.MySql": "5.0.0-alpha.2",
-          "System.Data.SqlClient": "4.8.3"
+          "AutoMapper": "10.1.1",
+          "AutoMapper.Extensions.Microsoft.DependencyInjection": "8.1.1",
+          "Backend.Domain": "1.0.0",
+          "MediatR": "7.0.0",
+          "MediatR.Extensions.Microsoft.DependencyInjection": "7.0.0",
+          "Microsoft.EntityFrameworkCore": "5.0.13"
         },
         "compile": {
-          "bin/placeholder/Backend.Data.dll": {}
+          "bin/placeholder/Backend.ApplicationCore.dll": {}
         },
         "runtime": {
-          "bin/placeholder/Backend.Data.dll": {}
+          "bin/placeholder/Backend.ApplicationCore.dll": {}
         }
       },
-      "Backend.Models/1.0.0": {
+      "Backend.Domain/1.0.0": {
         "type": "project",
         "framework": ".NETCoreApp,Version=v3.1",
         "compile": {
-          "bin/placeholder/Backend.Models.dll": {}
+          "bin/placeholder/Backend.Domain.dll": {}
         },
         "runtime": {
-          "bin/placeholder/Backend.Models.dll": {}
+          "bin/placeholder/Backend.Domain.dll": {}
         }
       },
-      "Backend.Services/1.0.0": {
+      "Backend.Infrastructure/1.0.0": {
         "type": "project",
         "framework": ".NETCoreApp,Version=v3.1",
         "dependencies": {
-          "AutoMapper": "10.1.1",
-          "Backend.Common": "1.0.0",
-          "Backend.Data": "1.0.0",
-          "Backend.Models": "1.0.0"
+          "Backend.ApplicationCore": "1.0.0",
+          "Backend.Domain": "1.0.0"
         },
         "compile": {
-          "bin/placeholder/Backend.Services.dll": {}
+          "bin/placeholder/Backend.Infrastructure.dll": {}
         },
         "runtime": {
-          "bin/placeholder/Backend.Services.dll": {}
+          "bin/placeholder/Backend.Infrastructure.dll": {}
         }
       },
-      "Mediator/1.0.0": {
+      "Backend.Persistence/1.0.0": {
         "type": "project",
         "framework": ".NETCoreApp,Version=v3.1",
         "dependencies": {
-          "Backend.Common": "1.0.0",
-          "Backend.Models": "1.0.0",
-          "Backend.Services": "1.0.0",
-          "MediatR": "7.0.0",
-          "MediatR.Extensions.Microsoft.DependencyInjection": "7.0.0"
+          "Backend.ApplicationCore": "1.0.0",
+          "Microsoft.AspNet.Identity.EntityFramework": "2.2.3",
+          "Microsoft.AspNetCore.Http.Abstractions": "2.2.0",
+          "Microsoft.AspNetCore.Identity.EntityFrameworkCore": "5.0.10",
+          "Microsoft.EntityFrameworkCore": "5.0.13",
+          "Microsoft.Extensions.Configuration.Abstractions": "6.0.0",
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "6.0.0",
+          "MySql.Data.EntityFrameworkCore": "8.0.22",
+          "Pomelo.EntityFrameworkCore.MySql": "5.0.0-alpha.2",
+          "System.Data.SqlClient": "4.8.3"
         },
         "compile": {
-          "bin/placeholder/Mediator.dll": {}
+          "bin/placeholder/Backend.Persistence.dll": {}
         },
         "runtime": {
-          "bin/placeholder/Mediator.dll": {}
+          "bin/placeholder/Backend.Persistence.dll": {}
         }
       }
     }
         "lib/netstandard2.0/Google.Protobuf.xml"
       ]
     },
-    "Humanizer.Core/2.8.26": {
-      "sha512": "OiKusGL20vby4uDEswj2IgkdchC1yQ6rwbIkZDVBPIR6al2b7n3pC91elBul9q33KaBgRKhbZH3+2Ur4fnWx2A==",
-      "type": "package",
-      "path": "humanizer.core/2.8.26",
-      "files": [
-        ".nupkg.metadata",
-        ".signature.p7s",
-        "humanizer.core.2.8.26.nupkg.sha512",
-        "humanizer.core.nuspec",
-        "lib/netstandard1.0/Humanizer.dll",
-        "lib/netstandard1.0/Humanizer.xml",
-        "lib/netstandard2.0/Humanizer.dll",
-        "lib/netstandard2.0/Humanizer.xml",
-        "logo.png"
-      ]
-    },
     "K4os.Compression.LZ4/1.1.11": {
       "sha512": "RNvJw0UGkedPhCqVBNIogtfQebY+bQt0PN7xDbVe5LWLra0ZEqPfjPSl7iStj3rgDnkqkkTTpm+vCX3hU1qKmA==",
       "type": "package",
         "microsoft.entityframeworkcore.analyzers.nuspec"
       ]
     },
-    "Microsoft.EntityFrameworkCore.Design/5.0.13": {
-      "sha512": "T9Qq5RebYkx2EEU7ahHNediObrIE5dsRKt6mTkVwqrVqX1Kp+/HD02T1ZMdI1H62WLHH4QIdcCfjgsKgenTQFg==",
+    "Microsoft.EntityFrameworkCore.Relational/5.0.10": {
+      "sha512": "3l7GA+0y5E3kDOl85KRHhC0zXYA/CyQBQqDXvFGkqYzdPMRyWQkaQz2+yN4CN/SC+TVa48FPIAc2Wim8aWAliQ==",
       "type": "package",
-      "path": "microsoft.entityframeworkcore.design/5.0.13",
-      "files": [
-        ".nupkg.metadata",
-        ".signature.p7s",
-        "Icon.png",
-        "build/netcoreapp3.0/Microsoft.EntityFrameworkCore.Design.props",
-        "lib/netstandard2.1/Microsoft.EntityFrameworkCore.Design.dll",
-        "lib/netstandard2.1/Microsoft.EntityFrameworkCore.Design.xml",
-        "microsoft.entityframeworkcore.design.5.0.13.nupkg.sha512",
-        "microsoft.entityframeworkcore.design.nuspec"
-      ]
-    },
-    "Microsoft.EntityFrameworkCore.Relational/5.0.13": {
-      "sha512": "Qs7N0HFemByf04PZHvn2ZFytveLZyZKCmuNcMus1f53uNarypvWifrOC7L/wYylm/j8vs3qcc7jgb/yox1sbtg==",
-      "type": "package",
-      "path": "microsoft.entityframeworkcore.relational/5.0.13",
+      "path": "microsoft.entityframeworkcore.relational/5.0.10",
       "files": [
         ".nupkg.metadata",
         ".signature.p7s",
         "Icon.png",
         "lib/netstandard2.1/Microsoft.EntityFrameworkCore.Relational.dll",
         "lib/netstandard2.1/Microsoft.EntityFrameworkCore.Relational.xml",
-        "microsoft.entityframeworkcore.relational.5.0.13.nupkg.sha512",
+        "microsoft.entityframeworkcore.relational.5.0.10.nupkg.sha512",
         "microsoft.entityframeworkcore.relational.nuspec"
       ]
     },
-    "Microsoft.EntityFrameworkCore.Tools/5.0.13": {
-      "sha512": "i/46k4pfCBMb2LVjLqHAbBO8WsAaB+CKbe8oF9ZBTtjVqyEJAxSpn8IZcvajY2KJmM7lc3zgyUdaommvxH2ClA==",
-      "type": "package",
-      "path": "microsoft.entityframeworkcore.tools/5.0.13",
-      "hasTools": true,
-      "files": [
-        ".nupkg.metadata",
-        ".signature.p7s",
-        "Icon.png",
-        "lib/netstandard2.1/_._",
-        "microsoft.entityframeworkcore.tools.5.0.13.nupkg.sha512",
-        "microsoft.entityframeworkcore.tools.nuspec",
-        "tools/EntityFrameworkCore.PS2.psd1",
-        "tools/EntityFrameworkCore.PS2.psm1",
-        "tools/EntityFrameworkCore.psd1",
-        "tools/EntityFrameworkCore.psm1",
-        "tools/about_EntityFrameworkCore.help.txt",
-        "tools/init.ps1",
-        "tools/net461/any/ef.exe",
-        "tools/net461/win-x86/ef.exe",
-        "tools/netcoreapp2.0/any/ef.dll",
-        "tools/netcoreapp2.0/any/ef.runtimeconfig.json"
-      ]
-    },
     "Microsoft.Extensions.Caching.Abstractions/5.0.0": {
       "sha512": "bu8As90/SBAouMZ6fJ+qRNo1X+KgHGrVueFhhYi+E5WqEhcnp2HoWRFnMzXQ6g4RdZbvPowFerSbKNH4Dtg5yg==",
       "type": "package",
         "version.txt"
       ]
     },
-    "Microsoft.Extensions.DependencyInjection.Abstractions/5.0.0": {
-      "sha512": "ORj7Zh81gC69TyvmcUm9tSzytcy8AVousi+IVRAI8nLieQjOFryRusSFh7+aLk16FN9pQNqJAiMd7BTKINK0kA==",
+    "Microsoft.Extensions.DependencyInjection.Abstractions/6.0.0": {
+      "sha512": "xlzi2IYREJH3/m6+lUrQlujzX8wDitm4QGnUu6kUXTQAWPuZY8i+ticFJbzfqaetLA6KR/rO6Ew/HuYD+bxifg==",
       "type": "package",
-      "path": "microsoft.extensions.dependencyinjection.abstractions/5.0.0",
+      "path": "microsoft.extensions.dependencyinjection.abstractions/6.0.0",
       "files": [
         ".nupkg.metadata",
         ".signature.p7s",
         "Icon.png",
         "LICENSE.TXT",
         "THIRD-PARTY-NOTICES.TXT",
+        "buildTransitive/netcoreapp2.0/Microsoft.Extensions.DependencyInjection.Abstractions.targets",
+        "buildTransitive/netcoreapp3.1/_._",
         "lib/net461/Microsoft.Extensions.DependencyInjection.Abstractions.dll",
         "lib/net461/Microsoft.Extensions.DependencyInjection.Abstractions.xml",
+        "lib/net6.0/Microsoft.Extensions.DependencyInjection.Abstractions.dll",
+        "lib/net6.0/Microsoft.Extensions.DependencyInjection.Abstractions.xml",
         "lib/netstandard2.0/Microsoft.Extensions.DependencyInjection.Abstractions.dll",
         "lib/netstandard2.0/Microsoft.Extensions.DependencyInjection.Abstractions.xml",
-        "microsoft.extensions.dependencyinjection.abstractions.5.0.0.nupkg.sha512",
+        "lib/netstandard2.1/Microsoft.Extensions.DependencyInjection.Abstractions.dll",
+        "lib/netstandard2.1/Microsoft.Extensions.DependencyInjection.Abstractions.xml",
+        "microsoft.extensions.dependencyinjection.abstractions.6.0.0.nupkg.sha512",
         "microsoft.extensions.dependencyinjection.abstractions.nuspec",
-        "useSharedDesignerContext.txt",
-        "version.txt"
+        "useSharedDesignerContext.txt"
       ]
     },
     "Microsoft.Extensions.Identity.Core/5.0.10": {
         "system.xml.xpath.xmldocument.nuspec"
       ]
     },
-    "Backend.Common/1.0.0": {
-      "type": "project",
-      "path": "../Backend.Common/Backend.Common.csproj",
-      "msbuildProject": "../Backend.Common/Backend.Common.csproj"
-    },
-    "Backend.Data/1.0.0": {
+    "Backend.ApplicationCore/1.0.0": {
       "type": "project",
-      "path": "../Backend.Data/Backend.Data.csproj",
-      "msbuildProject": "../Backend.Data/Backend.Data.csproj"
+      "path": "../Backend.Services/Backend.ApplicationCore.csproj",
+      "msbuildProject": "../Backend.Services/Backend.ApplicationCore.csproj"
     },
-    "Backend.Models/1.0.0": {
+    "Backend.Domain/1.0.0": {
       "type": "project",
-      "path": "../Backend.Models/Backend.Models.csproj",
-      "msbuildProject": "../Backend.Models/Backend.Models.csproj"
+      "path": "../Backend.Common/Backend.Domain.csproj",
+      "msbuildProject": "../Backend.Common/Backend.Domain.csproj"
     },
-    "Backend.Services/1.0.0": {
+    "Backend.Infrastructure/1.0.0": {
       "type": "project",
-      "path": "../Backend.Services/Backend.Services.csproj",
-      "msbuildProject": "../Backend.Services/Backend.Services.csproj"
+      "path": "../Backend.Data/Backend.Infrastructure.csproj",
+      "msbuildProject": "../Backend.Data/Backend.Infrastructure.csproj"
     },
-    "Mediator/1.0.0": {
+    "Backend.Persistence/1.0.0": {
       "type": "project",
-      "path": "../Mediator/Mediator.csproj",
-      "msbuildProject": "../Mediator/Mediator.csproj"
+      "path": "../Backend.EFCore/Backend.Persistence.csproj",
+      "msbuildProject": "../Backend.EFCore/Backend.Persistence.csproj"
     }
   },
   "projectFileDependencyGroups": {
     ".NETCoreApp,Version=v3.1": [
-      "AutoMapper >= 10.1.1",
-      "AutoMapper.Extensions.Microsoft.DependencyInjection >= 8.1.1",
-      "Backend.Common >= 1.0.0",
-      "MediatR.Extensions.Microsoft.DependencyInjection >= 7.0.0",
-      "Mediator >= 1.0.0",
-      "Microsoft.EntityFrameworkCore >= 5.0.13",
-      "Microsoft.EntityFrameworkCore.Tools >= 5.0.13",
+      "Backend.ApplicationCore >= 1.0.0",
+      "Backend.Domain >= 1.0.0",
+      "Backend.Infrastructure >= 1.0.0",
+      "Backend.Persistence >= 1.0.0",
       "Microsoft.VisualStudio.Azure.Containers.Tools.Targets >= 1.11.1",
-      "Pomelo.EntityFrameworkCore.MySql >= 5.0.0-alpha.2",
       "Swashbuckle.AspNetCore.Swagger >= 6.2.3",
       "Swashbuckle.AspNetCore.SwaggerGen >= 6.2.3",
       "Swashbuckle.AspNetCore.SwaggerUI >= 6.2.3"
         "netcoreapp3.1": {
           "targetAlias": "netcoreapp3.1",
           "projectReferences": {
-            "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Common\\Backend.Common.csproj": {
-              "projectPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Common\\Backend.Common.csproj"
+            "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Common\\Backend.Domain.csproj": {
+              "projectPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Common\\Backend.Domain.csproj"
+            },
+            "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Data\\Backend.Infrastructure.csproj": {
+              "projectPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Data\\Backend.Infrastructure.csproj"
+            },
+            "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.EFCore\\Backend.Persistence.csproj": {
+              "projectPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.EFCore\\Backend.Persistence.csproj"
             },
-            "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Mediator\\Mediator.csproj": {
-              "projectPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Mediator\\Mediator.csproj"
+            "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Services\\Backend.ApplicationCore.csproj": {
+              "projectPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Services\\Backend.ApplicationCore.csproj"
             }
           }
         }
       "netcoreapp3.1": {
         "targetAlias": "netcoreapp3.1",
         "dependencies": {
-          "AutoMapper": {
-            "target": "Package",
-            "version": "[10.1.1, )"
-          },
-          "AutoMapper.Extensions.Microsoft.DependencyInjection": {
-            "target": "Package",
-            "version": "[8.1.1, )"
-          },
-          "MediatR.Extensions.Microsoft.DependencyInjection": {
-            "target": "Package",
-            "version": "[7.0.0, )"
-          },
-          "Microsoft.EntityFrameworkCore": {
-            "target": "Package",
-            "version": "[5.0.13, )"
-          },
-          "Microsoft.EntityFrameworkCore.Tools": {
-            "include": "Runtime, Build, Native, ContentFiles, Analyzers, BuildTransitive",
-            "suppressParent": "All",
-            "target": "Package",
-            "version": "[5.0.13, )"
-          },
           "Microsoft.VisualStudio.Azure.Containers.Tools.Targets": {
             "target": "Package",
             "version": "[1.11.1, )"
           },
-          "Pomelo.EntityFrameworkCore.MySql": {
-            "target": "Package",
-            "version": "[5.0.0-alpha.2, )"
-          },
           "Swashbuckle.AspNetCore.Swagger": {
             "target": "Package",
             "version": "[6.2.3, )"

CatalogueCQRS/Backend.API/obj/project.nuget.cache

 {
   "version": 2,
-  "dgSpecHash": "6Ve22KvRi66dmn7VFkf8a3eGTJdPLQn5+zWYlTYaOApmNK65tK3ZIwt4r5RfPsluDW6LTRgfXzO4/Bxiwra+vQ==",
+  "dgSpecHash": "TA9CcoqYfvWe+eaQZkCvv5HaAxQkt8hJGLXIdJejCYsg+Lk3GHZ846uREyjVeEYrMBYIx2+BEbjOSto9jqEiug==",
   "success": true,
   "projectFilePath": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.API\\Backend.API.csproj",
   "expectedPackageFiles": [
     "C:\\Users\\Alex ONDOA BALEGNAMA\\.nuget\\packages\\bouncycastle.netcore\\1.8.3\\bouncycastle.netcore.1.8.3.nupkg.sha512",
     "C:\\Users\\Alex ONDOA BALEGNAMA\\.nuget\\packages\\entityframework\\6.1.0\\entityframework.6.1.0.nupkg.sha512",
     "C:\\Users\\Alex ONDOA BALEGNAMA\\.nuget\\packages\\google.protobuf\\3.11.4\\google.protobuf.3.11.4.nupkg.sha512",
-    "C:\\Users\\Alex ONDOA BALEGNAMA\\.nuget\\packages\\humanizer.core\\2.8.26\\humanizer.core.2.8.26.nupkg.sha512",
     "C:\\Users\\Alex ONDOA BALEGNAMA\\.nuget\\packages\\k4os.compression.lz4\\1.1.11\\k4os.compression.lz4.1.1.11.nupkg.sha512",
     "C:\\Users\\Alex ONDOA BALEGNAMA\\.nuget\\packages\\k4os.compression.lz4.streams\\1.1.11\\k4os.compression.lz4.streams.1.1.11.nupkg.sha512",
     "C:\\Users\\Alex ONDOA BALEGNAMA\\.nuget\\packages\\k4os.hash.xxhash\\1.0.6\\k4os.hash.xxhash.1.0.6.nupkg.sha512",
     "C:\\Users\\Alex ONDOA BALEGNAMA\\.nuget\\packages\\microsoft.entityframeworkcore\\5.0.13\\microsoft.entityframeworkcore.5.0.13.nupkg.sha512",
     "C:\\Users\\Alex ONDOA BALEGNAMA\\.nuget\\packages\\microsoft.entityframeworkcore.abstractions\\5.0.13\\microsoft.entityframeworkcore.abstractions.5.0.13.nupkg.sha512",
     "C:\\Users\\Alex ONDOA BALEGNAMA\\.nuget\\packages\\microsoft.entityframeworkcore.analyzers\\5.0.13\\microsoft.entityframeworkcore.analyzers.5.0.13.nupkg.sha512",
-    "C:\\Users\\Alex ONDOA BALEGNAMA\\.nuget\\packages\\microsoft.entityframeworkcore.design\\5.0.13\\microsoft.entityframeworkcore.design.5.0.13.nupkg.sha512",
-    "C:\\Users\\Alex ONDOA BALEGNAMA\\.nuget\\packages\\microsoft.entityframeworkcore.relational\\5.0.13\\microsoft.entityframeworkcore.relational.5.0.13.nupkg.sha512",
-    "C:\\Users\\Alex ONDOA BALEGNAMA\\.nuget\\packages\\microsoft.entityframeworkcore.tools\\5.0.13\\microsoft.entityframeworkcore.tools.5.0.13.nupkg.sha512",
+    "C:\\Users\\Alex ONDOA BALEGNAMA\\.nuget\\packages\\microsoft.entityframeworkcore.relational\\5.0.10\\microsoft.entityframeworkcore.relational.5.0.10.nupkg.sha512",
     "C:\\Users\\Alex ONDOA BALEGNAMA\\.nuget\\packages\\microsoft.extensions.caching.abstractions\\5.0.0\\microsoft.extensions.caching.abstractions.5.0.0.nupkg.sha512",
     "C:\\Users\\Alex ONDOA BALEGNAMA\\.nuget\\packages\\microsoft.extensions.caching.memory\\5.0.0\\microsoft.extensions.caching.memory.5.0.0.nupkg.sha512",
     "C:\\Users\\Alex ONDOA BALEGNAMA\\.nuget\\packages\\microsoft.extensions.configuration.abstractions\\6.0.0\\microsoft.extensions.configuration.abstractions.6.0.0.nupkg.sha512",
     "C:\\Users\\Alex ONDOA BALEGNAMA\\.nuget\\packages\\microsoft.extensions.dependencyinjection\\5.0.2\\microsoft.extensions.dependencyinjection.5.0.2.nupkg.sha512",
-    "C:\\Users\\Alex ONDOA BALEGNAMA\\.nuget\\packages\\microsoft.extensions.dependencyinjection.abstractions\\5.0.0\\microsoft.extensions.dependencyinjection.abstractions.5.0.0.nupkg.sha512",
+    "C:\\Users\\Alex ONDOA BALEGNAMA\\.nuget\\packages\\microsoft.extensions.dependencyinjection.abstractions\\6.0.0\\microsoft.extensions.dependencyinjection.abstractions.6.0.0.nupkg.sha512",
     "C:\\Users\\Alex ONDOA BALEGNAMA\\.nuget\\packages\\microsoft.extensions.identity.core\\5.0.10\\microsoft.extensions.identity.core.5.0.10.nupkg.sha512",
     "C:\\Users\\Alex ONDOA BALEGNAMA\\.nuget\\packages\\microsoft.extensions.identity.stores\\5.0.10\\microsoft.extensions.identity.stores.5.0.10.nupkg.sha512",
     "C:\\Users\\Alex ONDOA BALEGNAMA\\.nuget\\packages\\microsoft.extensions.logging\\5.0.0\\microsoft.extensions.logging.5.0.0.nupkg.sha512",

CatalogueCQRS/Backend.Common/Constants/ErrorsConstants.cs

 using System;
 using System.Runtime.Serialization;
 
-namespace Backend.Common
+namespace Backend.Domain
 {
     public class ErrorsConstants  
     {
-        public static string C_APPLICATION_DBCONTEXT_NULL_MSG = "ApplicationDBContext is null";
-        public static string C_REPO_MSG_ERROR = "Repository Error";
-        public static string C_SERVICE_MSG_ERROR = "Service Error";
-        public static string C_NOT_EXIST_MSG_ERROR = "Object Not exist";
-        public static string HTTP_ERROR_5XX = "Internal Error";
-        public static string HTTP_ERROR_4XX = "Bad request";
-        public static string C_REPO_MSG_ERROR_SAVE ="Save Change in database Error";
-        public static string C_REPO_MSG_ERROR_UPDATE = "Update object in database context Error";
-        public static string C_REPO_MSG_ERROR_ADD = "Add object in database context Error";
-        public static string C_REPO_MSG_ERROR_REMOVE = "Add object in database context Error";
+        public static string S_APPLICATION_DBCONTEXT_NULL_MSG = "ApplicationDBContext is null";
+        public static string S_REPO_MSG_ERROR = "Repository Error";
+        public static string S_SERVICE_MSG_ERROR = "Service Error";
+        public static string S_NOT_EXIST_MSG_ERROR = "Object Not exist";
+        public static string S_HTTP_ERROR_5XX = "Internal Error";
+        public static string S_HTTP_ERROR_4XX = "Bad request";
+        public static string S_REPO_MSG_ERROR_SAVE ="Save Change in database Error";
+        public static string S_REPO_MSG_ERROR_UPDATE = "Update object in database context Error";
+        public static string S_REPO_MSG_ERROR_ADD = "Add object in database context Error";
+        public static string S_REPO_MSG_ERROR_REMOVE = "Add object in database context Error";
     }
 }

CatalogueCQRS/Backend.Data/Domain/Commande.cs → CatalogueCQRS/Backend.Common/Entities/Commande.cs

 using System.Collections.Generic;
 using System.ComponentModel.DataAnnotations;
 
-namespace Backend.Data
+namespace Backend.Domain.Entities
 {
     public class Commande
     {

CatalogueCQRS/Backend.Data/Domain/LigneCommande.cs → CatalogueCQRS/Backend.Common/Entities/LigneCommande.cs

 using System;
 using System.ComponentModel.DataAnnotations;
 
-namespace Backend.Data
+namespace Backend.Domain.Entities
 {
     public class LigneCommande
     {

CatalogueCQRS/Backend.Data/Domain/Produit.cs → CatalogueCQRS/Backend.Common/Entities/Produit.cs

 using System;
 using System.Collections.Generic;
 
-namespace Backend.Data
+namespace Backend.Domain.Entities
 {
     public class Produit
     {

CatalogueCQRS/Backend.Data/Domain/Propriete.cs → CatalogueCQRS/Backend.Common/Entities/Propriete.cs

 using System;
 using System.ComponentModel.DataAnnotations;
 
-namespace Backend.Data
+namespace Backend.Domain.Entities
 {
     public class Propriete
     {

CatalogueCQRS/Backend.Data/Domain/TypePropriete.cs → CatalogueCQRS/Backend.Common/Entities/TypePropriete.cs

 using System.Collections.Generic;
 using System.ComponentModel.DataAnnotations;
 
-namespace Backend.Data
+namespace Backend.Domain.Entities
 {
     public class TypePropriete
     {

CatalogueCQRS/Backend.Common/bin/Debug/netcoreapp3.1/Backend.Domain.deps.json

+{
+  "runtimeTarget": {
+    "name": ".NETCoreApp,Version=v3.1",
+    "signature": ""
+  },
+  "compilationOptions": {},
+  "targets": {
+    ".NETCoreApp,Version=v3.1": {
+      "Backend.Domain/1.0.0": {
+        "runtime": {
+          "Backend.Domain.dll": {}
+        }
+      }
+    }
+  },
+  "libraries": {
+    "Backend.Domain/1.0.0": {
+      "type": "project",
+      "serviceable": false,
+      "sha512": ""
+    }
+  }
+}

CatalogueCQRS/Backend.Common/obj/Backend.Domain.csproj.nuget.dgspec.json

+{
+  "format": 1,
+  "restore": {
+    "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Common\\Backend.Domain.csproj": {}
+  },
+  "projects": {
+    "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Common\\Backend.Domain.csproj": {
+      "version": "1.0.0",
+      "restore": {
+        "projectUniqueName": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Common\\Backend.Domain.csproj",
+        "projectName": "Backend.Domain",
+        "projectPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Common\\Backend.Domain.csproj",
+        "packagesPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\.nuget\\packages\\",
+        "outputPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Common\\obj\\",
+        "projectStyle": "PackageReference",
+        "configFilePaths": [
+          "C:\\Users\\Alex ONDOA BALEGNAMA\\AppData\\Roaming\\NuGet\\NuGet.Config",
+          "C:\\Program Files (x86)\\NuGet\\Config\\Microsoft.VisualStudio.Offline.config"
+        ],
+        "originalTargetFrameworks": [
+          "netcoreapp3.1"
+        ],
+        "sources": {
+          "C:\\Program Files (x86)\\Microsoft SDKs\\NuGetPackages\\": {},
+          "https://api.nuget.org/v3/index.json": {},
+          "https://packagesource": {}
+        },
+        "frameworks": {
+          "netcoreapp3.1": {
+            "targetAlias": "netcoreapp3.1",
+            "projectReferences": {}
+          }
+        },
+        "warningProperties": {
+          "warnAsError": [
+            "NU1605"
+          ]
+        }
+      },
+      "frameworks": {
+        "netcoreapp3.1": {
+          "targetAlias": "netcoreapp3.1",
+          "imports": [
+            "net461",
+            "net462",
+            "net47",
+            "net471",
+            "net472",
+            "net48"
+          ],
+          "assetTargetFallback": true,
+          "warn": true,
+          "frameworkReferences": {
+            "Microsoft.NETCore.App": {
+              "privateAssets": "all"
+            }
+          },
+          "runtimeIdentifierGraphPath": "C:\\Program Files\\dotnet\\sdk\\5.0.403\\RuntimeIdentifierGraph.json"
+        }
+      }
+    }
+  }
+}

CatalogueCQRS/Backend.Common/obj/Backend.Domain.csproj.nuget.g.props

+<?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\Alex ONDOA BALEGNAMA\.nuget\packages\</NuGetPackageFolders>
+    <NuGetProjectStyle Condition=" '$(NuGetProjectStyle)' == '' ">PackageReference</NuGetProjectStyle>
+    <NuGetToolVersion Condition=" '$(NuGetToolVersion)' == '' ">5.11.1</NuGetToolVersion>
+  </PropertyGroup>
+  <ItemGroup Condition=" '$(ExcludeRestorePackageImports)' != 'true' ">
+    <SourceRoot Include="C:\Users\Alex ONDOA BALEGNAMA\.nuget\packages\" />
+  </ItemGroup>
+  <PropertyGroup>
+    <MSBuildAllProjects>$(MSBuildAllProjects);$(MSBuildThisFileFullPath)</MSBuildAllProjects>
+  </PropertyGroup>
+</Project>

CatalogueCQRS/Backend.Common/obj/Backend.Domain.csproj.nuget.g.targets

+<?xml version="1.0" encoding="utf-8" standalone="no"?>
+<Project ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <MSBuildAllProjects>$(MSBuildAllProjects);$(MSBuildThisFileFullPath)</MSBuildAllProjects>
+  </PropertyGroup>
+</Project>

CatalogueCQRS/Backend.Common/obj/Debug/netcoreapp3.1/Backend.Common.csproj.FileListAbsolute.txt

 C:\Users\Alex ONDOA BALEGNAMA\source\repos\CatalogueCQRS\Backend.Common\obj\Debug\netcoreapp3.1\Backend.Common.dll
 C:\Users\Alex ONDOA BALEGNAMA\source\repos\CatalogueCQRS\Backend.Common\obj\Debug\netcoreapp3.1\Backend.Common.pdb
 C:\Users\Alex ONDOA BALEGNAMA\source\repos\CatalogueCQRS\Backend.Common\obj\Debug\netcoreapp3.1\Backend.Common.csproj.AssemblyReference.cache
+C:\Users\Alex ONDOA BALEGNAMA\source\repos\Backend\CatalogueCQRS\Backend.Common\bin\Debug\netcoreapp3.1\Backend.Common.deps.json
+C:\Users\Alex ONDOA BALEGNAMA\source\repos\Backend\CatalogueCQRS\Backend.Common\bin\Debug\netcoreapp3.1\Backend.Common.dll
+C:\Users\Alex ONDOA BALEGNAMA\source\repos\Backend\CatalogueCQRS\Backend.Common\bin\Debug\netcoreapp3.1\Backend.Common.pdb
+C:\Users\Alex ONDOA BALEGNAMA\source\repos\Backend\CatalogueCQRS\Backend.Common\obj\Debug\netcoreapp3.1\Backend.Common.GeneratedMSBuildEditorConfig.editorconfig
+C:\Users\Alex ONDOA BALEGNAMA\source\repos\Backend\CatalogueCQRS\Backend.Common\obj\Debug\netcoreapp3.1\Backend.Common.AssemblyInfoInputs.cache
+C:\Users\Alex ONDOA BALEGNAMA\source\repos\Backend\CatalogueCQRS\Backend.Common\obj\Debug\netcoreapp3.1\Backend.Common.AssemblyInfo.cs
+C:\Users\Alex ONDOA BALEGNAMA\source\repos\Backend\CatalogueCQRS\Backend.Common\obj\Debug\netcoreapp3.1\Backend.Common.csproj.CoreCompileInputs.cache
+C:\Users\Alex ONDOA BALEGNAMA\source\repos\Backend\CatalogueCQRS\Backend.Common\obj\Debug\netcoreapp3.1\Backend.Common.dll
+C:\Users\Alex ONDOA BALEGNAMA\source\repos\Backend\CatalogueCQRS\Backend.Common\obj\Debug\netcoreapp3.1\Backend.Common.pdb

CatalogueCQRS/Backend.Common/obj/Debug/netcoreapp3.1/Backend.Domain.AssemblyInfo.cs

+//------------------------------------------------------------------------------
+// <auto-generated>
+//     Ce code a été généré par un outil.
+//     Version du runtime :4.0.30319.42000
+//
+//     Les modifications apportées à ce fichier peuvent provoquer un comportement incorrect et seront perdues si
+//     le code est régénéré.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+using System;
+using System.Reflection;
+
+[assembly: System.Reflection.AssemblyCompanyAttribute("Backend.Domain")]
+[assembly: System.Reflection.AssemblyConfigurationAttribute("Debug")]
+[assembly: System.Reflection.AssemblyFileVersionAttribute("1.0.0.0")]
+[assembly: System.Reflection.AssemblyInformationalVersionAttribute("1.0.0")]
+[assembly: System.Reflection.AssemblyProductAttribute("Backend.Domain")]
+[assembly: System.Reflection.AssemblyTitleAttribute("Backend.Domain")]
+[assembly: System.Reflection.AssemblyVersionAttribute("1.0.0.0")]
+
+// Généré par la classe MSBuild WriteCodeFragment.
+

CatalogueCQRS/Backend.Common/obj/Debug/netcoreapp3.1/Backend.Domain.AssemblyInfoInputs.cache

+91e6db1f71a1d13b8236fb3f6239e9a29361b8c7

CatalogueCQRS/Backend.Common/obj/Debug/netcoreapp3.1/Backend.Domain.GeneratedMSBuildEditorConfig.editorconfig

+is_global = true
+build_property.RootNamespace = Backend.Domain
+build_property.ProjectDir = C:\Users\Alex ONDOA BALEGNAMA\source\repos\Backend\CatalogueCQRS\Backend.Common\

CatalogueCQRS/Backend.Common/obj/Debug/netcoreapp3.1/Backend.Domain.csproj.CoreCompileInputs.cache

+352f687bfebd19e8697cc1695f9637327b4e1f64

CatalogueCQRS/Backend.Common/obj/Debug/netcoreapp3.1/Backend.Domain.csproj.FileListAbsolute.txt

+C:\Users\Alex ONDOA BALEGNAMA\source\repos\Backend\CatalogueCQRS\Backend.Common\bin\Debug\netcoreapp3.1\Backend.Domain.deps.json
+C:\Users\Alex ONDOA BALEGNAMA\source\repos\Backend\CatalogueCQRS\Backend.Common\bin\Debug\netcoreapp3.1\Backend.Domain.dll
+C:\Users\Alex ONDOA BALEGNAMA\source\repos\Backend\CatalogueCQRS\Backend.Common\bin\Debug\netcoreapp3.1\Backend.Domain.pdb
+C:\Users\Alex ONDOA BALEGNAMA\source\repos\Backend\CatalogueCQRS\Backend.Common\obj\Debug\netcoreapp3.1\Backend.Domain.GeneratedMSBuildEditorConfig.editorconfig
+C:\Users\Alex ONDOA BALEGNAMA\source\repos\Backend\CatalogueCQRS\Backend.Common\obj\Debug\netcoreapp3.1\Backend.Domain.AssemblyInfoInputs.cache
+C:\Users\Alex ONDOA BALEGNAMA\source\repos\Backend\CatalogueCQRS\Backend.Common\obj\Debug\netcoreapp3.1\Backend.Domain.AssemblyInfo.cs
+C:\Users\Alex ONDOA BALEGNAMA\source\repos\Backend\CatalogueCQRS\Backend.Common\obj\Debug\netcoreapp3.1\Backend.Domain.csproj.CoreCompileInputs.cache
+C:\Users\Alex ONDOA BALEGNAMA\source\repos\Backend\CatalogueCQRS\Backend.Common\obj\Debug\netcoreapp3.1\Backend.Domain.dll
+C:\Users\Alex ONDOA BALEGNAMA\source\repos\Backend\CatalogueCQRS\Backend.Common\obj\Debug\netcoreapp3.1\Backend.Domain.pdb

CatalogueCQRS/Backend.Common/obj/project.assets.json

   "project": {
     "version": "1.0.0",
     "restore": {
-      "projectUniqueName": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Common\\Backend.Common.csproj",
-      "projectName": "Backend.Common",
-      "projectPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Common\\Backend.Common.csproj",
+      "projectUniqueName": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Common\\Backend.Domain.csproj",
+      "projectName": "Backend.Domain",
+      "projectPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Common\\Backend.Domain.csproj",
       "packagesPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\.nuget\\packages\\",
       "outputPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Common\\obj\\",
       "projectStyle": "PackageReference",

CatalogueCQRS/Backend.Common/obj/project.nuget.cache

 {
   "version": 2,
-  "dgSpecHash": "QwfqRCs1G28hV3IeXxCeoUJMYhHmopAtvMO6Tjte/MTWuxHgXkkuyHNffFrG+RJrc+gY1Gk2f402emwzIwuf2Q==",
+  "dgSpecHash": "0E2rbsa3jrsRUin7LkHRchl+TN3HVlPCMjMBN+tUDqhexevNpk/HCJSsMDSoAxPLTMm8VBSuhvGnnHDhXM2dMw==",
   "success": true,
-  "projectFilePath": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Common\\Backend.Common.csproj",
+  "projectFilePath": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Common\\Backend.Domain.csproj",
   "expectedPackageFiles": [],
   "logs": []
 }

CatalogueCQRS/Backend.Data/Backend.Infrastructure.csproj

+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Backend.Common\Backend.Domain.csproj" />
+    <ProjectReference Include="..\Backend.Services\Backend.ApplicationCore.csproj" />
+  </ItemGroup>
+
+</Project>

CatalogueCQRS/Backend.Data/Repositories/CommandeRepository.cs

-using Backend.Data.Interfaces;
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
+
+using Backend.ApplicationCore.Interfaces.IRepositories;
+using Backend.Domain.Entities;
 
-namespace Backend.Data.Repositories
+namespace Backend.Infrastructure.Repositories
 {
     public class CommandeRepository : GenericRepository<Commande>, ICommandeRepository
     {

CatalogueCQRS/Backend.Data/Repositories/GenericRepository.cs

-using Backend.Data.Interfaces;
+using Backend.ApplicationCore.Interfaces.IRepositories;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.ChangeTracking;
 using System;
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace Backend.Data.Repositories
+namespace Backend.Infrastructure.Repositories
 {
     public class GenericRepository<TEntity> : IDisposable, IGenericRepository<TEntity> where TEntity : class
     {
            _context.Entry(ExistEntity).CurrentValues.SetValues(entity);
             return _context.Entry(entity);
         }
+     
 
         /// <summary>
         /// DeleteAsync delete en antity by Id
             _context?.Dispose();
         }
 
-       
+        
     }
 }

CatalogueCQRS/Backend.Data/Repositories/LigneCommandeRepository.cs

-using Backend.Data.Interfaces;
+
+using Backend.ApplicationCore.Interfaces.IRepositories;
+using Backend.Domain.Entities;
 using System;
 using System.Collections.Generic;
 using System.Linq;
 
-namespace Backend.Data.Repositories
+namespace Backend.Infrastructure.Repositories
 {
     public class LigneCommandeRepository : GenericRepository<LigneCommande>, ILigneCommandeRepository
     {

CatalogueCQRS/Backend.Data/Repositories/ProduitRepository.cs

-using Backend.Data.Interfaces;
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
+
 
-namespace Backend.Data.Repositories
+using Backend.ApplicationCore.Interfaces.IRepositories;
+using Backend.Domain.Entities;
+
+namespace Backend.Infrastructure.Repositories
 {
     public class ProduitRepository : GenericRepository<Produit>, IProduitRepository
     {

CatalogueCQRS/Backend.Data/Repositories/ProprieteRepository.cs

-using Backend.Data.Interfaces;
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
+
 
-namespace Backend.Data.Repositories
+using Backend.ApplicationCore.Interfaces.IRepositories;
+using Backend.Domain.Entities;
+
+namespace Backend.Infrastructure.Repositories
 {
     public class ProprieteRepository : GenericRepository<Propriete>, IProprieteRepository
     {

CatalogueCQRS/Backend.Data/Repositories/TypeProprieteRepository.cs

-using Backend.Data.Interfaces;
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
+using Backend.ApplicationCore.Interfaces.IRepositories;
+using Backend.Domain.Entities;
 
-namespace Backend.Data.Repositories
+namespace Backend.Infrastructure.Repositories
 {
     public class TypeProprieteRepository : GenericRepository<TypePropriete>, ITypeProprieteRepository
     {

CatalogueCQRS/Backend.Data/bin/Debug/netcoreapp3.1/Backend.Infrastructure.deps.json

+{
+  "runtimeTarget": {
+    "name": ".NETCoreApp,Version=v3.1",
+    "signature": ""
+  },
+  "compilationOptions": {},
+  "targets": {
+    ".NETCoreApp,Version=v3.1": {
+      "Backend.Infrastructure/1.0.0": {
+        "dependencies": {
+          "Backend.ApplicationCore": "1.0.0",
+          "Backend.Domain": "1.0.0"
+        },
+        "runtime": {
+          "Backend.Infrastructure.dll": {}
+        }
+      },
+      "AutoMapper/10.1.1": {
+        "dependencies": {
+          "Microsoft.CSharp": "4.7.0",
+          "System.Reflection.Emit": "4.7.0"
+        },
+        "runtime": {
+          "lib/netstandard2.0/AutoMapper.dll": {
+            "assemblyVersion": "10.0.0.0",
+            "fileVersion": "10.1.1.0"
+          }
+        }
+      },
+      "AutoMapper.Extensions.Microsoft.DependencyInjection/8.1.1": {
+        "dependencies": {
+          "AutoMapper": "10.1.1",
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "5.0.0",
+          "Microsoft.Extensions.Options": "5.0.0"
+        },
+        "runtime": {
+          "lib/netstandard2.0/AutoMapper.Extensions.Microsoft.DependencyInjection.dll": {
+            "assemblyVersion": "8.0.0.0",
+            "fileVersion": "8.1.1.0"
+          }
+        }
+      },
+      "MediatR/7.0.0": {
+        "runtime": {
+          "lib/netstandard2.0/MediatR.dll": {
+            "assemblyVersion": "7.0.0.0",
+            "fileVersion": "7.0.0.0"
+          }
+        }
+      },
+      "MediatR.Extensions.Microsoft.DependencyInjection/7.0.0": {
+        "dependencies": {
+          "MediatR": "7.0.0",
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "5.0.0"
+        },
+        "runtime": {
+          "lib/netstandard2.0/MediatR.Extensions.Microsoft.DependencyInjection.dll": {
+            "assemblyVersion": "7.0.0.0",
+            "fileVersion": "7.0.0.0"
+          }
+        }
+      },
+      "Microsoft.CSharp/4.7.0": {},
+      "Microsoft.EntityFrameworkCore/5.0.13": {
+        "dependencies": {
+          "Microsoft.EntityFrameworkCore.Abstractions": "5.0.13",
+          "Microsoft.EntityFrameworkCore.Analyzers": "5.0.13",
+          "Microsoft.Extensions.Caching.Memory": "5.0.0",
+          "Microsoft.Extensions.DependencyInjection": "5.0.2",
+          "Microsoft.Extensions.Logging": "5.0.0",
+          "System.Collections.Immutable": "5.0.0",
+          "System.ComponentModel.Annotations": "5.0.0",
+          "System.Diagnostics.DiagnosticSource": "5.0.1"
+        },
+        "runtime": {
+          "lib/netstandard2.1/Microsoft.EntityFrameworkCore.dll": {
+            "assemblyVersion": "5.0.13.0",
+            "fileVersion": "5.0.1321.56013"
+          }
+        }
+      },
+      "Microsoft.EntityFrameworkCore.Abstractions/5.0.13": {
+        "runtime": {
+          "lib/netstandard2.1/Microsoft.EntityFrameworkCore.Abstractions.dll": {
+            "assemblyVersion": "5.0.13.0",
+            "fileVersion": "5.0.1321.56013"
+          }
+        }
+      },
+      "Microsoft.EntityFrameworkCore.Analyzers/5.0.13": {},
+      "Microsoft.Extensions.Caching.Abstractions/5.0.0": {
+        "dependencies": {
+          "Microsoft.Extensions.Primitives": "5.0.0"
+        },
+        "runtime": {
+          "lib/netstandard2.0/Microsoft.Extensions.Caching.Abstractions.dll": {
+            "assemblyVersion": "5.0.0.0",
+            "fileVersion": "5.0.20.51904"
+          }
+        }
+      },
+      "Microsoft.Extensions.Caching.Memory/5.0.0": {
+        "dependencies": {
+          "Microsoft.Extensions.Caching.Abstractions": "5.0.0",
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "5.0.0",
+          "Microsoft.Extensions.Logging.Abstractions": "5.0.0",
+          "Microsoft.Extensions.Options": "5.0.0",
+          "Microsoft.Extensions.Primitives": "5.0.0"
+        },
+        "runtime": {
+          "lib/netstandard2.0/Microsoft.Extensions.Caching.Memory.dll": {
+            "assemblyVersion": "5.0.0.0",
+            "fileVersion": "5.0.20.51904"
+          }
+        }
+      },
+      "Microsoft.Extensions.DependencyInjection/5.0.2": {
+        "dependencies": {
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "5.0.0"
+        },
+        "runtime": {
+          "lib/netstandard2.1/Microsoft.Extensions.DependencyInjection.dll": {
+            "assemblyVersion": "5.0.0.1",
+            "fileVersion": "5.0.821.31504"
+          }
+        }
+      },
+      "Microsoft.Extensions.DependencyInjection.Abstractions/5.0.0": {
+        "runtime": {
+          "lib/netstandard2.0/Microsoft.Extensions.DependencyInjection.Abstractions.dll": {
+            "assemblyVersion": "5.0.0.0",
+            "fileVersion": "5.0.20.51904"
+          }
+        }
+      },
+      "Microsoft.Extensions.Logging/5.0.0": {
+        "dependencies": {
+          "Microsoft.Extensions.DependencyInjection": "5.0.2",
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "5.0.0",
+          "Microsoft.Extensions.Logging.Abstractions": "5.0.0",
+          "Microsoft.Extensions.Options": "5.0.0",
+          "System.Diagnostics.DiagnosticSource": "5.0.1"
+        },
+        "runtime": {
+          "lib/netstandard2.1/Microsoft.Extensions.Logging.dll": {
+            "assemblyVersion": "5.0.0.0",
+            "fileVersion": "5.0.20.51904"
+          }
+        }
+      },
+      "Microsoft.Extensions.Logging.Abstractions/5.0.0": {
+        "runtime": {
+          "lib/netstandard2.0/Microsoft.Extensions.Logging.Abstractions.dll": {
+            "assemblyVersion": "5.0.0.0",
+            "fileVersion": "5.0.20.51904"
+          }
+        }
+      },
+      "Microsoft.Extensions.Options/5.0.0": {
+        "dependencies": {
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "5.0.0",
+          "Microsoft.Extensions.Primitives": "5.0.0"
+        },
+        "runtime": {
+          "lib/netstandard2.0/Microsoft.Extensions.Options.dll": {
+            "assemblyVersion": "5.0.0.0",
+            "fileVersion": "5.0.20.51904"
+          }
+        }
+      },
+      "Microsoft.Extensions.Primitives/5.0.0": {
+        "runtime": {
+          "lib/netcoreapp3.0/Microsoft.Extensions.Primitives.dll": {
+            "assemblyVersion": "5.0.0.0",
+            "fileVersion": "5.0.20.51904"
+          }
+        }
+      },
+      "System.Collections.Immutable/5.0.0": {
+        "runtime": {
+          "lib/netstandard2.0/System.Collections.Immutable.dll": {
+            "assemblyVersion": "5.0.0.0",
+            "fileVersion": "5.0.20.51904"
+          }
+        }
+      },
+      "System.ComponentModel.Annotations/5.0.0": {
+        "runtime": {
+          "lib/netstandard2.1/System.ComponentModel.Annotations.dll": {
+            "assemblyVersion": "5.0.0.0",
+            "fileVersion": "5.0.20.51904"
+          }
+        }
+      },
+      "System.Diagnostics.DiagnosticSource/5.0.1": {
+        "runtime": {
+          "lib/netstandard1.3/System.Diagnostics.DiagnosticSource.dll": {
+            "assemblyVersion": "5.0.0.0",
+            "fileVersion": "5.0.220.61120"
+          }
+        }
+      },
+      "System.Reflection.Emit/4.7.0": {},
+      "Backend.ApplicationCore/1.0.0": {
+        "dependencies": {
+          "AutoMapper": "10.1.1",
+          "AutoMapper.Extensions.Microsoft.DependencyInjection": "8.1.1",
+          "Backend.Domain": "1.0.0",
+          "MediatR": "7.0.0",
+          "MediatR.Extensions.Microsoft.DependencyInjection": "7.0.0",
+          "Microsoft.EntityFrameworkCore": "5.0.13"
+        },
+        "runtime": {
+          "Backend.ApplicationCore.dll": {}
+        }
+      },
+      "Backend.Domain/1.0.0": {
+        "runtime": {
+          "Backend.Domain.dll": {}
+        }
+      }
+    }
+  },
+  "libraries": {
+    "Backend.Infrastructure/1.0.0": {
+      "type": "project",
+      "serviceable": false,
+      "sha512": ""
+    },
+    "AutoMapper/10.1.1": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-uMgbqOdu9ZG5cIOty0C85hzzayBH2i9BthnS5FlMqKtMSHDv4ts81a2jS1VFaDBVhlBeIqJ/kQKjQY95BZde9w==",
+      "path": "automapper/10.1.1",
+      "hashPath": "automapper.10.1.1.nupkg.sha512"
+    },
+    "AutoMapper.Extensions.Microsoft.DependencyInjection/8.1.1": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-xSWoVzOipuDU4PeZcUfaZQ+xqXU8QmGv5jrdlxt3MYm9xaOmrefqcfzGQ3SQ+D+8wfBa/ZwSuL0qKOVj080inA==",
+      "path": "automapper.extensions.microsoft.dependencyinjection/8.1.1",
+      "hashPath": "automapper.extensions.microsoft.dependencyinjection.8.1.1.nupkg.sha512"
+    },
+    "MediatR/7.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-sgfHxkBsmMlHOD564SnLqTvSbAuGlFiZfc6ybxBSI1wYV/2u+Y5TXtFoIhCISFg5/s/6aMvB338QC2JseHsjTA==",
+      "path": "mediatr/7.0.0",
+      "hashPath": "mediatr.7.0.0.nupkg.sha512"
+    },
+    "MediatR.Extensions.Microsoft.DependencyInjection/7.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-DRf8jBnjBg84da1L1L0YmwqkhCV+UJTg7bTBHOhleWrLfrtSK5h5aNeE1HOofs1Afisq03B6H2C10NmS47gmqA==",
+      "path": "mediatr.extensions.microsoft.dependencyinjection/7.0.0",
+      "hashPath": "mediatr.extensions.microsoft.dependencyinjection.7.0.0.nupkg.sha512"
+    },
+    "Microsoft.CSharp/4.7.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-pTj+D3uJWyN3My70i2Hqo+OXixq3Os2D1nJ2x92FFo6sk8fYS1m1WLNTs0Dc1uPaViH0YvEEwvzddQ7y4rhXmA==",
+      "path": "microsoft.csharp/4.7.0",
+      "hashPath": "microsoft.csharp.4.7.0.nupkg.sha512"
+    },
+    "Microsoft.EntityFrameworkCore/5.0.13": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-Q5dVSbK5Id01xuAvm2xzrzEUNgO0fFD8mD/qFkD2F4Q23rs5YnrHH+/Wr9PAGNLdKqYWmkB0yTxKBL/0nLgr3g==",
+      "path": "microsoft.entityframeworkcore/5.0.13",
+      "hashPath": "microsoft.entityframeworkcore.5.0.13.nupkg.sha512"
+    },
+    "Microsoft.EntityFrameworkCore.Abstractions/5.0.13": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-TdnEXtDpm3o9s6RzUX0Mjgfgms4BD04uyvyxM9Xg8tQPOqqh7ZO6fWy+xJTj+wTcYuY5pYSkfPNGvtJ5FRmqWQ==",
+      "path": "microsoft.entityframeworkcore.abstractions/5.0.13",
+      "hashPath": "microsoft.entityframeworkcore.abstractions.5.0.13.nupkg.sha512"
+    },
+    "Microsoft.EntityFrameworkCore.Analyzers/5.0.13": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-torTg+dQC/vOlFI5FZsRmOAA5pKtr8cJNJ5SWsl0RVYmhb5I7s/V3T1NsIzSqJTYzGBssHl5mFbiBODeBdQpnQ==",
+      "path": "microsoft.entityframeworkcore.analyzers/5.0.13",
+      "hashPath": "microsoft.entityframeworkcore.analyzers.5.0.13.nupkg.sha512"
+    },
+    "Microsoft.Extensions.Caching.Abstractions/5.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-bu8As90/SBAouMZ6fJ+qRNo1X+KgHGrVueFhhYi+E5WqEhcnp2HoWRFnMzXQ6g4RdZbvPowFerSbKNH4Dtg5yg==",
+      "path": "microsoft.extensions.caching.abstractions/5.0.0",
+      "hashPath": "microsoft.extensions.caching.abstractions.5.0.0.nupkg.sha512"
+    },
+    "Microsoft.Extensions.Caching.Memory/5.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-/1qPCleFOkJe0O+xmFqCNLFYQZTJz965sVw8CUB/BQgsApBwzAUsL2BUkDvQW+geRUVTXUS9zLa0pBjC2VJ1gA==",
+      "path": "microsoft.extensions.caching.memory/5.0.0",
+      "hashPath": "microsoft.extensions.caching.memory.5.0.0.nupkg.sha512"
+    },
+    "Microsoft.Extensions.DependencyInjection/5.0.2": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-xzFW00AZEvOXM1OX+0+AYH5op/Hf3u//e6wszBd/rK72sypD+jx5CtsHxM4BVuFBEs8SajfO4QzSJtrQaHDr4A==",
+      "path": "microsoft.extensions.dependencyinjection/5.0.2",
+      "hashPath": "microsoft.extensions.dependencyinjection.5.0.2.nupkg.sha512"
+    },
+    "Microsoft.Extensions.DependencyInjection.Abstractions/5.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-ORj7Zh81gC69TyvmcUm9tSzytcy8AVousi+IVRAI8nLieQjOFryRusSFh7+aLk16FN9pQNqJAiMd7BTKINK0kA==",
+      "path": "microsoft.extensions.dependencyinjection.abstractions/5.0.0",
+      "hashPath": "microsoft.extensions.dependencyinjection.abstractions.5.0.0.nupkg.sha512"
+    },
+    "Microsoft.Extensions.Logging/5.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-MgOwK6tPzB6YNH21wssJcw/2MKwee8b2gI7SllYfn6rvTpIrVvVS5HAjSU2vqSku1fwqRvWP0MdIi14qjd93Aw==",
+      "path": "microsoft.extensions.logging/5.0.0",
+      "hashPath": "microsoft.extensions.logging.5.0.0.nupkg.sha512"
+    },
+    "Microsoft.Extensions.Logging.Abstractions/5.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-NxP6ahFcBnnSfwNBi2KH2Oz8Xl5Sm2krjId/jRR3I7teFphwiUoUeZPwTNA21EX+5PtjqmyAvKaOeBXcJjcH/w==",
+      "path": "microsoft.extensions.logging.abstractions/5.0.0",
+      "hashPath": "microsoft.extensions.logging.abstractions.5.0.0.nupkg.sha512"
+    },
+    "Microsoft.Extensions.Options/5.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-CBvR92TCJ5uBIdd9/HzDSrxYak+0W/3+yxrNg8Qm6Bmrkh5L+nu6m3WeazQehcZ5q1/6dDA7J5YdQjim0165zg==",
+      "path": "microsoft.extensions.options/5.0.0",
+      "hashPath": "microsoft.extensions.options.5.0.0.nupkg.sha512"
+    },
+    "Microsoft.Extensions.Primitives/5.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-cI/VWn9G1fghXrNDagX9nYaaB/nokkZn0HYAawGaELQrl8InSezfe9OnfPZLcJq3esXxygh3hkq2c3qoV3SDyQ==",
+      "path": "microsoft.extensions.primitives/5.0.0",
+      "hashPath": "microsoft.extensions.primitives.5.0.0.nupkg.sha512"
+    },
+    "System.Collections.Immutable/5.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-FXkLXiK0sVVewcso0imKQoOxjoPAj42R8HtjjbSjVPAzwDfzoyoznWxgA3c38LDbN9SJux1xXoXYAhz98j7r2g==",
+      "path": "system.collections.immutable/5.0.0",
+      "hashPath": "system.collections.immutable.5.0.0.nupkg.sha512"
+    },
+    "System.ComponentModel.Annotations/5.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-dMkqfy2el8A8/I76n2Hi1oBFEbG1SfxD2l5nhwXV3XjlnOmwxJlQbYpJH4W51odnU9sARCSAgv7S3CyAFMkpYg==",
+      "path": "system.componentmodel.annotations/5.0.0",
+      "hashPath": "system.componentmodel.annotations.5.0.0.nupkg.sha512"
+    },
+    "System.Diagnostics.DiagnosticSource/5.0.1": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-uXQEYqav2V3zP6OwkOKtLv+qIi6z3m1hsGyKwXX7ZA7htT4shoVccGxnJ9kVRFPNAsi1ArZTq2oh7WOto6GbkQ==",
+      "path": "system.diagnostics.diagnosticsource/5.0.1",
+      "hashPath": "system.diagnostics.diagnosticsource.5.0.1.nupkg.sha512"
+    },
+    "System.Reflection.Emit/4.7.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-VR4kk8XLKebQ4MZuKuIni/7oh+QGFmZW3qORd1GvBq/8026OpW501SzT/oypwiQl4TvT8ErnReh/NzY9u+C6wQ==",
+      "path": "system.reflection.emit/4.7.0",
+      "hashPath": "system.reflection.emit.4.7.0.nupkg.sha512"
+    },
+    "Backend.ApplicationCore/1.0.0": {
+      "type": "project",
+      "serviceable": false,
+      "sha512": ""
+    },
+    "Backend.Domain/1.0.0": {
+      "type": "project",
+      "serviceable": false,
+      "sha512": ""
+    }
+  }
+}

CatalogueCQRS/Backend.Data/obj/Backend.ApplicationCore.csproj.nuget.dgspec.json

+{
+  "format": 1,
+  "restore": {
+    "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Data\\Backend.ApplicationCore.csproj": {}
+  },
+  "projects": {
+    "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Data\\Backend.ApplicationCore.csproj": {
+      "version": "1.0.0",
+      "restore": {
+        "projectUniqueName": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Data\\Backend.ApplicationCore.csproj",
+        "projectName": "Backend.ApplicationCore",
+        "projectPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Data\\Backend.ApplicationCore.csproj",
+        "packagesPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\.nuget\\packages\\",
+        "outputPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Data\\obj\\",
+        "projectStyle": "PackageReference",
+        "configFilePaths": [
+          "C:\\Users\\Alex ONDOA BALEGNAMA\\AppData\\Roaming\\NuGet\\NuGet.Config",
+          "C:\\Program Files (x86)\\NuGet\\Config\\Microsoft.VisualStudio.Offline.config"
+        ],
+        "originalTargetFrameworks": [
+          "netcoreapp3.1"
+        ],
+        "sources": {
+          "C:\\Program Files (x86)\\Microsoft SDKs\\NuGetPackages\\": {},
+          "https://api.nuget.org/v3/index.json": {},
+          "https://packagesource": {}
+        },
+        "frameworks": {
+          "netcoreapp3.1": {
+            "targetAlias": "netcoreapp3.1",
+            "projectReferences": {}
+          }
+        },
+        "warningProperties": {
+          "warnAsError": [
+            "NU1605"
+          ]
+        }
+      },
+      "frameworks": {
+        "netcoreapp3.1": {
+          "targetAlias": "netcoreapp3.1",
+          "dependencies": {
+            "Microsoft.AspNet.Identity.EntityFramework": {
+              "target": "Package",
+              "version": "[2.2.3, )"
+            },
+            "Microsoft.AspNetCore.Http.Abstractions": {
+              "target": "Package",
+              "version": "[2.2.0, )"
+            },
+            "Microsoft.AspNetCore.Identity.EntityFrameworkCore": {
+              "target": "Package",
+              "version": "[5.0.10, )"
+            },
+            "Microsoft.EntityFrameworkCore": {
+              "target": "Package",
+              "version": "[5.0.10, )"
+            },
+            "Microsoft.Extensions.Configuration.Abstractions": {
+              "target": "Package",
+              "version": "[6.0.0, )"
+            },
+            "MySql.Data.EntityFrameworkCore": {
+              "target": "Package",
+              "version": "[8.0.22, )"
+            },
+            "Pomelo.EntityFrameworkCore.MySql": {
+              "target": "Package",
+              "version": "[5.0.0-alpha.2, )"
+            },
+            "System.Data.SqlClient": {
+              "target": "Package",
+              "version": "[4.8.3, )"
+            }
+          },
+          "imports": [
+            "net461",
+            "net462",
+            "net47",
+            "net471",
+            "net472",
+            "net48"
+          ],
+          "assetTargetFallback": true,
+          "warn": true,
+          "frameworkReferences": {
+            "Microsoft.NETCore.App": {
+              "privateAssets": "all"
+            }
+          },
+          "runtimeIdentifierGraphPath": "C:\\Program Files\\dotnet\\sdk\\5.0.403\\RuntimeIdentifierGraph.json"
+        }
+      }
+    }
+  }
+}

CatalogueCQRS/Backend.Data/obj/Backend.ApplicationCore.csproj.nuget.g.props

+<?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\Alex ONDOA BALEGNAMA\.nuget\packages\</NuGetPackageFolders>
+    <NuGetProjectStyle Condition=" '$(NuGetProjectStyle)' == '' ">PackageReference</NuGetProjectStyle>
+    <NuGetToolVersion Condition=" '$(NuGetToolVersion)' == '' ">5.11.1</NuGetToolVersion>
+  </PropertyGroup>
+  <ItemGroup Condition=" '$(ExcludeRestorePackageImports)' != 'true' ">
+    <SourceRoot Include="C:\Users\Alex ONDOA BALEGNAMA\.nuget\packages\" />
+  </ItemGroup>
+  <PropertyGroup>
+    <MSBuildAllProjects>$(MSBuildAllProjects);$(MSBuildThisFileFullPath)</MSBuildAllProjects>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(ExcludeRestorePackageImports)' != 'true' ">
+    <PkgEntityFramework Condition=" '$(PkgEntityFramework)' == '' ">C:\Users\Alex ONDOA BALEGNAMA\.nuget\packages\entityframework\6.1.0</PkgEntityFramework>
+  </PropertyGroup>
+</Project>

CatalogueCQRS/Backend.Data/obj/Backend.ApplicationCore.csproj.nuget.g.targets

+<?xml version="1.0" encoding="utf-8" standalone="no"?>
+<Project ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <MSBuildAllProjects>$(MSBuildAllProjects);$(MSBuildThisFileFullPath)</MSBuildAllProjects>
+  </PropertyGroup>
+</Project>

CatalogueCQRS/Backend.Data/obj/Backend.Domain.csproj.nuget.dgspec.json

+{
+  "format": 1,
+  "restore": {
+    "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Data\\Backend.Domain.csproj": {}
+  },
+  "projects": {
+    "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Data\\Backend.Domain.csproj": {
+      "version": "1.0.0",
+      "restore": {
+        "projectUniqueName": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Data\\Backend.Domain.csproj",
+        "projectName": "Backend.Domain",
+        "projectPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Data\\Backend.Domain.csproj",
+        "packagesPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\.nuget\\packages\\",
+        "outputPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Data\\obj\\",
+        "projectStyle": "PackageReference",
+        "configFilePaths": [
+          "C:\\Users\\Alex ONDOA BALEGNAMA\\AppData\\Roaming\\NuGet\\NuGet.Config",
+          "C:\\Program Files (x86)\\NuGet\\Config\\Microsoft.VisualStudio.Offline.config"
+        ],
+        "originalTargetFrameworks": [
+          "netcoreapp3.1"
+        ],
+        "sources": {
+          "C:\\Program Files (x86)\\Microsoft SDKs\\NuGetPackages\\": {},
+          "https://api.nuget.org/v3/index.json": {},
+          "https://packagesource": {}
+        },
+        "frameworks": {
+          "netcoreapp3.1": {
+            "targetAlias": "netcoreapp3.1",
+            "projectReferences": {}
+          }
+        },
+        "warningProperties": {
+          "warnAsError": [
+            "NU1605"
+          ]
+        }
+      },
+      "frameworks": {
+        "netcoreapp3.1": {
+          "targetAlias": "netcoreapp3.1",
+          "dependencies": {
+            "Microsoft.AspNet.Identity.EntityFramework": {
+              "target": "Package",
+              "version": "[2.2.3, )"
+            },
+            "Microsoft.AspNetCore.Http.Abstractions": {
+              "target": "Package",
+              "version": "[2.2.0, )"
+            },
+            "Microsoft.AspNetCore.Identity.EntityFrameworkCore": {
+              "target": "Package",
+              "version": "[5.0.10, )"
+            },
+            "Microsoft.EntityFrameworkCore": {
+              "target": "Package",
+              "version": "[5.0.10, )"
+            },
+            "Microsoft.Extensions.Configuration.Abstractions": {
+              "target": "Package",
+              "version": "[6.0.0, )"
+            },
+            "MySql.Data.EntityFrameworkCore": {
+              "target": "Package",
+              "version": "[8.0.22, )"
+            },
+            "Pomelo.EntityFrameworkCore.MySql": {
+              "target": "Package",
+              "version": "[5.0.0-alpha.2, )"
+            },
+            "System.Data.SqlClient": {
+              "target": "Package",
+              "version": "[4.8.3, )"
+            }
+          },
+          "imports": [
+            "net461",
+            "net462",
+            "net47",
+            "net471",
+            "net472",
+            "net48"
+          ],
+          "assetTargetFallback": true,
+          "warn": true,
+          "frameworkReferences": {
+            "Microsoft.NETCore.App": {
+              "privateAssets": "all"
+            }
+          },
+          "runtimeIdentifierGraphPath": "C:\\Program Files\\dotnet\\sdk\\5.0.403\\RuntimeIdentifierGraph.json"
+        }
+      }
+    }
+  }
+}

CatalogueCQRS/Backend.Data/obj/Backend.Domain.csproj.nuget.g.props

+<?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\Alex ONDOA BALEGNAMA\.nuget\packages\</NuGetPackageFolders>
+    <NuGetProjectStyle Condition=" '$(NuGetProjectStyle)' == '' ">PackageReference</NuGetProjectStyle>
+    <NuGetToolVersion Condition=" '$(NuGetToolVersion)' == '' ">5.11.1</NuGetToolVersion>
+  </PropertyGroup>
+  <ItemGroup Condition=" '$(ExcludeRestorePackageImports)' != 'true' ">
+    <SourceRoot Include="C:\Users\Alex ONDOA BALEGNAMA\.nuget\packages\" />
+  </ItemGroup>
+  <PropertyGroup>
+    <MSBuildAllProjects>$(MSBuildAllProjects);$(MSBuildThisFileFullPath)</MSBuildAllProjects>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(ExcludeRestorePackageImports)' != 'true' ">
+    <PkgEntityFramework Condition=" '$(PkgEntityFramework)' == '' ">C:\Users\Alex ONDOA BALEGNAMA\.nuget\packages\entityframework\6.1.0</PkgEntityFramework>
+  </PropertyGroup>
+</Project>