devops: added dockerfile and other configs

Reviewed-on: https://gitea.white-enciso.pro/AgileWebs/Core.Inventory.BFF/pulls/6
Reviewed-by: efrain_marin <efrain.marin@agilewebs.com>
Reviewed-by: Sergio Matías <sergio.matias@agilewebs.com>

.dockerignore

@@ -0,0 +1,12 @@
+**/bin
+**/obj
+**/out
+**/.vs
+**/.idea
+**/.git
+**/.gitignore
+**/node_modules
+*.user
+*.swp
+*.swo
+.DS_Store

Core.Inventory.BFF.API/Controllers/ProductController.cs

@@ -0,0 +1,307 @@
+using Asp.Versioning;
+using Core.Adapters.Lib.Inventory;
+using Core.Inventory.External.Clients.Inventory;
+using Core.Inventory.External.Clients.Inventory.Requests.Product;
+using Lib.Architecture.BuildingBlocks;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using System.Text.Json;
+
+namespace Core.Inventory.BFF.API.Controllers
+{
+    /// <summary>
+    /// Handles all requests for Product operations.
+    /// </summary>
+    [ApiVersion("1.0")]
+    [Route("api/v{version:apiVersion}/[controller]")]
+    [Consumes("application/json")]
+    [Produces("application/json")]
+    [ApiController]
+    [AllowAnonymous]
+    public class ProductController(IInventoryServiceClient inventoryServiceClient, ILogger<ProductController> logger) : BaseController(logger)
+    {
+        /// <summary>
+        /// Gets all the Products.
+        /// </summary>
+        [HttpGet("GetAll")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> GetAllProductsService(CancellationToken cancellationToken)
+        {
+            try
+            {
+                logger.LogInformation($"{nameof(GetAllProductsService)} - Request received - Payload: ");
+
+                return await Handle(() => inventoryServiceClient.GetAllProductsService(new GetAllProductsRequest { }, cancellationToken)).ConfigureAwait(false);
+            }
+            catch (Exception ex)
+            {
+                logger.LogError($"{nameof(GetAllProductsService)} - An Error Occurred- {ex.Message} - {ex.InnerException} - {ex.StackTrace} - with payload");
+                throw;
+            }
+        }
+
+        /// <summary>
+        /// Gets all the Products by Product identifiers.
+        /// </summary>
+        /// <param name="request">The request containing the list of Product identifiers.</param>
+        /// <param name="cancellationToken">Cancellation token for the asynchronous operation.</param>
+        /// <returns>The <see cref="IActionResult"/> representing the result of the service call.</returns>
+        /// <response code="200">The Products found.</response>
+        /// <response code="204">No content if no Products are found.</response>
+        /// <response code="400">Bad request if the Product identifiers are missing or invalid.</response>
+        /// <response code="401">Unauthorized if the user is not authenticated.</response>
+        /// <response code="500">Internal server error if an unexpected error occurs.</response>
+        [HttpPost("GetAllByList")]
+        [ProducesResponseType(typeof(IEnumerable<ProductAdapter>), StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status204NoContent)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> GetAllProductsByListAsync([FromBody] GetAllProductsByListRequest request, CancellationToken cancellationToken)
+        {
+            try
+            {
+                logger.LogInformation($"{nameof(GetAllProductsByListAsync)} - Request received - Payload: {request}");
+
+                if (request == null || request.Products == null || !request.Products.Any())
+                {
+                    return BadRequest("Product identifiers are required.");
+                }
+
+                return await Handle(() => inventoryServiceClient.GetAllProductsByListService(request, cancellationToken)).ConfigureAwait(false);
+
+            }
+            catch (Exception ex)
+            {
+                logger.LogError(ex, $"{nameof(GetAllProductsByListAsync)} - An error occurred - {ex.Message} - {ex.InnerException} - {ex.StackTrace} - with payload: {request}");
+                return StatusCode(StatusCodes.Status500InternalServerError, "Internal server error");
+            }
+        }
+
+        /// <summary>
+        /// Creates a new Product.
+        /// </summary>
+        [HttpPost("Create")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> CreateProductService(CreateProductRequest newProduct, CancellationToken cancellationToken)
+        {
+            try
+            {
+                logger.LogInformation($"{nameof(CreateProductService)} - Request received - Payload: {JsonSerializer.Serialize(newProduct)}");
+
+                if (newProduct == null) return BadRequest("Invalid Product object");
+
+                if (string.IsNullOrEmpty(newProduct.ProductName)) return BadRequest("Invalid Product name");
+
+                return await Handle(() => inventoryServiceClient.CreateProductService(newProduct, cancellationToken)).ConfigureAwait(false);
+            }
+            catch (Exception ex)
+            {
+                logger.LogError($"{nameof(CreateProductService)} - An Error Occurred- {ex.Message} - {ex.InnerException} - {ex.StackTrace} - with payload {JsonSerializer.Serialize(newProduct)}");
+                throw;
+            }
+        }
+
+        /// <summary>
+        /// Gets the Product by identifier.
+        /// </summary>
+        [HttpPost("GetById")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> GetProductByIdService(GetProductRequest request, CancellationToken cancellationToken)
+        {
+            try
+            {
+                logger.LogInformation($"{nameof(GetProductByIdService)} - Request received - Payload: {JsonSerializer.Serialize(request)}");
+
+                if (string.IsNullOrEmpty(request.Id)) return BadRequest("Invalid Product identifier");
+
+                return await Handle(() => inventoryServiceClient.GetProductByIdService(request, cancellationToken)).ConfigureAwait(false);
+            }
+            catch (Exception ex)
+            {
+                logger.LogError($"{nameof(GetProductByIdService)} - An Error Occurred- {ex.Message} - {ex.InnerException} - {ex.StackTrace} - with payload {JsonSerializer.Serialize(request)}");
+                throw;
+            }
+        }
+
+        /// <summary>
+        /// Updates a full Product by identifier.
+        /// </summary>
+        [HttpPut("Update")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> UpdateProductService(UpdateProductRequest newProduct, CancellationToken cancellationToken)
+        {
+            try
+            {
+                logger.LogInformation($"{nameof(UpdateProductService)} - Request received - Payload: {JsonSerializer.Serialize(newProduct)}");
+
+                if (newProduct == null) return BadRequest("Invalid Product object");
+
+                if (string.IsNullOrEmpty(newProduct.ProductName)) return BadRequest("Invalid Product name");
+
+                return await Handle(() => inventoryServiceClient.UpdateProductService(newProduct, cancellationToken)).ConfigureAwait(false);
+            }
+            catch (Exception ex)
+            {
+                logger.LogError($"{nameof(UpdateProductService)} - An Error Occurred- {ex.Message} - {ex.InnerException} - {ex.StackTrace} - with payload {JsonSerializer.Serialize(newProduct)}");
+                throw;
+            }
+        }
+
+        /// <summary>
+        /// Changes the status of the Product.
+        /// </summary>
+        /// <param name="request">The request containing the product ID and new ProductStatus.</param>
+        /// <returns>The <see cref="ProductAdapter"/> updated entity.</returns>
+        /// <response code="200">The Product updates.</response>
+        /// <response code="204">The Product not found.</response>
+        /// <response code="400">The Product could not be updated.</response>
+        /// <response code="401">The Product could not be updated.</response>
+        /// <response code="412">The Product could not be updated.</response>
+        /// <response code="422">The Product could not be updated.</response>
+        /// <response code="500">The service internal error.</response>
+        [HttpPatch]
+        [Route("ChangeStatus")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status204NoContent)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> ChangeProductStatusService([FromBody] ChangeProductStatusRequest request, CancellationToken cancellationToken)
+        {
+            try
+            {
+                logger.LogInformation($"{nameof(ChangeProductStatusService)} - Request received - Payload: {JsonSerializer.Serialize(request)}");
+
+                if (string.IsNullOrEmpty(request.Id)) { return BadRequest("Invalid Product identifier"); }
+
+                return await Handle(() => inventoryServiceClient.ChangeProductStatusService(request, cancellationToken)).ConfigureAwait(false);
+            }
+            catch (Exception ex)
+            {
+                logger.LogError($"{nameof(ChangeProductStatusService)} - An Error Occurred- {ex.Message} - {ex.InnerException} - {ex.StackTrace} - with payload {JsonSerializer.Serialize(request)}");
+                throw;
+            }
+        }
+
+        /// <summary>
+        /// Adds a tag to the product.
+        /// </summary>
+        [HttpPost]
+        [Route("AddTag")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status204NoContent)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> AddTagToProductAsync([FromBody] AddTagToProductRequest request, CancellationToken cancellationToken)
+        {
+            try
+            {
+                logger.LogInformation($"{nameof(AddTagToProductAsync)} - Request received - Payload: {JsonSerializer.Serialize(request)}");
+
+                if (string.IsNullOrEmpty(request.ProductId)) { return BadRequest("Invalid product identifier"); }
+                if (string.IsNullOrEmpty(request.TagId)) { return BadRequest("Invalid tag identifier"); }
+
+                return await Handle(() => inventoryServiceClient.AddTagToProductAsync(request, cancellationToken)).ConfigureAwait(false);
+            }
+            catch (Exception ex)
+            {
+                logger.LogError($"{nameof(AddTagToProductAsync)} - An Error Occurred- {ex.Message} - {ex.InnerException} - {ex.StackTrace} - with payload {JsonSerializer.Serialize(request)}");
+                throw;
+            }
+        }
+
+        /// <summary>
+        /// Remove a tag from the product.
+        /// </summary>
+        [HttpDelete]
+        [Route("RemoveTag")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status204NoContent)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> RemoveTagFromProductAsync([FromBody] RemoveTagFromProductRequest request, CancellationToken cancellationToken)
+        {
+            try
+            {
+                logger.LogInformation($"{nameof(RemoveTagFromProductAsync)} - Request received - Payload: {JsonSerializer.Serialize(request)}");
+
+                if (string.IsNullOrEmpty(request.ProductId)) { return BadRequest("Invalid product identifier"); }
+                if (string.IsNullOrEmpty(request.TagId)) { return BadRequest("Invalid tag identifier"); }
+
+                return await Handle(() => inventoryServiceClient.RemoveTagFromProductAsync(request, cancellationToken)).ConfigureAwait(false);
+            }
+            catch (Exception ex)
+            {
+                logger.LogError($"{nameof(RemoveTagFromProductAsync)} - An Error Occurred- {ex.Message} - {ex.InnerException} - {ex.StackTrace} - with payload {JsonSerializer.Serialize(request)}");
+                throw;
+            }
+        }
+
+        /// <summary>
+        /// Deletes a Product by its identifier.
+        /// </summary>
+        /// <param name="request">The request containing the product ID to delete.</param>
+        /// <param name="cancellationToken">Cancellation token for the asynchronous operation.</param>
+        /// <returns>The <see cref="IActionResult"/> representing the result of the service call.</returns>
+        /// <response code="200">The Product deleted successfully.</response>
+        /// <response code="204">No content if the Product was not found.</response>
+        /// <response code="400">Bad request if the Product ID is missing or invalid.</response>
+        /// <response code="401">Unauthorized if the user is not authenticated.</response>
+        /// <response code="412">Precondition failed if the request does not meet expected conditions.</response>
+        /// <response code="422">Unprocessable entity if the request cannot be processed.</response>
+        /// <response code="500">Internal server error if an unexpected error occurs.</response>
+        [HttpDelete("Delete")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status204NoContent)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> DeleteProductService([FromBody] DeleteProductRequest request, CancellationToken cancellationToken)
+        {
+            try
+            {
+                logger.LogInformation($"{nameof(DeleteProductService)} - Request received - Payload: {JsonSerializer.Serialize(request)}");
+
+                if (string.IsNullOrEmpty(request.Id)) { return BadRequest("Invalid Product identifier"); }
+
+                return await Handle(() => inventoryServiceClient.DeleteProductService(request, cancellationToken)).ConfigureAwait(false);
+            }
+            catch (Exception ex)
+            {
+                logger.LogError($"{nameof(DeleteProductService)} - An Error Occurred- {ex.Message} - {ex.InnerException} - {ex.StackTrace} - with payload {JsonSerializer.Serialize(request)}");
+                throw;
+            }
+        }
+    }
+} 

Core.Inventory.BFF.API/Controllers/TagController.cs

@@ -0,0 +1,291 @@
+using Asp.Versioning;
+using Core.Adapters.Lib;
+using Core.Inventory.External.Clients.Inventory;
+using Core.Inventory.External.Clients.Inventory.Requests.Tag;
+using Core.Inventory.External.Clients.Inventory.Requests.TagType;
+using Lib.Architecture.BuildingBlocks;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using System.Text.Json;
+
+namespace Core.Inventory.BFF.API.Controllers
+{
+    /// <summary>
+    /// Handles all requests for Tag authentication.
+    /// </summary>
+    [ApiVersion("1.0")]
+    [Route("api/v{version:apiVersion}/[controller]")]
+    [Consumes("application/json")]
+    [Produces("application/json")]
+    [ApiController]
+    [AllowAnonymous]
+    public class TagController(IInventoryServiceClient inventoryServiceClient, ILogger<TagController> logger) : BaseController(logger)
+    {
+        /// <summary>
+        /// Gets all the Tags.
+        /// </summary>
+        [HttpGet("GetAll")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> GetAllTagsService(CancellationToken cancellationToken)
+        {
+            try
+            {
+                logger.LogInformation($"{nameof(GetAllTagsService)} - Request received - Payload: ");
+
+                return await Handle(() => inventoryServiceClient.GetAllTagsService(new GetAllTagsRequest { }, cancellationToken)).ConfigureAwait(false);
+            }
+            catch (Exception ex)
+            {
+                logger.LogError($"{nameof(GetAllTagsService)} - An Error Occurred- {ex.Message} - {ex.InnerException} - {ex.StackTrace} - with payload");
+                throw;
+            }
+        }
+
+        /// <summary>
+        /// Gets all the Tags by Tag identifiers.
+        /// </summary>
+        /// <param name="request">The request containing the list of Tag identifiers.</param>
+        /// <param name="cancellationToken">Cancellation token for the asynchronous operation.</param>
+        /// <returns>The <see cref="IActionResult"/> representing the result of the service call.</returns>
+        /// <response code="200">The Tags found.</response>
+        /// <response code="204">No content if no Tags are found.</response>
+        /// <response code="400">Bad request if the Tag identifiers are missing or invalid.</response>
+        /// <response code="401">Unauthorized if the user is not authenticated.</response>
+        /// <response code="500">Internal server error if an unexpected error occurs.</response>
+        [HttpPost("GetAllByList")]
+        [ProducesResponseType(typeof(IEnumerable<TagAdapter>), StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status204NoContent)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> GetAllTagsByListAsync([FromBody] GetAllTagsByListRequest request, CancellationToken cancellationToken)
+        {
+            try
+            {
+                logger.LogInformation($"{nameof(GetAllTagsByListAsync)} - Request received - Payload: {request}");
+
+                if (request == null || request.Tags == null || !request.Tags.Any())
+                {
+                    return BadRequest("Tag identifiers are required.");
+                }
+
+                return await Handle(() => inventoryServiceClient.GetAllTagsByListService(request, cancellationToken)).ConfigureAwait(false);
+
+            }
+            catch (Exception ex)
+            {
+                logger.LogError(ex, $"{nameof(GetAllTagsByListAsync)} - An error occurred - {ex.Message} - {ex.InnerException} - {ex.StackTrace} - with payload: {request}");
+                return StatusCode(StatusCodes.Status500InternalServerError, "Internal server error");
+            }
+        }
+
+
+        /// <summary>
+        /// Creates a new Tag.
+        /// </summary>
+        [HttpPost("Create")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> CreateTagService(CreateTagRequest newTag, CancellationToken cancellationToken)
+        {
+            try
+            {
+                logger.LogInformation($"{nameof(CreateTagService)} - Request received - Payload: {JsonSerializer.Serialize(newTag)}");
+
+                if (newTag == null) return BadRequest("Invalid Tag object");
+
+                if (string.IsNullOrEmpty(newTag.TagName)) return BadRequest("Invalid Tag name");
+
+                return await Handle(() => inventoryServiceClient.CreateTagService(newTag, cancellationToken)).ConfigureAwait(false);
+            }
+            catch (Exception ex)
+            {
+                logger.LogError($"{nameof(CreateTagService)} - An Error Occurred- {ex.Message} - {ex.InnerException} - {ex.StackTrace} - with payload {JsonSerializer.Serialize(newTag)}");
+                throw;
+            }
+        }
+
+        /// <summary>
+        /// Gets the Tag by identifier.
+        /// </summary>
+        [HttpPost("GetById")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> GetTagByIdService(GetTagRequest request, CancellationToken cancellationToken)
+        {
+            try
+            {
+                logger.LogInformation($"{nameof(GetTagByIdService)} - Request received - Payload: {JsonSerializer.Serialize(request)}");
+
+                if (string.IsNullOrEmpty(request.Id)) return BadRequest("Invalid Tag identifier");
+
+                return await Handle(() => inventoryServiceClient.GetTagByIdService(request, cancellationToken)).ConfigureAwait(false);
+            }
+            catch (Exception ex)
+            {
+                logger.LogError($"{nameof(GetTagByIdService)} - An Error Occurred- {ex.Message} - {ex.InnerException} - {ex.StackTrace} - with payload {JsonSerializer.Serialize(request)}");
+                throw;
+            }
+        }
+
+        /// <summary>
+        /// Updates a full Tag by identifier.
+        /// </summary>
+        [HttpPut("Update")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> UpdateTagService(UpdateTagRequest tag, CancellationToken cancellationToken)
+        {
+            try
+            {
+                logger.LogInformation($"{nameof(UpdateTagService)} - Request received - Payload: {JsonSerializer.Serialize(tag)}");
+
+                if (tag == null) return BadRequest("Invalid Tag object");
+
+                if (string.IsNullOrEmpty(tag.TagName)) return BadRequest("Invalid Tag name");
+
+                return await Handle(() => inventoryServiceClient.UpdateTagService(tag, cancellationToken)).ConfigureAwait(false);
+            }
+            catch (Exception ex)
+            {
+                logger.LogError($"{nameof(UpdateTagService)} - An Error Occurred- {ex.Message} - {ex.InnerException} - {ex.StackTrace} - with payload {JsonSerializer.Serialize(tag)}");
+                throw;
+            }
+        }
+
+        /// <summary>
+        /// Changes the status of the Tag.
+        /// </summary>
+        [HttpPatch]
+        [Route("ChangeStatus")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status204NoContent)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> ChangeTagStatusService([FromBody] ChangeTagStatusRequest request, CancellationToken cancellationToken)
+        {
+            try
+            {
+                logger.LogInformation($"{nameof(ChangeTagStatusService)} - Request received - Payload: {JsonSerializer.Serialize(request)}");
+
+                if (string.IsNullOrEmpty(request.Id)) { return BadRequest("Invalid Tag identifier"); }
+
+                return await Handle(() => inventoryServiceClient.ChangeTagStatusService(request, cancellationToken)).ConfigureAwait(false);
+            }
+            catch (Exception ex)
+            {
+                logger.LogError($"{nameof(ChangeTagStatusService)} - An Error Occurred- {ex.Message} - {ex.InnerException} - {ex.StackTrace} - with payload {JsonSerializer.Serialize(request)}");
+                throw;
+            }
+        }
+
+        /// <summary>
+        /// Adds a parentTag to the tag.
+        /// </summary>
+        [HttpPost]
+        [Route("AddParentTag")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status204NoContent)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> AddParentTagAsync([FromBody] AddParentTagToTagRequest request, CancellationToken cancellationToken)
+        {
+            try
+            {
+                logger.LogInformation($"{nameof(AddParentTagAsync)} - Request received - Payload: {JsonSerializer.Serialize(request)}");
+
+                if (string.IsNullOrEmpty(request.TagId)) { return BadRequest("Invalid tag identifier"); }
+                if (string.IsNullOrEmpty(request.ParentTagId)) { return BadRequest("Invalid parentTag identifier"); }
+
+                return await Handle(() => inventoryServiceClient.AddParentTagAsync(request, cancellationToken)).ConfigureAwait(false);
+            }
+            catch (Exception ex)
+            {
+                logger.LogError($"{nameof(AddParentTagAsync)} - An Error Occurred- {ex.Message} - {ex.InnerException} - {ex.StackTrace} - with payload {JsonSerializer.Serialize(request)}");
+                throw;
+            }
+        }
+
+        /// <summary>
+        /// Remove a parentTag to the tag.
+        /// </summary>
+        [HttpDelete]
+        [Route("RemoveParentTag")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status204NoContent)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> RemoveParentTagAsync([FromBody] RemoveParentTagFromTag request, CancellationToken cancellationToken)
+        {
+            try
+            {
+                logger.LogInformation($"{nameof(RemoveParentTagAsync)} - Request received - Payload: {JsonSerializer.Serialize(request)}");
+
+                if (string.IsNullOrEmpty(request.TagId)) { return BadRequest("Invalid tag identifier"); }
+                if (string.IsNullOrEmpty(request.ParentTagId)) { return BadRequest("Invalid parentTag identifier"); }
+
+                return await Handle(() => inventoryServiceClient.RemoveParentTagAsync(request, cancellationToken)).ConfigureAwait(false);
+            }
+            catch (Exception ex)
+            {
+                logger.LogError($"{nameof(RemoveParentTagAsync)} - An Error Occurred- {ex.Message} - {ex.InnerException} - {ex.StackTrace} - with payload {JsonSerializer.Serialize(request)}");
+                throw;
+            }
+        }
+
+        /// <summary>
+        /// Deletes a full Tag by identifier.
+        /// </summary>
+        [HttpDelete("Delete")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> DeleteTagService(DeleteTagRequest request, CancellationToken cancellationToken)
+        {
+            try
+            {
+                logger.LogInformation($"{nameof(DeleteTagService)} - Request received - Payload: {JsonSerializer.Serialize(request)}");
+
+                if (request == null) return BadRequest("Invalid Tag object");
+
+                if (string.IsNullOrEmpty(request.Id)) return BadRequest("Invalid Tag identifier");
+
+                return await Handle(() => inventoryServiceClient.DeleteTagService(request, cancellationToken)).ConfigureAwait(false);
+            }
+            catch (Exception ex)
+            {
+                logger.LogError($"{nameof(DeleteTagService)} - An Error Occurred- {ex.Message} - {ex.InnerException} - {ex.StackTrace} - with payload {JsonSerializer.Serialize(request)}");
+                throw;
+            }
+        }
+    }
+}

Core.Inventory.BFF.API/Controllers/TagOverrideController.cs

@@ -0,0 +1,235 @@
+using Asp.Versioning;
+using Core.Adapters.Lib;
+using Core.Inventory.External.Clients.Inventory;
+using Core.Inventory.External.Clients.Inventory.Requests.TagOverride;
+using Core.Inventory.External.Clients.Inventory.Requests.TagType;
+using Lib.Architecture.BuildingBlocks;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using System.Text.Json;
+
+namespace Core.Inventory.BFF.API.Controllers
+{
+    /// <summary>
+    /// Handles all requests for TagOverride authentication.
+    /// </summary>
+    [ApiVersion("1.0")]
+    [Route("api/v{version:apiVersion}/[controller]")]
+    [Consumes("application/json")]
+    [Produces("application/json")]
+    [ApiController]
+    [AllowAnonymous]
+    public class TagOverrideController(IInventoryServiceClient inventoryServiceClient, ILogger<TagOverrideController> logger) : BaseController(logger)
+    {
+        /// <summary>
+        /// Gets all the TagOverrides.
+        /// </summary>
+        [HttpGet("GetAll")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> GetAllTagOverridesService(CancellationToken cancellationToken)
+        {
+            try
+            {
+                logger.LogInformation($"{nameof(GetAllTagOverridesService)} - Request received - Payload: ");
+
+                return await Handle(() => inventoryServiceClient.GetAllTagOverridesService(new GetAllTagOverridesRequest { }, cancellationToken)).ConfigureAwait(false);
+            }
+            catch (Exception ex)
+            {
+                logger.LogError($"{nameof(GetAllTagOverridesService)} - An Error Occurred- {ex.Message} - {ex.InnerException} - {ex.StackTrace} - with payload");
+                throw;
+            }
+        }
+
+        /// <summary>
+        /// Gets all the TagOverrides by TagOverride identifiers.
+        /// </summary>
+        /// <param name="request">The request containing the list of TagOverride identifiers.</param>
+        /// <param name="cancellationToken">Cancellation token for the asynchronous operation.</param>
+        /// <returns>The <see cref="IActionResult"/> representing the result of the service call.</returns>
+        /// <response code="200">The TagOverrides found.</response>
+        /// <response code="204">No content if no TagOverrides are found.</response>
+        /// <response code="400">Bad request if the TagOverride identifiers are missing or invalid.</response>
+        /// <response code="401">Unauthorized if the user is not authenticated.</response>
+        /// <response code="500">Internal server error if an unexpected error occurs.</response>
+        [HttpPost("GetAllByList")]
+        [ProducesResponseType(typeof(IEnumerable<TagOverrideAdapter>), StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status204NoContent)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> GetAllTagOverridesByListAsync([FromBody] GetAllTagOverridesByListRequest request, CancellationToken cancellationToken)
+        {
+            try
+            {
+                logger.LogInformation($"{nameof(GetAllTagOverridesByListAsync)} - Request received - Payload: {request}");
+
+                if (request == null || request.TagOverrides == null || !request.TagOverrides.Any())
+                {
+                    return BadRequest("TagOverride identifiers are required.");
+                }
+
+                return await Handle(() => inventoryServiceClient.GetAllTagOverridesByListService(request, cancellationToken)).ConfigureAwait(false);
+
+            }
+            catch (Exception ex)
+            {
+                logger.LogError(ex, $"{nameof(GetAllTagOverridesByListAsync)} - An error occurred - {ex.Message} - {ex.InnerException} - {ex.StackTrace} - with payload: {request}");
+                return StatusCode(StatusCodes.Status500InternalServerError, "Internal server error");
+            }
+        }
+
+
+        /// <summary>
+        /// Creates a new TagOverride.
+        /// </summary>
+        [HttpPost("Create")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> CreateTagOverrideService(CreateTagOverrideRequest newTagOverride, CancellationToken cancellationToken)
+        {
+            try
+            {
+                logger.LogInformation($"{nameof(CreateTagOverrideService)} - Request received - Payload: {JsonSerializer.Serialize(newTagOverride)}");
+
+                if (newTagOverride == null) return BadRequest("Invalid TagOverride object");
+
+                if (string.IsNullOrEmpty(newTagOverride.BaseTagId)) return BadRequest("Invalid TagOverride BaseTagId");
+
+                if (string.IsNullOrEmpty(newTagOverride.OverrideTagId)) return BadRequest("Invalid TagOverride OverrideTagId");
+
+                return await Handle(() => inventoryServiceClient.CreateTagOverrideService(newTagOverride, cancellationToken)).ConfigureAwait(false);
+            }
+            catch (Exception ex)
+            {
+                logger.LogError($"{nameof(CreateTagOverrideService)} - An Error Occurred- {ex.Message} - {ex.InnerException} - {ex.StackTrace} - with payload {JsonSerializer.Serialize(newTagOverride)}");
+                throw;
+            }
+        }
+
+        /// <summary>
+        /// Gets the TagOverride by identifier.
+        /// </summary>
+        [HttpPost("GetById")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> GetTagOverrideByIdService(GetTagOverrideRequest request, CancellationToken cancellationToken)
+        {
+            try
+            {
+                logger.LogInformation($"{nameof(GetTagOverrideByIdService)} - Request received - Payload: {JsonSerializer.Serialize(request)}");
+
+                if (string.IsNullOrEmpty(request.Id)) return BadRequest("Invalid TagOverride identifier");
+
+                return await Handle(() => inventoryServiceClient.GetTagOverrideByIdService(request, cancellationToken)).ConfigureAwait(false);
+            }
+            catch (Exception ex)
+            {
+                logger.LogError($"{nameof(GetTagOverrideByIdService)} - An Error Occurred- {ex.Message} - {ex.InnerException} - {ex.StackTrace} - with payload {JsonSerializer.Serialize(request)}");
+                throw;
+            }
+        }
+
+        /// <summary>
+        /// Updates a full TagOverride by identifier.
+        /// </summary>
+        [HttpPut("Update")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> UpdateTagOverrideService(UpdateTagOverrideRequest tagOverride, CancellationToken cancellationToken)
+        {
+            try
+            {
+                logger.LogInformation($"{nameof(UpdateTagOverrideService)} - Request received - Payload: {JsonSerializer.Serialize(tagOverride)}");
+
+                if (tagOverride == null) return BadRequest("Invalid TagOverride object");
+
+                if (string.IsNullOrEmpty(tagOverride.BaseTagId)) return BadRequest("Invalid TagOverride BaseTagId");
+
+                if (string.IsNullOrEmpty(tagOverride.OverrideTagId)) return BadRequest("Invalid TagOverride OverrideTagId");
+
+                return await Handle(() => inventoryServiceClient.UpdateTagOverrideService(tagOverride, cancellationToken)).ConfigureAwait(false);
+            }
+            catch (Exception ex)
+            {
+                logger.LogError($"{nameof(UpdateTagOverrideService)} - An Error Occurred- {ex.Message} - {ex.InnerException} - {ex.StackTrace} - with payload {JsonSerializer.Serialize(tagOverride)}");
+                throw;
+            }
+        }
+
+        /// <summary>
+        /// Changes the status of the TagOverride.
+        /// </summary>
+        [HttpPatch]
+        [Route("ChangeStatus")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status204NoContent)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> ChangeTagOverrideStatusService([FromBody] ChangeTagOverrideStatusRequest request, CancellationToken cancellationToken)
+        {
+            try
+            {
+                logger.LogInformation($"{nameof(ChangeTagOverrideStatusService)} - Request received - Payload: {JsonSerializer.Serialize(request)}");
+
+                if (string.IsNullOrEmpty(request.Id)) { return BadRequest("Invalid TagOverride identifier"); }
+
+                return await Handle(() => inventoryServiceClient.ChangeTagOverrideStatusService(request, cancellationToken)).ConfigureAwait(false);
+            }
+            catch (Exception ex)
+            {
+                logger.LogError($"{nameof(ChangeTagOverrideStatusService)} - An Error Occurred- {ex.Message} - {ex.InnerException} - {ex.StackTrace} - with payload {JsonSerializer.Serialize(request)}");
+                throw;
+            }
+        }
+
+        /// <summary>
+        /// Deletes a full TagOverride by identifier.
+        /// </summary>
+        [HttpDelete("Delete")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> DeleteTagOverrideService(DeleteTagOverrideRequest request, CancellationToken cancellationToken)
+        {
+            try
+            {
+                logger.LogInformation($"{nameof(DeleteTagOverrideService)} - Request received - Payload: {JsonSerializer.Serialize(request)}");
+
+                if (request == null) return BadRequest("Invalid TagOverride object");
+
+                if (string.IsNullOrEmpty(request.Id)) return BadRequest("Invalid TagOverride identifier");
+
+                return await Handle(() => inventoryServiceClient.DeleteTagOverrideService(request, cancellationToken)).ConfigureAwait(false);
+            }
+            catch (Exception ex)
+            {
+                logger.LogError($"{nameof(DeleteTagOverrideService)} - An Error Occurred- {ex.Message} - {ex.InnerException} - {ex.StackTrace} - with payload {JsonSerializer.Serialize(request)}");
+                throw;
+            }
+        }
+    }
+}

Core.Inventory.BFF.API/Controllers/TagTypeController.cs

@@ -150,21 +150,21 @@ namespace Core.Inventory.BFF.API.Controllers
         [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
         [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
         [ProducesResponseType(StatusCodes.Status500InternalServerError)]
-        public async Task<IActionResult> UpdateTagTypeService(UpdateTagTypeRequest newTagType, CancellationToken cancellationToken)
+        public async Task<IActionResult> UpdateTagTypeService(UpdateTagTypeRequest tagType, CancellationToken cancellationToken)
         {
             try
             {
-                logger.LogInformation($"{nameof(UpdateTagTypeService)} - Request received - Payload: {JsonSerializer.Serialize(newTagType)}");
+                logger.LogInformation($"{nameof(UpdateTagTypeService)} - Request received - Payload: {JsonSerializer.Serialize(tagType)}");
 
-                if (newTagType == null) return BadRequest("Invalid TagType object");
+                if (tagType == null) return BadRequest("Invalid TagType object");
 
-                if (string.IsNullOrEmpty(newTagType.TypeName)) return BadRequest("Invalid TagType name");
+                if (string.IsNullOrEmpty(tagType.TypeName)) return BadRequest("Invalid TagType name");
 
-                return await Handle(() => inventoryServiceClient.UpdateTagTypeService(newTagType, cancellationToken)).ConfigureAwait(false);
+                return await Handle(() => inventoryServiceClient.UpdateTagTypeService(tagType, cancellationToken)).ConfigureAwait(false);
             }
             catch (Exception ex)
             {
-                logger.LogError($"{nameof(UpdateTagTypeService)} - An Error Occurred- {ex.Message} - {ex.InnerException} - {ex.StackTrace} - with payload {JsonSerializer.Serialize(newTagType)}");
+                logger.LogError($"{nameof(UpdateTagTypeService)} - An Error Occurred- {ex.Message} - {ex.InnerException} - {ex.StackTrace} - with payload {JsonSerializer.Serialize(tagType)}");
                 throw;
             }
         }
@@ -198,6 +198,33 @@ namespace Core.Inventory.BFF.API.Controllers
             }
         }
 
+        /// <summary>
+        /// Deletes a full TagType by identifier.
+        /// </summary>
+        [HttpDelete("Delete")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> DeleteTagTypeService(DeleteTagTypeRequest request, CancellationToken cancellationToken)
+        {
+            try
+            {
+                logger.LogInformation($"{nameof(DeleteTagTypeService)} - Request received - Payload: {JsonSerializer.Serialize(request)}");
 
+                if (request == null) return BadRequest("Invalid TagType object");
+
+                if (string.IsNullOrEmpty(request.Id)) return BadRequest("Invalid TagType identifier");
+
+                return await Handle(() => inventoryServiceClient.DeleteTagTypeService(request, cancellationToken)).ConfigureAwait(false);
+            }
+            catch (Exception ex)
+            {
+                logger.LogError($"{nameof(DeleteTagTypeService)} - An Error Occurred- {ex.Message} - {ex.InnerException} - {ex.StackTrace} - with payload {JsonSerializer.Serialize(request)}");
+                throw;
+            }
+        }
     }
 }

Core.Inventory.BFF.API/Core.Inventory.BFF.API.csproj

@@ -8,7 +8,7 @@
 
   <ItemGroup>
     <PackageReference Include="Asp.Versioning.Mvc.ApiExplorer" Version="8.1.0" />
-    <PackageReference Include="Core.Blueprint.Logging" Version="1.0.1" />
+    <PackageReference Include="Core.Blueprint.Logging" Version="1.0.0" />
     <PackageReference Include="OpenTelemetry" Version="1.12.0" />
     <PackageReference Include="OpenTelemetry.Exporter.Console" Version="1.12.0" />
     <PackageReference Include="Swashbuckle.AspNetCore" Version="8.1.4" />

Core.Inventory.External/Clients/Inventory/IInventoryServiceClient.cs

@@ -1,5 +1,9 @@
 using Core.Adapters.Lib;
+using Core.Adapters.Lib.Inventory;
 using Core.Inventory.External.Clients.Inventory.Requests.Base;
+using Core.Inventory.External.Clients.Inventory.Requests.Product;
+using Core.Inventory.External.Clients.Inventory.Requests.Tag;
+using Core.Inventory.External.Clients.Inventory.Requests.TagOverride;
 using Core.Inventory.External.Clients.Inventory.Requests.TagType;
 using Core.Inventory.External.Clients.Inventory.Requests.Variant;
 using Refit;
@@ -72,6 +76,96 @@ namespace Core.Inventory.External.Clients.Inventory
         [Patch("/api/v1/TagType/ChangeStatus")]
         Task<ApiResponse<TagTypeAdapter>> ChangeTagTypeStatusService([Header("TrackingId")][Body] ChangeTagTypeStatusRequest request, CancellationToken cancellationToken = default);
 
+        [Delete("/api/v1/TagType/Delete")]
+        Task<ApiResponse<TagTypeAdapter>> DeleteTagTypeService([Header("TrackingId")][Body] DeleteTagTypeRequest request, CancellationToken cancellationToken = default);
+
+        #endregion
+
+        #region Tag
+
+        [Post("/api/v1/Tag/Create")]
+        Task<ApiResponse<TagAdapter>> CreateTagService([Header("TrackingId")][Body] CreateTagRequest request, CancellationToken cancellationToken = default);
+
+        [Post("/api/v1/Tag/GetById")]
+        Task<ApiResponse<TagAdapter>> GetTagByIdService([Header("TrackingId")][Body] GetTagRequest request, CancellationToken cancellationToken = default);
+
+        [Get("/api/v1/Tag/GetAll")]
+        Task<ApiResponse<IEnumerable<TagAdapter>>> GetAllTagsService([Header("TrackingId")][Body] GetAllTagsRequest request, CancellationToken cancellationToken = default);
+
+        [Post("/api/v1/Tag/GetTagList")]
+        Task<ApiResponse<IEnumerable<TagAdapter>>> GetAllTagsByListService([Header("TrackingId")][Body] GetAllTagsByListRequest request, CancellationToken cancellationToken = default);
+
+        [Put("/api/v1/Tag/Update")]
+        Task<ApiResponse<TagAdapter>> UpdateTagService([Header("TrackingId")][Body] UpdateTagRequest request, CancellationToken cancellationToken = default);
+
+        [Patch("/api/v1/Tag/ChangeStatus")]
+        Task<ApiResponse<TagAdapter>> ChangeTagStatusService([Header("TrackingId")][Body] ChangeTagStatusRequest request, CancellationToken cancellationToken = default);
+
+        [Post("/api/v1/Tag/AddParentTag")]
+        Task<ApiResponse<TagAdapter>> AddParentTagAsync([Header("TrackingId")][Body] AddParentTagToTagRequest request, CancellationToken cancellationToken = default);
+
+        [Delete("/api/v1/Tag/RemoveParentTag")]
+        Task<ApiResponse<TagAdapter>> RemoveParentTagAsync([Header("TrackingId")][Body] RemoveParentTagFromTag request, CancellationToken cancellationToken = default);
+
+        [Delete("/api/v1/Tag/Delete")]
+        Task<ApiResponse<TagAdapter>> DeleteTagService([Header("TrackingId")][Body] DeleteTagRequest request, CancellationToken cancellationToken = default);
+
+        #endregion
+
+        #region TagOverride
+
+        [Post("/api/v1/TagOverride/Create")]
+        Task<ApiResponse<TagOverrideAdapter>> CreateTagOverrideService([Header("TrackingId")][Body] CreateTagOverrideRequest request, CancellationToken cancellationToken = default);
+
+        [Post("/api/v1/TagOverride/GetById")]
+        Task<ApiResponse<TagOverrideAdapter>> GetTagOverrideByIdService([Header("TrackingId")][Body] GetTagOverrideRequest request, CancellationToken cancellationToken = default);
+
+        [Get("/api/v1/TagOverride/GetAll")]
+        Task<ApiResponse<IEnumerable<TagOverrideAdapter>>> GetAllTagOverridesService([Header("TrackingId")][Body] GetAllTagOverridesRequest request, CancellationToken cancellationToken = default);
+
+        [Post("/api/v1/TagOverride/GetTagOverrideList")]
+        Task<ApiResponse<IEnumerable<TagOverrideAdapter>>> GetAllTagOverridesByListService([Header("TrackingId")][Body] GetAllTagOverridesByListRequest request, CancellationToken cancellationToken = default);
+
+        [Put("/api/v1/TagOverride/Update")]
+        Task<ApiResponse<TagOverrideAdapter>> UpdateTagOverrideService([Header("TrackingId")][Body] UpdateTagOverrideRequest request, CancellationToken cancellationToken = default);
+
+        [Patch("/api/v1/TagOverride/ChangeStatus")]
+        Task<ApiResponse<TagOverrideAdapter>> ChangeTagOverrideStatusService([Header("TrackingId")][Body] ChangeTagOverrideStatusRequest request, CancellationToken cancellationToken = default);
+
+        [Delete("/api/v1/TagOverride/Delete")]
+        Task<ApiResponse<TagOverrideAdapter>> DeleteTagOverrideService([Header("TrackingId")][Body] DeleteTagOverrideRequest request, CancellationToken cancellationToken = default);
+
+        #endregion
+
+        #region Product
+
+        [Post("/api/v1/Product/Create")]
+        Task<ApiResponse<ProductAdapter>> CreateProductService([Header("TrackingId")][Body] CreateProductRequest request, CancellationToken cancellationToken = default);
+
+        [Post("/api/v1/Product/GetById")]
+        Task<ApiResponse<ProductAdapter>> GetProductByIdService([Header("TrackingId")][Body] GetProductRequest request, CancellationToken cancellationToken = default);
+
+        [Get("/api/v1/Product/GetAll")]
+        Task<ApiResponse<IEnumerable<ProductAdapter>>> GetAllProductsService([Header("TrackingId")][Body] GetAllProductsRequest request, CancellationToken cancellationToken = default);
+
+        [Post("/api/v1/Product/GetProductList")]
+        Task<ApiResponse<IEnumerable<ProductAdapter>>> GetAllProductsByListService([Header("TrackingId")][Body] GetAllProductsByListRequest request, CancellationToken cancellationToken = default);
+
+        [Put("/api/v1/Product/Update")]
+        Task<ApiResponse<ProductAdapter>> UpdateProductService([Header("TrackingId")][Body] UpdateProductRequest request, CancellationToken cancellationToken = default);
+
+        [Patch("/api/v1/Product/ChangeStatus")]
+        Task<ApiResponse<ProductAdapter>> ChangeProductStatusService([Header("TrackingId")][Body] ChangeProductStatusRequest request, CancellationToken cancellationToken = default);
+
+        [Post("/api/v1/Product/AddTag")]
+        Task<ApiResponse<ProductAdapter>> AddTagToProductAsync([Header("TrackingId")][Body] AddTagToProductRequest request, CancellationToken cancellationToken = default);
+
+        [Delete("/api/v1/Product/RemoveTag")]
+        Task<ApiResponse<ProductAdapter>> RemoveTagFromProductAsync([Header("TrackingId")][Body] RemoveTagFromProductRequest request, CancellationToken cancellationToken = default);
+
+        [Delete("/api/v1/Product/Delete")]
+        Task<ApiResponse<ProductAdapter>> DeleteProductService([Header("TrackingId")][Body] DeleteProductRequest request, CancellationToken cancellationToken = default);
+
         #endregion
     }
 }

Core.Inventory.External/Clients/Inventory/Requests/Product/AddTagToProductRequest.cs

@@ -0,0 +1,8 @@
+namespace Core.Inventory.External.Clients.Inventory.Requests.Product
+{
+    public class AddTagToProductRequest
+    {
+        public string ProductId { get; set; } = null!;
+        public string TagId { get; set; } = null!;
+    }
+} 

Core.Inventory.External/Clients/Inventory/Requests/Product/ChangeProductStatusRequest.cs

@@ -0,0 +1,10 @@
+using Core.Adapters.Lib.Inventory;
+
+namespace Core.Inventory.External.Clients.Inventory.Requests.Product
+{
+    public class ChangeProductStatusRequest
+    {
+        public string Id { get; set; } = null!;
+        public ProductStatus NewStatus { get; set; }
+    }
+} 

Core.Inventory.External/Clients/Inventory/Requests/Product/CreateProductRequest.cs

@@ -0,0 +1,11 @@
+namespace Core.Inventory.External.Clients.Inventory.Requests.Product
+{
+    public class CreateProductRequest
+    {
+        public string TenantId { get; set; } = null!;
+        public string ProductName { get; set; } = null!;
+        public string Description { get; set; } = null!;
+        public string ProductStatus { get; set; } = null!;
+        public List<string> TagIds { get; set; } = new List<string>();
+    }
+} 

Core.Inventory.External/Clients/Inventory/Requests/Product/DeleteProductRequest.cs

@@ -0,0 +1,14 @@
+using Lib.Architecture.BuildingBlocks;
+
+namespace Core.Inventory.External.Clients.Inventory.Requests.Product
+{
+    public class DeleteProductRequest : Notificator, ICommand
+    {
+        public string Id { get; set; } = null!;
+
+        public bool Validate()
+        {
+            return Id != null;
+        }
+    }
+} 

Core.Inventory.External/Clients/Inventory/Requests/Product/GetAllProductsByListRequest.cs

@@ -0,0 +1,7 @@
+namespace Core.Inventory.External.Clients.Inventory.Requests.Product
+{
+    public class GetAllProductsByListRequest
+    {
+        public string[] Products { get; set; } = null!;
+    }
+} 

Core.Inventory.External/Clients/Inventory/Requests/Product/GetAllProductsRequest.cs

@@ -0,0 +1,6 @@
+namespace Core.Inventory.External.Clients.Inventory.Requests.Product
+{
+    public class GetAllProductsRequest
+    {
+    }
+} 

Core.Inventory.External/Clients/Inventory/Requests/Product/GetProductRequest.cs

@@ -0,0 +1,7 @@
+namespace Core.Inventory.External.Clients.Inventory.Requests.Product
+{
+    public class GetProductRequest
+    {
+        public string Id { get; set; }
+    }
+} 

Core.Inventory.External/Clients/Inventory/Requests/Product/RemoveTagFromProductRequest.cs

@@ -0,0 +1,8 @@
+namespace Core.Inventory.External.Clients.Inventory.Requests.Product
+{
+    public class RemoveTagFromProductRequest
+    {
+        public string ProductId { get; set; } = null!;
+        public string TagId { get; set; } = null!;
+    }
+} 

Core.Inventory.External/Clients/Inventory/Requests/Product/UpdateProductRequest.cs

@@ -0,0 +1,14 @@
+using Core.Adapters.Lib.Inventory;
+
+namespace Core.Inventory.External.Clients.Inventory.Requests.Product
+{
+    public class UpdateProductRequest
+    {
+        public string Id { get; set; } = null!;
+        public string TenantId { get; set; } = null!;
+        public string ProductName { get; set; } = null!;
+        public string Description { get; set; } = null!;
+        public string ProductStatus { get; set; } = null!;
+        public List<string> TagIds { get; set; } = new List<string>();
+    }
+} 

Core.Inventory.External/Clients/Inventory/Requests/Tag/AddParentTagToTagRequest.cs

@@ -0,0 +1,8 @@
+namespace Core.Inventory.External.Clients.Inventory.Requests.Tag
+{
+    public class AddParentTagToTagRequest
+    {
+        public string TagId { get; set; }
+        public string ParentTagId { get; set; }
+    }
+}

Core.Inventory.External/Clients/Inventory/Requests/Tag/ChangeTagStatusRequest.cs

@@ -0,0 +1,10 @@
+using Core.Blueprint.Mongo;
+
+namespace Core.Inventory.External.Clients.Inventory.Requests.Tag
+{
+    public class ChangeTagStatusRequest
+    {
+        public string Id { get; set; }
+        public StatusEnum Status { get; set; }
+    }
+}

Core.Inventory.External/Clients/Inventory/Requests/Tag/CreateTagRequest.cs

@@ -0,0 +1,13 @@
+namespace Core.Inventory.External.Clients.Inventory.Requests.Tag
+{
+    public class CreateTagRequest
+    {
+        public string TenantId { get; set; } = null!;
+        public string TagName { get; set; } = null!;
+        public string TypeId { get; set; } = null!;
+        public string[] ParentTagId { get; set; } = null!;
+        public string Slug { get; set; } = null!;
+        public int DisplayOrder { get; set; }
+        public string Icon { get; set; } = null!;
+    }
+}

Core.Inventory.External/Clients/Inventory/Requests/Tag/DeleteTagRequest.cs

@@ -0,0 +1,14 @@
+using Lib.Architecture.BuildingBlocks;
+
+namespace Core.Inventory.External.Clients.Inventory.Requests.Tag
+{
+    public class DeleteTagRequest : Notificator, ICommand
+    {
+        public string Id { get; set; } = null!;
+
+        public bool Validate()
+        {
+            return Id != null;
+        }
+    }
+}

Core.Inventory.External/Clients/Inventory/Requests/Tag/GetAllTagByListRequest.cs

@@ -0,0 +1,7 @@
+namespace Core.Inventory.External.Clients.Inventory.Requests.Tag
+{
+    public class GetAllTagsByListRequest
+    {
+        public string[] Tags { get; set; }
+    }
+}

Core.Inventory.External/Clients/Inventory/Requests/Tag/GetAllTagsRequest.cs

@@ -0,0 +1,6 @@
+namespace Core.Inventory.External.Clients.Inventory.Requests.Tag
+{
+    public class GetAllTagsRequest
+    {
+    }
+}

Core.Inventory.External/Clients/Inventory/Requests/Tag/GetTagRequest.cs

@@ -0,0 +1,7 @@
+namespace Core.Inventory.External.Clients.Inventory.Requests.Tag
+{
+    public class GetTagRequest
+    {
+        public string Id { get; set; }
+    }
+}

Core.Inventory.External/Clients/Inventory/Requests/Tag/RemoveParentTagFromTag.cs

@@ -0,0 +1,8 @@
+namespace Core.Inventory.External.Clients.Inventory.Requests.Tag
+{
+    public class RemoveParentTagFromTag
+    {
+        public string TagId { get; set; }
+        public string ParentTagId { get; set; }
+    }
+}

Core.Inventory.External/Clients/Inventory/Requests/Tag/UpdateTagRequest.cs

@@ -0,0 +1,17 @@
+using Core.Blueprint.Mongo;
+
+namespace Core.Inventory.External.Clients.Inventory.Requests.Tag
+{
+    public class UpdateTagRequest
+    {
+        public string Id { get; set; } = null!;
+        public string TenantId { get; set; } = null!;
+        public string TagName { get; set; } = null!;
+        public string TypeId { get; set; } = null!;
+        public string[] ParentTagId { get; set; } = null!;
+        public string Slug { get; set; } = null!;
+        public int DisplayOrder { get; set; }
+        public string Icon { get; set; } = null!;
+        public StatusEnum Status { get; set; }
+    }
+}

Core.Inventory.External/Clients/Inventory/Requests/TagOverride/ChangeTagOverrideStatusRequest.cs

@@ -0,0 +1,10 @@
+using Core.Blueprint.Mongo;
+
+namespace Core.Inventory.External.Clients.Inventory.Requests.TagOverride
+{
+    public class ChangeTagOverrideStatusRequest
+    {
+        public string Id { get; set; }
+        public StatusEnum Status { get; set; }
+    }
+}

Core.Inventory.External/Clients/Inventory/Requests/TagOverride/CreateTagOverrideRequest.cs

@@ -0,0 +1,9 @@
+namespace Core.Inventory.External.Clients.Inventory.Requests.TagOverride
+{
+    public class CreateTagOverrideRequest
+    {
+        public string TenantId { get; set; } = null!;
+        public string BaseTagId { get; set; } = null!;
+        public string OverrideTagId { get; set; } = null!;
+    }
+}

Core.Inventory.External/Clients/Inventory/Requests/TagOverride/DeleteTagOverrideRequest.cs

@@ -0,0 +1,14 @@
+using Lib.Architecture.BuildingBlocks;
+
+namespace Core.Inventory.External.Clients.Inventory.Requests.TagOverride
+{
+    public class DeleteTagOverrideRequest : Notificator, ICommand
+    {
+        public string Id { get; set; } = null!;
+
+        public bool Validate()
+        {
+            return Id != null;
+        }
+    }
+}

Core.Inventory.External/Clients/Inventory/Requests/TagOverride/GetAllTagOverridesByListRequest.cs

@@ -0,0 +1,7 @@
+namespace Core.Inventory.External.Clients.Inventory.Requests.TagOverride
+{
+    public class GetAllTagOverridesByListRequest
+    {
+        public string[] TagOverrides { get; set; }
+    }
+}

Core.Inventory.External/Clients/Inventory/Requests/TagOverride/GetAllTagOverridesRequest.cs

@@ -0,0 +1,6 @@
+namespace Core.Inventory.External.Clients.Inventory.Requests.TagOverride
+{
+    public class GetAllTagOverridesRequest
+    {
+    }
+}

Core.Inventory.External/Clients/Inventory/Requests/TagOverride/GetTagOverrideRequest.cs

@@ -0,0 +1,7 @@
+namespace Core.Inventory.External.Clients.Inventory.Requests.TagOverride
+{
+    public class GetTagOverrideRequest
+    {
+        public string Id { get; set; }
+    }
+}

Core.Inventory.External/Clients/Inventory/Requests/TagOverride/UpdateTagOverrideRequest.cs

@@ -0,0 +1,13 @@
+using Core.Blueprint.Mongo;
+
+namespace Core.Inventory.External.Clients.Inventory.Requests.TagOverride
+{
+    public class UpdateTagOverrideRequest
+    {
+        public string Id { get; set; } = null!;
+        public string TenantId { get; set; } = null!;
+        public string BaseTagId { get; set; } = null!;
+        public string OverrideTagId { get; set; } = null!;
+        public StatusEnum Status { get; set; }
+    }
+}

Core.Inventory.External/Clients/Inventory/Requests/TagType/DeleteTagTypeRequest.cs

@@ -0,0 +1,14 @@
+using Lib.Architecture.BuildingBlocks;
+
+namespace Core.Inventory.External.Clients.Inventory.Requests.TagType
+{
+    public class DeleteTagTypeRequest : Notificator, ICommand
+    {
+        public string Id { get; set; } = null!;
+
+        public bool Validate()
+        {
+            return Id != null;
+        }
+    }
+}

Core.Inventory.External/Core.Inventory.External.csproj

@@ -7,8 +7,8 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Adapters.Lib" Version="1.0.9" />
-    <PackageReference Include="BuildingBlocks.Library" Version="1.0.0" />
+    <PackageReference Include="Core.Adapters.Lib" Version="1.0.0" />
+    <PackageReference Include="Lib.Architecture.BuildingBlocks" Version="1.0.0" />
     <PackageReference Include="Refit" Version="8.0.0" />
   </ItemGroup>
 

Dockerfile

@@ -0,0 +1,38 @@
+# ===== Build stage =====
+FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
+WORKDIR /src
+
+# Usar tu feed (BaGet) + nuget.org
+COPY nuget.config ./
+
+# Copiar SOLO los .csproj primero (mejor caché)
+COPY Core.Inventory.BFF.API/Core.Inventory.BFF.API.csproj Core.Inventory.BFF.API/
+COPY Core.Inventory.External/Core.Inventory.External.csproj Core.Inventory.External/
+
+# Restore con tu nuget.config
+RUN dotnet restore Core.Inventory.BFF.API/Core.Inventory.BFF.API.csproj --configfile ./nuget.config
+
+# Copiar el resto del código
+COPY . .
+
+# Publicar artefactos
+ARG BUILD_CONFIGURATION=Release
+RUN dotnet publish Core.Inventory.BFF.API/Core.Inventory.BFF.API.csproj \
+    -c $BUILD_CONFIGURATION -o /app/out /p:UseAppHost=false
+
+# ===== Runtime stage =====
+FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS runtime
+WORKDIR /app
+COPY --from=build /app/out .
+
+# Config base
+ENV ASPNETCORE_URLS=http://+:8080 \
+    ASPNETCORE_ENVIRONMENT=Production
+
+EXPOSE 8080
+
+# (Opcional) Healthcheck si tienes endpoint /health
+# HEALTHCHECK --interval=30s --timeout=5s --retries=5 \
+#   CMD wget -qO- http://localhost:8080/health || exit 1
+
+ENTRYPOINT ["dotnet", "Core.Inventory.BFF.API.dll"]

nuget.config

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+  <packageSources>
+    <!-- Tu BaGet primero -->
+    <add key="BaGet" value="https://nuget.dream-views.com/v3/index.json" protocolVersion="3" />
+    <!-- NuGet oficial como fallback (si quieres) -->
+    <add key="nuget.org" value="https://api.nuget.org/v3/index.json" protocolVersion="3" />
+  </packageSources>
+</configuration>