Initial Commit With TU

CatalogueCQRS/.dockerignore

@@ -0,0 +1,25 @@
+**/.classpath
+**/.dockerignore
+**/.env
+**/.git
+**/.gitignore
+**/.project
+**/.settings
+**/.toolstarget
+**/.vs
+**/.vscode
+**/*.*proj.user
+**/*.dbmdl
+**/*.jfm
+**/azds.yaml
+**/bin
+**/charts
+**/docker-compose*
+**/Dockerfile*
+**/node_modules
+**/npm-debug.log
+**/obj
+**/secrets.dev.yaml
+**/values.dev.yaml
+LICENSE
+README.md

CatalogueCQRS/Backend.API/Backend.API.csproj

@@ -0,0 +1,34 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
+    <DockerDefaultTargetOS>Windows</DockerDefaultTargetOS>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Remove="Controllers\WeatherForecastController.cs" />
+  </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" />
+  </ItemGroup>
+
+
+</Project>

CatalogueCQRS/Backend.API/Backend.API.csproj.user

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="Current" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Controller_SelectedScaffolderID>MvcControllerEmptyScaffolder</Controller_SelectedScaffolderID>
+    <Controller_SelectedScaffolderCategoryPath>root/Common/MVC/Controller</Controller_SelectedScaffolderCategoryPath>
+    <ActiveDebugProfile>IIS Express</ActiveDebugProfile>
+    <ShowAllFiles>false</ShowAllFiles>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
+    <DebuggerFlavor>ProjectDebugger</DebuggerFlavor>
+  </PropertyGroup>
+</Project>

CatalogueCQRS/Backend.API/Controllers/CommandeController.cs

@@ -0,0 +1,166 @@
+using Backend.Common;
+using Backend.Models;
+using Mediator;
+using MediatR;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Threading.Tasks;
+
+namespace Backend.API.Controllers
+{
+    [ApiController]
+    [Route("api/[controller]")]
+    public class CommandeController : ControllerBase
+    {
+        private const string getAllCommande = "getAll";
+        private const string postCreateOrUpdate = "createOrUpdate";
+        private const string deleteById = "deleteById/{id}";
+
+        private readonly ILogger<CommandeController> _log;
+        private readonly IMediator _mediator;
+
+        public CommandeController(ILogger<CommandeController> log, IMediator mediator)
+        {
+            _log = log;
+            _mediator = mediator;
+        }
+
+        /// <summary>
+        /// get all type propriete
+        /// </summary>
+        /// <returns></returns>
+        [HttpGet(getAllCommande)]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> GetAll()
+        {
+            _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);
+            }
+            try
+            {
+                var query = new GetCommandeListQuery();
+                using Task<IEnumerable<CommandeResponse>> typesTask = _mediator.Send(query);
+                await typesTask;
+                if (typesTask.IsCompleted && typesTask.IsCompletedSuccessfully)
+                {
+                    return Ok(typesTask.Result);
+                }
+                else
+                {
+                    _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_5XX}");
+                    return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.HTTP_ERROR_5XX);
+                }
+            }
+            catch (Exception ex)
+            {
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Exception:{ex.Message}");
+                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
+            }
+
+        }
+
+        /// <summary>
+        /// create or update type
+        /// </summary>
+        /// <param name="cmd"></param>
+        /// <returns></returns>
+        [HttpPost(postCreateOrUpdate)]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> CreateOrUpdate([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);
+            }
+            if(cmd != null)
+            {
+                try
+                {
+                    using Task<int> typesTask = _mediator.Send(cmd);
+                    await typesTask;
+                    if (typesTask.IsCompleted && typesTask.IsCompletedSuccessfully)
+                    {
+                        return Ok(typesTask.Result);
+                    }
+                    else
+                    {
+                        _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_5XX}");
+                        return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.HTTP_ERROR_5XX);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Exception:{ex.Message}");
+                    return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
+                }
+            }
+            else
+            {
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_4XX}");
+                return StatusCode(StatusCodes.Status400BadRequest, ErrorsConstants.HTTP_ERROR_4XX);
+            }
+           
+        }
+
+        /// <summary>
+        /// delete type by id
+        /// </summary>
+        /// <param name="id"></param>
+        /// <returns></returns>
+        [HttpDelete(deleteById)]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> DeleteById([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);
+            }
+            if (id != null)
+            {
+                try
+                {
+                    RemoveCommandeCommand removeCommandeCommand = new RemoveCommandeCommand { Id = id };
+                    using Task<int> typesTask = _mediator.Send(removeCommandeCommand);
+                    await typesTask;
+                    if (typesTask.IsCompleted && typesTask.IsCompletedSuccessfully)
+                    {
+                        return Ok(typesTask.Result);
+                    }
+                    else
+                    {
+                        _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_5XX}");
+                        return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.HTTP_ERROR_5XX);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Exception:{ex.Message}");
+                    return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
+                }
+            }
+            else
+            {
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_4XX}");
+                return StatusCode(StatusCodes.Status400BadRequest, ErrorsConstants.HTTP_ERROR_4XX);
+            }
+
+        }
+    }
+}

CatalogueCQRS/Backend.API/Controllers/LigneCommandeController.cs

@@ -0,0 +1,166 @@
+using Backend.Common;
+using Backend.Models;
+using Mediator;
+using MediatR;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Threading.Tasks;
+
+namespace Backend.API.Controllers
+{
+    [ApiController]
+    [Route("api/[controller]")]
+    public class LigneCommandeController : ControllerBase
+    {
+        private const string getAllLigneCommande = "getAll";
+        private const string postCreateOrUpdate = "createOrUpdate";
+        private const string deleteById = "deleteById/{id}";
+
+        private readonly ILogger<LigneCommandeController> _log;
+        private readonly IMediator _mediator;
+
+        public LigneCommandeController(ILogger<LigneCommandeController> log, IMediator mediator)
+        {
+            _log = log;
+            _mediator = mediator;
+        }
+
+        /// <summary>
+        /// get all type propriete
+        /// </summary>
+        /// <returns></returns>
+        [HttpGet(getAllLigneCommande)]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> GetAll()
+        {
+            _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);
+            }
+            try
+            {
+                var query = new GetLigneCommandeListQuery();
+                using Task<IEnumerable<LigneCommandeResponse>> typesTask = _mediator.Send(query);
+                await typesTask;
+                if (typesTask.IsCompleted && typesTask.IsCompletedSuccessfully)
+                {
+                    return Ok(typesTask.Result);
+                }
+                else
+                {
+                    _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_5XX}");
+                    return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.HTTP_ERROR_5XX);
+                }
+            }
+            catch (Exception ex)
+            {
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Exception:{ex.Message}");
+                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
+            }
+
+        }
+
+        /// <summary>
+        /// create or update type
+        /// </summary>
+        /// <param name="cmd"></param>
+        /// <returns></returns>
+        [HttpPost(postCreateOrUpdate)]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> CreateOrUpdate([FromBody] AddLigneCommandeCommand 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);
+            }
+            if(cmd != null)
+            {
+                try
+                {
+                    using Task<int> typesTask = _mediator.Send(cmd);
+                    await typesTask;
+                    if (typesTask.IsCompleted && typesTask.IsCompletedSuccessfully)
+                    {
+                        return Ok(typesTask.Result);
+                    }
+                    else
+                    {
+                        _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_5XX}");
+                        return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.HTTP_ERROR_5XX);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Exception:{ex.Message}");
+                    return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
+                }
+            }
+            else
+            {
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_4XX}");
+                return StatusCode(StatusCodes.Status400BadRequest, ErrorsConstants.HTTP_ERROR_4XX);
+            }
+           
+        }
+
+        /// <summary>
+        /// delete type by id
+        /// </summary>
+        /// <param name="id"></param>
+        /// <returns></returns>
+        [HttpDelete(deleteById)]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> DeleteById([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);
+            }
+            if (id != null)
+            {
+                try
+                {
+                    RemoveLigneCommandeCommand removeLigneCommandeCommand = new RemoveLigneCommandeCommand { Id = id };
+                    using Task<int> typesTask = _mediator.Send(removeLigneCommandeCommand);
+                    await typesTask;
+                    if (typesTask.IsCompleted && typesTask.IsCompletedSuccessfully)
+                    {
+                        return Ok(typesTask.Result);
+                    }
+                    else
+                    {
+                        _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_5XX}");
+                        return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.HTTP_ERROR_5XX);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Exception:{ex.Message}");
+                    return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
+                }
+            }
+            else
+            {
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_4XX}");
+                return StatusCode(StatusCodes.Status400BadRequest, ErrorsConstants.HTTP_ERROR_4XX);
+            }
+
+        }
+    }
+}

CatalogueCQRS/Backend.API/Controllers/ProduitController.cs

@@ -0,0 +1,166 @@
+using Backend.Common;
+using Backend.Models;
+using Mediator;
+using MediatR;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Threading.Tasks;
+
+namespace Backend.API.Controllers
+{
+    [ApiController]
+    [Route("api/[controller]")]
+    public class ProduitController : ControllerBase
+    {
+        private const string getAllProduit = "getAll";
+        private const string postCreateOrUpdate = "createOrUpdate";
+        private const string deleteById = "deleteById/{id}";
+
+        private readonly ILogger<ProduitController> _log;
+        private readonly IMediator _mediator;
+
+        public ProduitController(ILogger<ProduitController> log, IMediator mediator)
+        {
+            _log = log;
+            _mediator = mediator;
+        }
+
+        /// <summary>
+        /// get all type propriete
+        /// </summary>
+        /// <returns></returns>
+        [HttpGet(getAllProduit)]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> GetAll()
+        {
+            _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);
+            }
+            try
+            {
+                var query = new GetProduitListQuery();
+                using Task<IEnumerable<ProduitResponse>> typesTask = _mediator.Send(query);
+                await typesTask;
+                if (typesTask.IsCompleted && typesTask.IsCompletedSuccessfully)
+                {
+                    return Ok(typesTask.Result);
+                }
+                else
+                {
+                    _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_5XX}");
+                    return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.HTTP_ERROR_5XX);
+                }
+            }
+            catch (Exception ex)
+            {
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Exception:{ex.Message}");
+                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
+            }
+
+        }
+
+        /// <summary>
+        /// create or update type
+        /// </summary>
+        /// <param name="cmd"></param>
+        /// <returns></returns>
+        [HttpPost(postCreateOrUpdate)]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> CreateOrUpdate([FromBody] AddProduitCommand 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);
+            }
+            if(cmd != null)
+            {
+                try
+                {
+                    using Task<int> typesTask = _mediator.Send(cmd);
+                    await typesTask;
+                    if (typesTask.IsCompleted && typesTask.IsCompletedSuccessfully)
+                    {
+                        return Ok(typesTask.Result);
+                    }
+                    else
+                    {
+                        _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_5XX}");
+                        return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.HTTP_ERROR_5XX);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Exception:{ex.Message}");
+                    return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
+                }
+            }
+            else
+            {
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_4XX}");
+                return StatusCode(StatusCodes.Status400BadRequest, ErrorsConstants.HTTP_ERROR_4XX);
+            }
+           
+        }
+
+        /// <summary>
+        /// delete type by id
+        /// </summary>
+        /// <param name="id"></param>
+        /// <returns></returns>
+        [HttpDelete(deleteById)]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> DeleteById([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);
+            }
+            if (id != null)
+            {
+                try
+                {
+                    RemoveProduitCommand removeProduitCommand = new RemoveProduitCommand { Id = id };
+                    using Task<int> typesTask = _mediator.Send(removeProduitCommand);
+                    await typesTask;
+                    if (typesTask.IsCompleted && typesTask.IsCompletedSuccessfully)
+                    {
+                        return Ok(typesTask.Result);
+                    }
+                    else
+                    {
+                        _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_5XX}");
+                        return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.HTTP_ERROR_5XX);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Exception:{ex.Message}");
+                    return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
+                }
+            }
+            else
+            {
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_4XX}");
+                return StatusCode(StatusCodes.Status400BadRequest, ErrorsConstants.HTTP_ERROR_4XX);
+            }
+
+        }
+    }
+}

CatalogueCQRS/Backend.API/Controllers/ProprieteController.cs

@@ -0,0 +1,166 @@
+using Backend.Common;
+using Backend.Models;
+using Mediator;
+using MediatR;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Threading.Tasks;
+
+namespace Backend.API.Controllers
+{
+    [ApiController]
+    [Route("api/[controller]")]
+    public class ProprieteController : ControllerBase
+    {
+        private const string getAllPropriete = "getAll";
+        private const string postCreateOrUpdate = "createOrUpdate";
+        private const string deleteById = "deleteById/{id}";
+
+        private readonly ILogger<ProprieteController> _log;
+        private readonly IMediator _mediator;
+
+        public ProprieteController(ILogger<ProprieteController> log, IMediator mediator)
+        {
+            _log = log;
+            _mediator = mediator;
+        }
+
+        /// <summary>
+        /// get all type propriete
+        /// </summary>
+        /// <returns></returns>
+        [HttpGet(getAllPropriete)]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> GetAll()
+        {
+            _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);
+            }
+            try
+            {
+                var query = new GetProprieteListQuery();
+                using Task<IEnumerable<ProprieteResponse>> typesTask = _mediator.Send(query);
+                await typesTask;
+                if (typesTask.IsCompleted && typesTask.IsCompletedSuccessfully)
+                {
+                    return Ok(typesTask.Result);
+                }
+                else
+                {
+                    _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_5XX}");
+                    return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.HTTP_ERROR_5XX);
+                }
+            }
+            catch (Exception ex)
+            {
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Exception:{ex.Message}");
+                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
+            }
+
+        }
+
+        /// <summary>
+        /// create or update type
+        /// </summary>
+        /// <param name="cmd"></param>
+        /// <returns></returns>
+        [HttpPost(postCreateOrUpdate)]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> CreateOrUpdate([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);
+            }
+            if(cmd != null)
+            {
+                try
+                {
+                    using Task<int> typesTask = _mediator.Send(cmd);
+                    await typesTask;
+                    if (typesTask.IsCompleted && typesTask.IsCompletedSuccessfully)
+                    {
+                        return Ok(typesTask.Result);
+                    }
+                    else
+                    {
+                        _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_5XX}");
+                        return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.HTTP_ERROR_5XX);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Exception:{ex.Message}");
+                    return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
+                }
+            }
+            else
+            {
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_4XX}");
+                return StatusCode(StatusCodes.Status400BadRequest, ErrorsConstants.HTTP_ERROR_4XX);
+            }
+           
+        }
+
+        /// <summary>
+        /// delete type by id
+        /// </summary>
+        /// <param name="id"></param>
+        /// <returns></returns>
+        [HttpDelete(deleteById)]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> DeleteById([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);
+            }
+            if (id != null)
+            {
+                try
+                {
+                    RemoveProprieteCommand removeProprieteCommand = new RemoveProprieteCommand { Id = id };
+                    using Task<int> typesTask = _mediator.Send(removeProprieteCommand);
+                    await typesTask;
+                    if (typesTask.IsCompleted && typesTask.IsCompletedSuccessfully)
+                    {
+                        return Ok(typesTask.Result);
+                    }
+                    else
+                    {
+                        _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_5XX}");
+                        return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.HTTP_ERROR_5XX);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Exception:{ex.Message}");
+                    return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
+                }
+            }
+            else
+            {
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_4XX}");
+                return StatusCode(StatusCodes.Status400BadRequest, ErrorsConstants.HTTP_ERROR_4XX);
+            }
+
+        }
+    }
+}

CatalogueCQRS/Backend.API/Controllers/TypeProprieteController.cs

@@ -0,0 +1,166 @@
+using Backend.Common;
+using Backend.Models;
+using Mediator;
+using MediatR;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Threading.Tasks;
+
+namespace Backend.API.Controllers
+{
+    [ApiController]
+    [Route("api/[controller]")]
+    public class TypeProprieteController : ControllerBase
+    {
+        private const string getAllTypePropriete = "getAll";
+        private const string postCreateOrUpdate = "createOrUpdate";
+        private const string deleteById = "deleteById/{id}";
+
+        private readonly ILogger<TypeProprieteController> _log;
+        private readonly IMediator _mediator;
+
+        public TypeProprieteController(ILogger<TypeProprieteController> log, IMediator mediator)
+        {
+            _log = log;
+            _mediator = mediator;
+        }
+
+        /// <summary>
+        /// get all type propriete
+        /// </summary>
+        /// <returns></returns>
+        [HttpGet(getAllTypePropriete)]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> GetAll()
+        {
+            _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);
+            }
+            try
+            {
+                var query = new GetTypeProprieteListQuery();
+                using Task<IEnumerable<TypeProprieteResponse>> typesTask = _mediator.Send(query);
+                await typesTask;
+                if (typesTask.IsCompleted && typesTask.IsCompletedSuccessfully)
+                {
+                    return Ok(typesTask.Result);
+                }
+                else
+                {
+                    _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_5XX}");
+                    return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.HTTP_ERROR_5XX);
+                }
+            }
+            catch (Exception ex)
+            {
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Exception:{ex.Message}");
+                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
+            }
+
+        }
+
+        /// <summary>
+        /// create or update type
+        /// </summary>
+        /// <param name="cmd"></param>
+        /// <returns></returns>
+        [HttpPost(postCreateOrUpdate)]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> CreateOrUpdate([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);
+            }
+            if(cmd != null)
+            {
+                try
+                {
+                    using Task<int> typesTask = _mediator.Send(cmd);
+                    await typesTask;
+                    if (typesTask.IsCompleted && typesTask.IsCompletedSuccessfully)
+                    {
+                        return Ok(typesTask.Result);
+                    }
+                    else
+                    {
+                        _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_5XX}");
+                        return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.HTTP_ERROR_5XX);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Exception:{ex.Message}");
+                    return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
+                }
+            }
+            else
+            {
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_4XX}");
+                return StatusCode(StatusCodes.Status400BadRequest, ErrorsConstants.HTTP_ERROR_4XX);
+            }
+           
+        }
+
+        /// <summary>
+        /// delete type by id
+        /// </summary>
+        /// <param name="id"></param>
+        /// <returns></returns>
+        [HttpDelete(deleteById)]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> DeleteById([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);
+            }
+            if (id != null)
+            {
+                try
+                {
+                    RemoveTypeProprieteCommand removeTypeProprieteCommand = new RemoveTypeProprieteCommand { Id = id };
+                    using Task<int> typesTask = _mediator.Send(removeTypeProprieteCommand);
+                    await typesTask;
+                    if (typesTask.IsCompleted && typesTask.IsCompletedSuccessfully)
+                    {
+                        return Ok(typesTask.Result);
+                    }
+                    else
+                    {
+                        _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_5XX}");
+                        return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.HTTP_ERROR_5XX);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Exception:{ex.Message}");
+                    return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
+                }
+            }
+            else
+            {
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.HTTP_ERROR_4XX}");
+                return StatusCode(StatusCodes.Status400BadRequest, ErrorsConstants.HTTP_ERROR_4XX);
+            }
+
+        }
+    }
+}

CatalogueCQRS/Backend.API/Controllers/WeatherForecastController.cs

@@ -0,0 +1,39 @@
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace Backend.API.Controllers
+{
+    [ApiController]
+    [Route("[controller]")]
+    public class WeatherForecastController : ControllerBase
+    {
+        private static readonly string[] Summaries = new[]
+        {
+            "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
+        };
+
+        private readonly ILogger<WeatherForecastController> _logger;
+
+        public WeatherForecastController(ILogger<WeatherForecastController> logger)
+        {
+            _logger = logger;
+        }
+
+        [HttpGet]
+        public IEnumerable<WeatherForecast> Get()
+        {
+            var rng = new Random();
+            return Enumerable.Range(1, 5).Select(index => new WeatherForecast
+            {
+                Date = DateTime.Now.AddDays(index),
+                TemperatureC = rng.Next(-20, 55),
+                Summary = Summaries[rng.Next(Summaries.Length)]
+            })
+            .ToArray();
+        }
+    }
+}

CatalogueCQRS/Backend.API/Dockerfile

@@ -0,0 +1,29 @@
+#See https://aka.ms/containerfastmode to understand how Visual Studio uses this Dockerfile to build your images for faster debugging.
+
+#Depending on the operating system of the host machines(s) that will build or run the containers, the image specified in the FROM statement may need to be changed.
+#For more information, please see https://aka.ms/containercompat
+
+FROM mcr.microsoft.com/dotnet/aspnet:3.1 AS base
+WORKDIR /app
+EXPOSE 80
+
+FROM mcr.microsoft.com/dotnet/sdk:3.1 AS build
+WORKDIR /src
+COPY ["Backend.API/Backend.API.csproj", "Backend.API/"]
+COPY ["Backend.Common/Backend.Common.csproj", "Backend.Common/"]
+COPY ["Mediator/Mediator.csproj", "Mediator/"]
+COPY ["Backend.Models/Backend.Models.csproj", "Backend.Models/"]
+COPY ["Backend.Services/Backend.Services.csproj", "Backend.Services/"]
+COPY ["Backend.Data/Backend.Data.csproj", "Backend.Data/"]
+RUN dotnet restore "Backend.API/Backend.API.csproj"
+COPY . .
+WORKDIR "/src/Backend.API"
+RUN dotnet build "Backend.API.csproj" -c Release -o /app/build
+
+FROM build AS publish
+RUN dotnet publish "Backend.API.csproj" -c Release -o /app/publish
+
+FROM base AS final
+WORKDIR /app
+COPY --from=publish /app/publish .
+ENTRYPOINT ["dotnet", "Backend.API.dll"]

CatalogueCQRS/Backend.API/Program.cs

@@ -0,0 +1,26 @@
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace Backend.API
+{
+    public class Program
+    {
+        public static void Main(string[] args)
+        {
+            CreateHostBuilder(args).Build().Run();
+        }
+
+        public static IHostBuilder CreateHostBuilder(string[] args) =>
+            Host.CreateDefaultBuilder(args)
+                .ConfigureWebHostDefaults(webBuilder =>
+                {
+                    webBuilder.UseStartup<Startup>();
+                });
+    }
+}

CatalogueCQRS/Backend.API/Properties/launchSettings.json

@@ -0,0 +1,36 @@
+{
+  "iisSettings": {
+    "windowsAuthentication": false,
+    "anonymousAuthentication": true,
+    "iisExpress": {
+      "applicationUrl": "http://localhost:43012/",
+      "sslPort": 0
+    }
+  },
+  "$schema": "http://json.schemastore.org/launchsettings.json",
+  "profiles": {
+    "IIS Express": {
+      "commandName": "IISExpress",
+      "launchBrowser": true,
+      "launchUrl": "swagger",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    },
+    "Backend.API": {
+      "commandName": "Project",
+      "launchBrowser": true,
+      "launchUrl": "swagger",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      },
+      "applicationUrl": "http://localhost:5000"
+    },
+    "Docker (1)": {
+      "commandName": "Docker",
+      "launchBrowser": true,
+      "launchUrl": "{Scheme}://{ServiceHost}:{ServicePort}/swagger",
+      "publishAllPorts": true
+    }
+  }
+}

CatalogueCQRS/Backend.API/Startup.cs

@@ -0,0 +1,135 @@
+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 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
+{
+    public class Startup
+    {
+        private readonly IConfiguration _configuration = null;
+        private readonly IHostEnvironment _appEnvironment = null;
+        public Startup(IConfiguration configuration, IHostEnvironment appEnvironment)
+        {
+            _configuration = configuration;
+            _appEnvironment = appEnvironment;
+        }
+
+        // This method gets called by the runtime. Use this method to add services to the container.
+        public void ConfigureServices(IServiceCollection services)
+        {
+            services.AddControllers();
+            services.AddOptions();
+
+            AddDataDependencyInjectionService(services);
+
+            AddDataDependencyInjectionRepository(services);
+
+            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)
+            {
+                services.AddDatabaseModule(_configuration);
+            }
+        }
+        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
+        public void Configure(IApplicationBuilder app, IWebHostEnvironment env, IServiceProvider serviceProvider)
+        {
+            if (env.IsDevelopment())
+            {
+                app.UseDeveloperExceptionPage();
+            }
+
+            app.UseRouting();
+
+            app.UseAuthorization();
+
+            app.UseEndpoints(endpoints =>
+            {
+                endpoints.MapControllers();
+            });
+            app.UseApplicationDatabase(serviceProvider);
+            app.UseSwagger();
+            app.UseSwaggerUI(c => {
+                c.SwaggerEndpoint("/swagger/v2/swagger.json", "Catalogue.Backend.API");
+            });
+        }
+
+    
+
+    }
+}

CatalogueCQRS/Backend.API/appsettings.Development.json

@@ -0,0 +1,9 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft": "Warning",
+      "Microsoft.Hosting.Lifetime": "Information"
+    }
+  }
+}

CatalogueCQRS/Backend.API/appsettings.json

@@ -0,0 +1,13 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft": "Warning",
+      "Microsoft.Hosting.Lifetime": "Information"
+    }
+  },
+  "ConnectionStrings": {
+    "AppDbContext": "server=localhost; port=3306; database=cataloguedb; user=root; password=Password123*; Persist Security Info=False; Connect Timeout=300"
+  },
+  "AllowedHosts": "*"
+}

CatalogueCQRS/Backend.API/bin/Debug/netcoreapp3.1/Backend.API.runtimeconfig.dev.json

@@ -0,0 +1,8 @@
+{
+  "runtimeOptions": {
+    "additionalProbingPaths": [
+      "C:\\Users\\Alex ONDOA BALEGNAMA\\.dotnet\\store\\|arch|\\|tfm|",
+      "C:\\Users\\Alex ONDOA BALEGNAMA\\.nuget\\packages"
+    ]
+  }
+}

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

@@ -0,0 +1,13 @@
+{
+  "runtimeOptions": {
+    "tfm": "netcoreapp3.1",
+    "framework": {
+      "name": "Microsoft.AspNetCore.App",
+      "version": "3.1.0"
+    },
+    "configProperties": {
+      "System.GC.Server": true,
+      "System.Runtime.Serialization.EnableUnsafeBinaryFormatterSerialization": false
+    }
+  }
+}

CatalogueCQRS/Backend.API/bin/Debug/netcoreapp3.1/appsettings.Development.json

@@ -0,0 +1,9 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft": "Warning",
+      "Microsoft.Hosting.Lifetime": "Information"
+    }
+  }
+}

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

@@ -0,0 +1,13 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft": "Warning",
+      "Microsoft.Hosting.Lifetime": "Information"
+    }
+  },
+  "ConnectionStrings": {
+    "AppDbContext": "server=localhost; port=3306; database=cataloguedb; user=root; password=Password123*; Persist Security Info=False; Connect Timeout=300"
+  },
+  "AllowedHosts": "*"
+}

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

@@ -0,0 +1,462 @@
+{
+  "format": 1,
+  "restore": {
+    "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.API\\Backend.API.csproj": {}
+  },
+  "projects": {
+    "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.API\\Backend.API.csproj": {
+      "version": "1.0.0",
+      "restore": {
+        "projectUniqueName": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.API\\Backend.API.csproj",
+        "projectName": "Backend.API",
+        "projectPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.API\\Backend.API.csproj",
+        "packagesPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\.nuget\\packages\\",
+        "outputPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.API\\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": {
+              "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\\Mediator\\Mediator.csproj": {
+                "projectPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Mediator\\Mediator.csproj"
+              }
+            }
+          }
+        },
+        "warningProperties": {
+          "warnAsError": [
+            "NU1605"
+          ]
+        }
+      },
+      "frameworks": {
+        "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, )"
+            },
+            "Swashbuckle.AspNetCore.SwaggerGen": {
+              "target": "Package",
+              "version": "[6.2.3, )"
+            },
+            "Swashbuckle.AspNetCore.SwaggerUI": {
+              "target": "Package",
+              "version": "[6.2.3, )"
+            }
+          },
+          "imports": [
+            "net461",
+            "net462",
+            "net47",
+            "net471",
+            "net472",
+            "net48"
+          ],
+          "assetTargetFallback": true,
+          "warn": true,
+          "frameworkReferences": {
+            "Microsoft.AspNetCore.App": {
+              "privateAssets": "none"
+            },
+            "Microsoft.NETCore.App": {
+              "privateAssets": "all"
+            }
+          },
+          "runtimeIdentifierGraphPath": "C:\\Program Files\\dotnet\\sdk\\5.0.403\\RuntimeIdentifierGraph.json"
+        }
+      }
+    },
+    "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Common\\Backend.Common.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",
+        "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"
+        }
+      }
+    },
+    "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Data\\Backend.Data.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",
+        "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"
+        }
+      }
+    },
+    "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": {
+          "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"
+        }
+      }
+    },
+    "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Backend.Services\\Backend.Services.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",
+        "packagesPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\.nuget\\packages\\",
+        "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",
+          "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": {
+              "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"
+              }
+            }
+          }
+        },
+        "warningProperties": {
+          "warnAsError": [
+            "NU1605"
+          ]
+        }
+      },
+      "frameworks": {
+        "netcoreapp3.1": {
+          "targetAlias": "netcoreapp3.1",
+          "dependencies": {
+            "AutoMapper": {
+              "target": "Package",
+              "version": "[10.1.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"
+        }
+      }
+    },
+    "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Mediator\\Mediator.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",
+        "packagesPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\.nuget\\packages\\",
+        "outputPath": "C:\\Users\\Alex ONDOA BALEGNAMA\\source\\repos\\Backend\\CatalogueCQRS\\Mediator\\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": {
+              "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"
+              }
+            }
+          }
+        },
+        "warningProperties": {
+          "warnAsError": [
+            "NU1605"
+          ]
+        }
+      },
+      "frameworks": {
+        "netcoreapp3.1": {
+          "targetAlias": "netcoreapp3.1",
+          "dependencies": {
+            "MediatR": {
+              "target": "Package",
+              "version": "[7.0.0, )"
+            },
+            "MediatR.Extensions.Microsoft.DependencyInjection": {
+              "target": "Package",
+              "version": "[7.0.0, )"
+            }
+          },
+          "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.API/obj/Backend.API.csproj.nuget.g.props

@@ -0,0 +1,27 @@
+<?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>
+  <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/Backend.API.csproj.nuget.g.targets

@@ -0,0 +1,9 @@
+<?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>
+  <ImportGroup Condition=" '$(ExcludeRestorePackageImports)' != 'true' ">
+    <Import Project="$(NuGetPackageRoot)microsoft.visualstudio.azure.containers.tools.targets\1.11.1\build\Microsoft.VisualStudio.Azure.Containers.Tools.Targets.targets" Condition="Exists('$(NuGetPackageRoot)microsoft.visualstudio.azure.containers.tools.targets\1.11.1\build\Microsoft.VisualStudio.Azure.Containers.Tools.Targets.targets')" />
+  </ImportGroup>
+</Project>