AgileWebs/Core.Inventory.BFF
6
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

First version of BFF

Browse Source
This commit is contained in:
Ignacio Gomez
2025-06-23 01:55:17 -06:00
parent e8a8af0228
commit 3e8100e1c5
28 changed files with 865 additions and 61 deletions
Download Patch File Download Diff File Expand all files Collapse all files

49
Core.Inventory.BFF.API/Controllers/BaseController.cs Normal file
View File

@@ -0,0 +1,49 @@

using Lib.Architecture.BuildingBlocks;
using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json;
using Refit;
namespace Core.Inventory.BFF.API.Controllers
{
[Route("api/[controller]")]
[ApiController]
public class BaseController(ILogger<BaseController> logger) : ControllerBase
{
private readonly ILogger<BaseController> _logger = logger;
protected Guid TrackingId => (Guid)(HttpContext.Items["TrackingId"] ?? Guid.NewGuid());
protected async Task<IActionResult> Handle<T>(Func<Task<ApiResponse<T>>> apiCall) where T : class
{
var response = await apiCall().ConfigureAwait(false);
_logger.LogInformation($"{TrackingId} - {response.RequestMessage?.Method} {response.RequestMessage?.RequestUri} - Status: {response.StatusCode}");
return FromAPIResponse(response);
}
private IActionResult FromAPIResponse<T>(ApiResponse<T> response) where T : class
{
if (response.IsSuccessful)
return StatusCode((int)response.StatusCode, response.Content);
else
{
dynamic errorContent = string.Empty;
try
{
errorContent = JsonConvert.DeserializeObject<string>(response.Error?.Content ?? string.Empty) ?? string.Empty;
}
catch (Exception)
{
errorContent = JsonConvert.DeserializeObject<HttpError>(response.Error?.Content);
if (errorContent?.Error?.ErrorCode is null && errorContent?.Error?.Message is null && errorContent?.Error?.Target is null)
errorContent = JsonConvert.DeserializeObject<GenericErrorResponse>(response.Error?.Content);
}
return StatusCode((int)response.StatusCode, errorContent);
}
}
}
}

142
Core.Inventory.BFF.API/Controllers/FurnitureBaseController.cs Normal file
View File

@@ -0,0 +1,142 @@
using Asp.Versioning;
using Core.Adapters.Lib;
using Core.Inventory.External.Clients.Inventory;
using Core.Inventory.External.Clients.Inventory.Requests.Base;
using Microsoft.AspNetCore.Mvc;
using System.Text.Json;
namespace Core.Inventory.BFF.API.Controllers
{
/// <summary>
/// Handles all requests for furniture base operations.
/// </summary>
[ApiVersion("1.0")]
[Route("api/v{version:apiVersion}/[controller]")]
[ApiController]
[Consumes("application/json")]
[Produces("application/json")]
public class FurnitureBaseController(IInventoryServiceClient inventoryClient, ILogger<FurnitureBaseController> logger) : BaseController(logger)
{
/// <summary>
/// Gets all furniture base records.
/// </summary>
[HttpGet("GetAll")]
[ProducesResponseType(typeof(IEnumerable<FurnitureBase>), StatusCodes.Status200OK)]
public async Task<IActionResult> GetAllAsync(CancellationToken cancellationToken)
{
try
{
logger.LogInformation($"{nameof(GetAllAsync)} - Request received.");
return await Handle(() => inventoryClient.GetAllAsync(TrackingId.ToString(), cancellationToken));
}
catch (Exception ex)
{
logger.LogError(ex, $"{nameof(GetAllAsync)} - An error occurred.");
throw;
}
}
/// <summary>
/// Gets a furniture base by its identifier.
/// </summary>
[HttpPost("GetById")]
[ProducesResponseType(typeof(FurnitureBase), StatusCodes.Status200OK)]
public async Task<IActionResult> GetByIdAsync([FromBody] GetFurnitureBaseByIdRequest request, CancellationToken cancellationToken)
{
try
{
logger.LogInformation($"{nameof(GetByIdAsync)} - Request received. Payload: {JsonSerializer.Serialize(request)}");
if (string.IsNullOrWhiteSpace(request.MongoId))
return BadRequest("FurnitureBase MongoId is required.");
return await Handle(() => inventoryClient.GetByIdAsync(TrackingId.ToString(), request, cancellationToken));
}
catch (Exception ex)
{
logger.LogError(ex, $"{nameof(GetByIdAsync)} - An error occurred. Payload: {JsonSerializer.Serialize(request)}");
throw;
}
}
/// <summary>
/// Creates a new furniture base record.
/// </summary>
[HttpPost("Create")]
[ProducesResponseType(typeof(FurnitureBase), StatusCodes.Status201Created)]
public async Task<IActionResult> CreateAsync([FromBody] CreateFurnitureBaseRequest newFurniture, CancellationToken cancellationToken)
{
try
{
logger.LogInformation($"{nameof(CreateAsync)} - Request received. Payload: {JsonSerializer.Serialize(newFurniture)}");
if (newFurniture == null) return BadRequest("Invalid furniture object");
if (string.IsNullOrEmpty(newFurniture.Name)) return BadRequest("Invalid furniture name");
if (string.IsNullOrEmpty(newFurniture.Material)) return BadRequest("Invalid furniture material");
if (string.IsNullOrEmpty(newFurniture.Condition)) return BadRequest("Invalid furniture condition");
return await Handle(() => inventoryClient.CreateAsync(TrackingId.ToString(), newFurniture, cancellationToken));
}
catch (Exception ex)
{
logger.LogError(ex, $"{nameof(CreateAsync)} - An error occurred. Payload: {JsonSerializer.Serialize(newFurniture)}");
throw;
}
}
/// <summary>
/// Updates a furniture base record.
/// </summary>
[HttpPut("Update")]
[ProducesResponseType(typeof(FurnitureBase), StatusCodes.Status200OK)]
public async Task<IActionResult> UpdateAsync([FromBody] UpdateFurnitureBaseRequest newFurniture, CancellationToken cancellationToken)
{
try
{
logger.LogInformation($"{nameof(UpdateAsync)} - Request received. Payload: {JsonSerializer.Serialize(newFurniture)}");
if (newFurniture == null) return BadRequest("Invalid furniture object");
if (string.IsNullOrEmpty(newFurniture.Name)) return BadRequest("Invalid furniture name");
if (string.IsNullOrEmpty(newFurniture.Material)) return BadRequest("Invalid furniture material");
if (string.IsNullOrEmpty(newFurniture.Condition)) return BadRequest("Invalid furniture condition");
if (string.IsNullOrWhiteSpace(newFurniture.Id)) return BadRequest("Id is required.");
return await Handle(() => inventoryClient.UpdateFurnitureBaseAsync(TrackingId.ToString(), newFurniture, cancellationToken));
}
catch (Exception ex)
{
logger.LogError(ex, $"{nameof(UpdateAsync)} - An error occurred. Payload: {JsonSerializer.Serialize(newFurniture)}");
throw;
}
}
/// <summary>
/// Changes the status of a furniture base.
/// </summary>
[HttpPatch("ChangeStatus")]
[ProducesResponseType(typeof(FurnitureBase), StatusCodes.Status200OK)]
public async Task<IActionResult> ChangeStatusAsync([FromBody] ChangeFurnitureBaseStatusRequest request, CancellationToken cancellationToken)
{
try
{
logger.LogInformation($"{nameof(ChangeStatusAsync)} - Request received. Payload: {JsonSerializer.Serialize(request)}");
if (string.IsNullOrWhiteSpace(request.MongoId)) return BadRequest("Id is required.");
return await Handle(() => inventoryClient.ChangeFurnitureBaseStatusAsync(TrackingId.ToString(), request, cancellationToken));
}
catch (Exception ex)
{
logger.LogError(ex, $"{nameof(ChangeStatusAsync)} - An error occurred. Payload: {JsonSerializer.Serialize(request)}");
throw;
}
}
}
}

167
Core.Inventory.BFF.API/Controllers/FurnitureVariantController.cs Normal file
View File

@@ -0,0 +1,167 @@
using Asp.Versioning;
using Core.Adapters.Lib;
using Core.Inventory.External.Clients.Inventory;
using Core.Inventory.External.Clients.Inventory.Requests.Variant;
using Microsoft.AspNetCore.Mvc;
using System.Text.Json;
namespace Core.Inventory.BFF.API.Controllers
{
/// <summary>
/// Handles all requests for furniture variant operations.
/// </summary>
[ApiVersion("1.0")]
[Route("api/v{version:apiVersion}/[controller]")]
[ApiController]
[Consumes("application/json")]
[Produces("application/json")]
public class FurnitureVariantController(IInventoryServiceClient inventoryClient, ILogger<FurnitureVariantController> logger) : BaseController(logger)
{
/// <summary>
/// Gets furniture variants by model ID.
/// </summary>
[HttpPost("GetAllByModelId")]
[ProducesResponseType(typeof(IEnumerable<FurnitureVariant>), StatusCodes.Status200OK)]
public async Task<IActionResult> GetAllByModelIdAsync([FromBody] GetAllFurnitureVariantsByModelIdRequest request, CancellationToken cancellationToken)
{
try
{
logger.LogInformation($"{nameof(GetAllByModelIdAsync)} - Request received. Payload: {JsonSerializer.Serialize(request)}");
if (string.IsNullOrWhiteSpace(request.ModelId)) return BadRequest("ModelId is required.");
return await Handle(() => inventoryClient.GetVariantsByModelIdAsync(TrackingId.ToString(), request, cancellationToken));
}
catch (Exception ex)
{
logger.LogError(ex, $"{nameof(GetAllByModelIdAsync)} - An error occurred. Payload: {JsonSerializer.Serialize(request)}");
throw;
}
}
/// <summary>
/// Gets a furniture variant by its MongoId.
/// </summary>
[HttpPost("GetById")]
[ProducesResponseType(typeof(FurnitureVariant), StatusCodes.Status200OK)]
public async Task<IActionResult> GetByIdAsync([FromBody] GetFurnitureVariantByIdRequest request, CancellationToken cancellationToken)
{
try
{
logger.LogInformation($"{nameof(GetByIdAsync)} - Request received. Payload: {JsonSerializer.Serialize(request)}");
if (string.IsNullOrWhiteSpace(request.MongoId)) return BadRequest("MongoId is required.");
return await Handle(() => inventoryClient.GetFurnitureVariantByIdAsync(TrackingId.ToString(), request, cancellationToken));
}
catch (Exception ex)
{
logger.LogError(ex, $"{nameof(GetByIdAsync)} - An error occurred. Payload: {JsonSerializer.Serialize(request)}");
throw;
}
}
/// <summary>
/// Gets furniture variants by a list of IDs.
/// </summary>
[HttpPost("GetByIds")]
[ProducesResponseType(typeof(IEnumerable<FurnitureVariant>), StatusCodes.Status200OK)]
public async Task<IActionResult> GetByIdsAsync([FromBody] GetFurnitureVariantsByIdsRequest request, CancellationToken cancellationToken)
{
try
{
logger.LogInformation($"{nameof(GetByIdsAsync)} - Request received. Payload: {JsonSerializer.Serialize(request)}");
if (request?.Ids == null || request.Ids.Count == 0)
return BadRequest("At least one Id is required.");
return await Handle(() => inventoryClient.GetFurnitureVariantsByIdsAsync(TrackingId.ToString(), request, cancellationToken));
}
catch (Exception ex)
{
logger.LogError(ex, $"{nameof(GetByIdsAsync)} - An error occurred. Payload: {JsonSerializer.Serialize(request)}");
throw;
}
}
/// <summary>
/// Creates a new furniture variant.
/// </summary>
[HttpPost("Create")]
[ProducesResponseType(typeof(FurnitureVariant), StatusCodes.Status201Created)]
public async Task<IActionResult> CreateAsync([FromBody] CreateFurnitureVariantRequest newVariant, CancellationToken cancellationToken)
{
try
{
logger.LogInformation($"{nameof(CreateAsync)} - Request received. Payload: {JsonSerializer.Serialize(newVariant)}");
if (newVariant == null) return BadRequest("Invalid furniture object");
if (string.IsNullOrEmpty(newVariant.ModelId)) return BadRequest("Invalid furniture modelId");
if (string.IsNullOrEmpty(newVariant.Name)) return BadRequest("Invalid furniture name");
if (string.IsNullOrEmpty(newVariant.Color)) return BadRequest("Invalid furniture color");
return await Handle(() => inventoryClient.CreateFurnitureVariantAsync(TrackingId.ToString(), newVariant, cancellationToken));
}
catch (Exception ex)
{
logger.LogError(ex, $"{nameof(CreateAsync)} - An error occurred. Payload: {JsonSerializer.Serialize(newVariant)}");
throw;
}
}
/// <summary>
/// Updates a furniture variant.
/// </summary>
[HttpPut("Update")]
[ProducesResponseType(typeof(FurnitureVariant), StatusCodes.Status200OK)]
public async Task<IActionResult> UpdateAsync([FromBody] UpdateFurnitureVariantRequest newVariant, CancellationToken cancellationToken)
{
try
{
logger.LogInformation($"{nameof(UpdateAsync)} - Request received. Payload: {JsonSerializer.Serialize(newVariant)}");
if (newVariant == null) return BadRequest("Invalid furniture object");
if (string.IsNullOrEmpty(newVariant.ModelId)) return BadRequest("Invalid furniture modelId");
if (string.IsNullOrEmpty(newVariant.Name)) return BadRequest("Invalid furniture name");
if (string.IsNullOrEmpty(newVariant.Color)) return BadRequest("Invalid furniture color");
if (string.IsNullOrWhiteSpace(newVariant.Id)) return BadRequest("Id is required.");
return await Handle(() => inventoryClient.UpdateFurnitureVariantAsync(TrackingId.ToString(), newVariant.Id, newVariant, cancellationToken));
}
catch (Exception ex)
{
logger.LogError(ex, $"{nameof(UpdateAsync)} - An error occurred. Payload: {JsonSerializer.Serialize(newVariant)}");
throw;
}
}
/// <summary>
/// Changes the status of a furniture variant.
/// </summary>
[HttpPatch("ChangeStatus")]
[ProducesResponseType(typeof(FurnitureVariant), StatusCodes.Status200OK)]
public async Task<IActionResult> ChangeStatusAsync([FromBody] ChangeFurnitureVariantStatusRequest request, CancellationToken cancellationToken)
{
try
{
logger.LogInformation($"{nameof(ChangeStatusAsync)} - Request received. Payload: {JsonSerializer.Serialize(request)}");
if (string.IsNullOrWhiteSpace(request.MongoId)) return BadRequest("Id is required.");
return await Handle(() => inventoryClient.ChangeFurnitureVariantStatusAsync(TrackingId.ToString(), request, cancellationToken));
}
catch (Exception ex)
{
logger.LogError(ex, $"{nameof(ChangeStatusAsync)} - An error occurred. Payload: {JsonSerializer.Serialize(request)}");
throw;
}
}
}
}

33
Core.Inventory.BFF.API/Controllers/WeatherForecastController.cs
View File

@@ -1,33 +0,0 @@
using Microsoft.AspNetCore.Mvc;
namespace Core.Inventory.BFF.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(Name = "GetWeatherForecast")]
public IEnumerable<WeatherForecast> Get()
{
return Enumerable.Range(1, 5).Select(index => new WeatherForecast
{
Date = DateOnly.FromDateTime(DateTime.Now.AddDays(index)),
TemperatureC = Random.Shared.Next(-20, 55),
Summary = Summaries[Random.Shared.Next(Summaries.Length)]
})
.ToArray();
}
}
}

10
Core.Inventory.BFF.API/Core.Inventory.BFF.API.csproj
View File

@@ -7,7 +7,15 @@
</PropertyGroup>
<ItemGroup>
<PackageReference Include="Swashbuckle.AspNetCore" Version="6.6.2" />
<PackageReference Include="Asp.Versioning.Mvc.ApiExplorer" Version="8.1.0" />
<PackageReference Include="Core.Blueprint.Logging" Version="1.0.1" />
<PackageReference Include="OpenTelemetry" Version="1.12.0" />
<PackageReference Include="OpenTelemetry.Exporter.Console" Version="1.12.0" />
<PackageReference Include="Swashbuckle.AspNetCore" Version="8.1.4" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\Core.Inventory.External\Core.Inventory.External.csproj" />
</ItemGroup>
</Project>

130
Core.Inventory.BFF.API/Program.cs
View File

@@ -1,25 +1,133 @@
using Core.Blueprint.Logging.Configuration;
using Core.Inventory.External;
using Core.Inventory.External.ClientConfiguration;
using Microsoft.AspNetCore.ResponseCompression;
using OpenTelemetry.Logs;
using OpenTelemetry.Resources;
using Swashbuckle.AspNetCore.SwaggerUI;
using System.IO.Compression;
using System.Reflection;
var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
builder.Services.AddControllers();
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();
builder.Configuration
.AddUserSecrets(Assembly.GetExecutingAssembly())
.AddEnvironmentVariables();
builder.Services.AddResponseCompression();
builder.Services.AddProblemDetails();
builder.Services.AddLogs(builder);
builder.Services.AddMemoryCache();
builder.Services.AddResponseCaching(configureOptions => { configureOptions.UseCaseSensitivePaths = true; });
builder.Logging.AddOpenTelemetry(options =>
{
options.IncludeScopes = true;
options.SetResourceBuilder(ResourceBuilder.CreateDefault().AddService("core.inventory.bff.api")).AddConsoleExporter();
});
builder.Host.ConfigureServices((context, services) =>
{
builder.Services.AddHsts(options =>
{
options.Preload = true;
options.IncludeSubDomains = true;
options.MaxAge = TimeSpan.FromDays(60);
});
builder.Services.AddResponseCaching(configureOptions =>
{
configureOptions.UseCaseSensitivePaths = true;
configureOptions.MaximumBodySize = 2048;
});
builder.Services.AddHttpsRedirection(options =>
{
options.RedirectStatusCode = 308;
});
services.AddHttpLogging(http =>
{
http.CombineLogs = true;
});
services.AddAntiforgery();
services.AddCors(options =>
{
options.AddPolicy("AllowAll", policyBuilder =>
policyBuilder.AllowAnyOrigin().AllowAnyHeader().AllowAnyMethod());
});
services.AddMvc().AddJsonOptions(options =>
{
options.JsonSerializerOptions.WriteIndented = true;
options.JsonSerializerOptions.MaxDepth = 20;
options.JsonSerializerOptions.NumberHandling = System.Text.Json.Serialization.JsonNumberHandling.AllowNamedFloatingPointLiterals;
});
services.Configure<BrotliCompressionProviderOptions>(options =>
{
options.Level = CompressionLevel.SmallestSize;
});
services.Configure<GzipCompressionProviderOptions>(options =>
{
options.Level = CompressionLevel.SmallestSize;
});
services.AddResponseCompression(options =>
{
options.EnableForHttps = true;
options.Providers.Add<BrotliCompressionProvider>();
options.Providers.Add<GzipCompressionProvider>();
});
services.AddResponseCaching();
services.AddControllers();
services.AddEndpointsApiExplorer();
services.AddSwaggerGen();
services.AddLogging();
services.AddProblemDetails();
services.AddHttpContextAccessor();
services.AddTransient<TrackingMechanismExtension>(); // Register the TrackingIdHandler
services.RegisterExternalLayer(builder.Configuration);
services.AddApiVersioning(options => options.ReportApiVersions = true)
.AddApiExplorer(options =>
{
options.GroupNameFormat = "'v'VVV";
options.SubstituteApiVersionInUrl = true;
});
});
builder.Services.AddCors(options =>
{
options.AddDefaultPolicy(
builder =>
{
builder.AllowAnyOrigin()
.AllowAnyHeader()
.AllowAnyMethod();
});
});
//*************************************************************************//
var app = builder.Build();
// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
app.UseCors(options => options.AllowAnyHeader().AllowAnyMethod().AllowAnyOrigin());
app.UseSwagger();
app.UseSwaggerUI(options =>
{
app.UseSwagger();
app.UseSwaggerUI();
}
foreach (var version in app.DescribeApiVersions().Select(version => version.GroupName))
options.SwaggerEndpoint($"/swagger/{version}/swagger.json", version);
options.DisplayRequestDuration();
options.EnableTryItOutByDefault();
options.DocExpansion(DocExpansion.None);
});
app.UseResponseCompression();
app.UseResponseCaching();
app.UseHttpsRedirection();
app.UseAuthentication();
app.UseAuthorization();
app.MapControllers();
app.UseHsts();
app.UseAntiforgery();
app.UseLogging(builder.Configuration);
app.Run();

6
Core.Inventory.BFF.API/Properties/launchSettings.json
View File

@@ -16,7 +16,7 @@
"launchUrl": "swagger",
"applicationUrl": "http://localhost:5101",
"environmentVariables": {
"ASPNETCORE_ENVIRONMENT": "Development"
"ASPNETCORE_ENVIRONMENT": "Local"
}
},
"https": {
@@ -26,7 +26,7 @@
"launchUrl": "swagger",
"applicationUrl": "https://localhost:7223;http://localhost:5101",
"environmentVariables": {
"ASPNETCORE_ENVIRONMENT": "Development"
"ASPNETCORE_ENVIRONMENT": "Local"
}
},
"IIS Express": {
@@ -34,7 +34,7 @@
"launchBrowser": true,
"launchUrl": "swagger",
"environmentVariables": {
"ASPNETCORE_ENVIRONMENT": "Development"
"ASPNETCORE_ENVIRONMENT": "Local"
}
}
}

13
Core.Inventory.BFF.API/WeatherForecast.cs
View File

@@ -1,13 +0,0 @@
namespace Core.Inventory.BFF.API
{
public class WeatherForecast
{
public DateOnly Date { get; set; }
public int TemperatureC { get; set; }
public int TemperatureF => 32 + (int)(TemperatureC / 0.5556);
public string? Summary { get; set; }
}
}

12
Core.Inventory.BFF.API/appsettings.Local.json Normal file
View File

@@ -0,0 +1,12 @@
{
"Logging": {
"LogLevel": {
"Default": "Information",
"Microsoft.AspNetCore": "Warning"
}
},
"LocalGateways": {
"InventoryService": "https://localhost:7028"
}
}