mz/DiunaBI
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Edit Records

Browse Source
This commit is contained in:
Michał Zieliński
2025-12-01 17:56:17 +01:00
parent 7ea5ed506e
commit c8ded1f0a4
11 changed files with 624 additions and 28 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
DiunaBI.API/Controllers/AuthController.cs
View File

@@ -1,9 +1,11 @@
using DiunaBI.API.Services;
using DiunaBI.Domain.Entities;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
namespace DiunaBI.API.Controllers;
[AllowAnonymous]
[ApiController]
[Route("[controller]")]
public class AuthController(

1
DiunaBI.API/Controllers/DataInboxController.cs
View File

@@ -9,6 +9,7 @@ using DiunaBI.Application.DTOModels.Common;
namespace DiunaBI.API.Controllers;
[Authorize]
[ApiController]
[Route("[controller]")]
public class DataInboxController : Controller

206
DiunaBI.API/Controllers/LayersController.cs
View File

@@ -12,6 +12,7 @@ using DiunaBI.Infrastructure.Services;
namespace DiunaBI.API.Controllers;
[Authorize]
[ApiController]
[Route("[controller]")]
public class LayersController : Controller
@@ -727,4 +728,209 @@ public class LayersController : Controller
throw;
}
}
// Record CRUD operations
[HttpPost]
[Route("{layerId:guid}/records")]
public IActionResult CreateRecord(Guid layerId, [FromBody] RecordDto recordDto)
{
try
{
var userId = Request.Headers["UserId"].ToString();
if (string.IsNullOrEmpty(userId))
{
_logger.LogWarning("CreateRecord: No UserId in request headers");
return Unauthorized();
}
var layer = _db.Layers.FirstOrDefault(x => x.Id == layerId && !x.IsDeleted);
if (layer == null)
{
_logger.LogWarning("CreateRecord: Layer {LayerId} not found", layerId);
return NotFound("Layer not found");
}
if (layer.Type != Domain.Entities.LayerType.Dictionary && layer.Type != Domain.Entities.LayerType.Administration)
{
_logger.LogWarning("CreateRecord: Layer {LayerId} is not editable (type: {LayerType})", layerId, layer.Type);
return BadRequest("Only Dictionary and Administration layers can be edited");
}
if (string.IsNullOrWhiteSpace(recordDto.Code))
{
return BadRequest("Code is required");
}
if (string.IsNullOrWhiteSpace(recordDto.Desc1))
{
return BadRequest("Desc1 is required");
}
var record = new Record
{
Id = Guid.NewGuid(),
Code = recordDto.Code,
Desc1 = recordDto.Desc1,
LayerId = layerId,
CreatedAt = DateTime.UtcNow,
ModifiedAt = DateTime.UtcNow,
CreatedById = Guid.Parse(userId),
ModifiedById = Guid.Parse(userId),
IsDeleted = false
};
_db.Records.Add(record);
// Update layer modified info
layer.ModifiedAt = DateTime.UtcNow;
layer.ModifiedById = Guid.Parse(userId);
_db.SaveChanges();
_logger.LogInformation("CreateRecord: Created record {RecordId} in layer {LayerId}", record.Id, layerId);
return Ok(new RecordDto
{
Id = record.Id,
Code = record.Code,
Desc1 = record.Desc1,
LayerId = record.LayerId,
CreatedAt = record.CreatedAt,
ModifiedAt = record.ModifiedAt,
CreatedById = record.CreatedById,
ModifiedById = record.ModifiedById
});
}
catch (Exception e)
{
_logger.LogError(e, "CreateRecord: Error creating record in layer {LayerId}", layerId);
return BadRequest(e.ToString());
}
}
[HttpPut]
[Route("{layerId:guid}/records/{recordId:guid}")]
public IActionResult UpdateRecord(Guid layerId, Guid recordId, [FromBody] RecordDto recordDto)
{
try
{
var userId = Request.Headers["UserId"].ToString();
if (string.IsNullOrEmpty(userId))
{
_logger.LogWarning("UpdateRecord: No UserId in request headers");
return Unauthorized();
}
var layer = _db.Layers.FirstOrDefault(x => x.Id == layerId && !x.IsDeleted);
if (layer == null)
{
_logger.LogWarning("UpdateRecord: Layer {LayerId} not found", layerId);
return NotFound("Layer not found");
}
if (layer.Type != Domain.Entities.LayerType.Dictionary && layer.Type != Domain.Entities.LayerType.Administration)
{
_logger.LogWarning("UpdateRecord: Layer {LayerId} is not editable (type: {LayerType})", layerId, layer.Type);
return BadRequest("Only Dictionary and Administration layers can be edited");
}
var record = _db.Records.FirstOrDefault(x => x.Id == recordId && x.LayerId == layerId);
if (record == null)
{
_logger.LogWarning("UpdateRecord: Record {RecordId} not found in layer {LayerId}", recordId, layerId);
return NotFound("Record not found");
}
if (string.IsNullOrWhiteSpace(recordDto.Code))
{
return BadRequest("Code is required");
}
if (string.IsNullOrWhiteSpace(recordDto.Desc1))
{
return BadRequest("Desc1 is required");
}
record.Desc1 = recordDto.Desc1;
record.ModifiedAt = DateTime.UtcNow;
record.ModifiedById = Guid.Parse(userId);
// Update layer modified info
layer.ModifiedAt = DateTime.UtcNow;
layer.ModifiedById = Guid.Parse(userId);
_db.SaveChanges();
_logger.LogInformation("UpdateRecord: Updated record {RecordId} in layer {LayerId}", recordId, layerId);
return Ok(new RecordDto
{
Id = record.Id,
Code = record.Code,
Desc1 = record.Desc1,
LayerId = record.LayerId,
CreatedAt = record.CreatedAt,
ModifiedAt = record.ModifiedAt,
CreatedById = record.CreatedById,
ModifiedById = record.ModifiedById
});
}
catch (Exception e)
{
_logger.LogError(e, "UpdateRecord: Error updating record {RecordId} in layer {LayerId}", recordId, layerId);
return BadRequest(e.ToString());
}
}
[HttpDelete]
[Route("{layerId:guid}/records/{recordId:guid}")]
public IActionResult DeleteRecord(Guid layerId, Guid recordId)
{
try
{
var userId = Request.Headers["UserId"].ToString();
if (string.IsNullOrEmpty(userId))
{
_logger.LogWarning("DeleteRecord: No UserId in request headers");
return Unauthorized();
}
var layer = _db.Layers.FirstOrDefault(x => x.Id == layerId && !x.IsDeleted);
if (layer == null)
{
_logger.LogWarning("DeleteRecord: Layer {LayerId} not found", layerId);
return NotFound("Layer not found");
}
if (layer.Type != Domain.Entities.LayerType.Dictionary && layer.Type != Domain.Entities.LayerType.Administration)
{
_logger.LogWarning("DeleteRecord: Layer {LayerId} is not editable (type: {LayerType})", layerId, layer.Type);
return BadRequest("Only Dictionary and Administration layers can be edited");
}
var record = _db.Records.FirstOrDefault(x => x.Id == recordId && x.LayerId == layerId);
if (record == null)
{
_logger.LogWarning("DeleteRecord: Record {RecordId} not found in layer {LayerId}", recordId, layerId);
return NotFound("Record not found");
}
_db.Records.Remove(record);
// Update layer modified info
layer.ModifiedAt = DateTime.UtcNow;
layer.ModifiedById = Guid.Parse(userId);
_db.SaveChanges();
_logger.LogInformation("DeleteRecord: Deleted record {RecordId} from layer {LayerId}", recordId, layerId);
return Ok();
}
catch (Exception e)
{
_logger.LogError(e, "DeleteRecord: Error deleting record {RecordId} from layer {LayerId}", recordId, layerId);
return BadRequest(e.ToString());
}
}
}

71
DiunaBI.API/Program.cs
View File

@@ -177,26 +177,67 @@ else
pluginManager.LoadPluginsFromDirectory(pluginsPath);
app.Use(async (context, next) =>
{
var token = context.Request.Headers.Authorization.ToString();
if (token.Length > 0
&& !context.Request.Path.ToString().Contains("getForPowerBI")
&& !context.Request.Path.ToString().Contains("getConfiguration")
&& !context.Request.Path.ToString().Contains("DataInbox/Add"))
{
var handler = new JwtSecurityTokenHandler();
var data = handler.ReadJwtToken(token.Split(' ')[1]);
context.Request.Headers.Append("UserId", new Microsoft.Extensions.Primitives.StringValues(data.Subject));
}
await next(context);
});
app.UseCors("CORSPolicy");
app.UseAuthentication();
app.UseAuthorization();
// Middleware to extract UserId from JWT token AFTER authentication
// This must run after UseAuthentication() so the JWT is already validated
app.Use(async (context, next) =>
{
var logger = context.RequestServices.GetRequiredService<ILogger<Program>>();
logger.LogInformation("🔍 UserId Extraction Middleware - Path: {Path}, Method: {Method}",
context.Request.Path, context.Request.Method);
var token = context.Request.Headers.Authorization.ToString();
logger.LogInformation("🔍 Authorization header: {Token}",
string.IsNullOrEmpty(token) ? "NULL/EMPTY" : $"{token[..Math.Min(30, token.Length)]}...");
if (!string.IsNullOrEmpty(token) && token.StartsWith("Bearer ", StringComparison.OrdinalIgnoreCase))
{
try
{
var handler = new JwtSecurityTokenHandler();
var jwtToken = handler.ReadJwtToken(token.Split(' ')[1]);
// Try to get UserId from Subject claim first, then fall back to NameIdentifier
var userId = jwtToken.Subject;
if (string.IsNullOrEmpty(userId))
{
// Try NameIdentifier claim (ClaimTypes.NameIdentifier)
var nameIdClaim = jwtToken.Claims.FirstOrDefault(c =>
c.Type == "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/nameidentifier" ||
c.Type == "nameid");
userId = nameIdClaim?.Value;
}
logger.LogInformation("🔍 JWT UserId: {UserId}", userId ?? "NULL");
if (!string.IsNullOrEmpty(userId))
{
// Use indexer to set/replace header value instead of Append
context.Request.Headers["UserId"] = userId;
logger.LogInformation("✅ Set UserId header to: {UserId}", userId);
}
else
{
logger.LogWarning("❌ UserId not found in JWT claims");
}
}
catch (Exception ex)
{
logger.LogError(ex, "❌ Failed to extract UserId from JWT token");
}
}
else
{
logger.LogWarning("❌ No valid Bearer token found");
}
await next(context);
});
app.MapControllers();
app.MapGet("/health", () => Results.Ok(new { status = "OK", timestamp = DateTime.UtcNow }))

1
DiunaBI.UI.Shared/Extensions/ServiceCollectionExtensions.cs
View File

@@ -17,6 +17,7 @@ public static class ServiceCollectionExtensions
services.AddTransient<HttpLoggingHandler>();
// Configure named HttpClient with logging handler
// Note: Authentication is handled by AuthService setting DefaultRequestHeaders.Authorization
services.AddHttpClient("DiunaBI", client =>
{
client.BaseAddress = new Uri(baseUri);

35
DiunaBI.UI.Shared/Handlers/AuthenticationHandler.cs Normal file
View File

@@ -0,0 +1,35 @@
using DiunaBI.UI.Shared.Services;
namespace DiunaBI.UI.Shared.Handlers;
public class AuthenticationHandler : DelegatingHandler
{
private readonly TokenProvider _tokenProvider;
public AuthenticationHandler(TokenProvider tokenProvider)
{
_tokenProvider = tokenProvider;
}
protected override async Task<HttpResponseMessage> SendAsync(
HttpRequestMessage request,
CancellationToken cancellationToken)
{
// Get token from TokenProvider
var token = _tokenProvider.Token;
Console.WriteLine($"🔐 AuthenticationHandler: Token = {(string.IsNullOrEmpty(token) ? "NULL" : $"{token[..Math.Min(20, token.Length)]}...")}");
if (!string.IsNullOrEmpty(token))
{
request.Headers.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", token);
Console.WriteLine($"🔐 AuthenticationHandler: Added Bearer token to request");
}
else
{
Console.WriteLine($"🔐 AuthenticationHandler: No token available, request will be unauthorized");
}
return await base.SendAsync(request, cancellationToken);
}
}

111
DiunaBI.UI.Shared/Pages/LayerDetailPage.razor
View File

@@ -84,13 +84,72 @@
{
<MudTh>@column</MudTh>
}
@if (isEditable)
{
<MudTh>Actions</MudTh>
}
</HeaderContent>
<RowTemplate>
@if (editingRecordId == context.Id)
{
<MudTd DataLabel="Code">
<MudTextField @bind-Value="editingRecord.Code"
Variant="Variant.Outlined"
Margin="Margin.Dense"
FullWidth="true"/>
</MudTd>
@foreach (var column in displayedColumns)
{
@if (column == "Description1")
{
<MudTd DataLabel="@column">
<MudTextField @bind-Value="editingRecord.Desc1"
Variant="Variant.Outlined"
Margin="Margin.Dense"
FullWidth="true"/>
</MudTd>
}
else
{
<MudTd DataLabel="@column">@GetRecordValue(context, column)</MudTd>
}
}
<MudTd>
<MudIconButton Icon="@Icons.Material.Filled.Check"
Color="Color.Success"
Size="Size.Small"
OnClick="SaveEdit"
Title="Save"/>
<MudIconButton Icon="@Icons.Material.Filled.Close"
Color="Color.Default"
Size="Size.Small"
OnClick="CancelEdit"
Title="Cancel"/>
</MudTd>
}
else
{
<MudTd DataLabel="Code">@context.Code</MudTd>
@foreach (var column in displayedColumns)
{
<MudTd DataLabel="@column">@GetRecordValue(context, column)</MudTd>
}
@if (isEditable)
{
<MudTd>
<MudIconButton Icon="@Icons.Material.Filled.Edit"
Color="Color.Primary"
Size="Size.Small"
OnClick="() => StartEdit(context)"
Title="Edit"/>
<MudIconButton Icon="@Icons.Material.Filled.Delete"
Color="Color.Error"
Size="Size.Small"
OnClick="() => DeleteRecord(context)"
Title="Delete"/>
</MudTd>
}
}
</RowTemplate>
<FooterContent>
<MudTd><b>Value1 sum</b></MudTd>
@@ -105,8 +164,60 @@
<MudTd></MudTd>
}
}
@if (isEditable)
{
<MudTd></MudTd>
}
</FooterContent>
</MudTable>
@if (isEditable)
{
@if (isAddingNew)
{
<MudPaper Class="mt-4 pa-4" Outlined="true">
<MudGrid>
<MudItem xs="12" md="6">
<MudTextField @bind-Value="newRecord.Code"
Label="Code"
Variant="Variant.Outlined"
FullWidth="true"/>
</MudItem>
<MudItem xs="12" md="6">
<MudTextField @bind-Value="newRecord.Desc1"
Label="Description"
Variant="Variant.Outlined"
FullWidth="true"/>
</MudItem>
<MudItem xs="12" Class="d-flex justify-end">
<MudButton Variant="Variant.Filled"
Color="Color.Success"
OnClick="SaveNewRecord"
StartIcon="@Icons.Material.Filled.Check"
Class="mr-2">
Save
</MudButton>
<MudButton Variant="Variant.Outlined"
Color="Color.Default"
OnClick="CancelAddNew"
StartIcon="@Icons.Material.Filled.Close">
Cancel
</MudButton>
</MudItem>
</MudGrid>
</MudPaper>
}
else
{
<MudButton Variant="Variant.Outlined"
Color="Color.Primary"
OnClick="StartAddNew"
StartIcon="@Icons.Material.Filled.Add"
Class="mt-4">
Add New Record
</MudButton>
}
}
}
</MudCardContent>
</MudCard>

159
DiunaBI.UI.Shared/Pages/LayerDetailPage.razor.cs
View File

@@ -13,11 +13,19 @@ public partial class LayerDetailPage : ComponentBase
[Inject]
private ISnackbar Snackbar { get; set; } = null!;
[Inject]
private IDialogService DialogService { get; set; } = null!;
private LayerDto? layer;
private List<RecordDto> records = new();
private List<string> displayedColumns = new();
private double valueSum = 0;
private bool isLoading = false;
private Guid? editingRecordId = null;
private RecordDto? editingRecord = null;
private bool isAddingNew = false;
private RecordDto newRecord = new();
private bool isEditable => layer?.Type == LayerType.Dictionary || layer?.Type == LayerType.Administration;
protected override async Task OnInitializedAsync()
{
@@ -119,4 +127,155 @@ public partial class LayerDetailPage : ComponentBase
// TODO: Implement process layer functionality
Snackbar.Add("Process layer functionality coming soon", Severity.Error);
}
// Record editing methods
private void StartEdit(RecordDto record)
{
editingRecordId = record.Id;
editingRecord = new RecordDto
{
Id = record.Id,
Code = record.Code,
Desc1 = record.Desc1,
LayerId = record.LayerId
};
}
private void CancelEdit()
{
editingRecordId = null;
editingRecord = null;
}
private async Task SaveEdit()
{
if (editingRecord == null || layer == null) return;
if (string.IsNullOrWhiteSpace(editingRecord.Code))
{
Snackbar.Add("Code is required", Severity.Warning);
return;
}
if (string.IsNullOrWhiteSpace(editingRecord.Desc1))
{
Snackbar.Add("Description is required", Severity.Warning);
return;
}
try
{
var updated = await LayerService.UpdateRecordAsync(layer.Id, editingRecord.Id, editingRecord);
if (updated != null)
{
var record = records.FirstOrDefault(r => r.Id == editingRecord.Id);
if (record != null)
{
record.Code = updated.Code;
record.Desc1 = updated.Desc1;
record.ModifiedAt = updated.ModifiedAt;
}
editingRecordId = null;
editingRecord = null;
Snackbar.Add("Record updated successfully", Severity.Success);
StateHasChanged();
}
else
{
Snackbar.Add("Failed to update record", Severity.Error);
}
}
catch (Exception ex)
{
Console.Error.WriteLine($"Error updating record: {ex.Message}");
Snackbar.Add("Error updating record", Severity.Error);
}
}
private async Task DeleteRecord(RecordDto record)
{
if (layer == null) return;
var result = await DialogService.ShowMessageBox(
"Confirm Delete",
$"Are you sure you want to delete record '{record.Code}'?",
yesText: "Delete",
cancelText: "Cancel");
if (result == true)
{
try
{
var success = await LayerService.DeleteRecordAsync(layer.Id, record.Id);
if (success)
{
records.Remove(record);
CalculateDisplayedColumns();
CalculateValueSum();
Snackbar.Add("Record deleted successfully", Severity.Success);
}
else
{
Snackbar.Add("Failed to delete record", Severity.Error);
}
}
catch (Exception ex)
{
Console.Error.WriteLine($"Error deleting record: {ex.Message}");
Snackbar.Add("Error deleting record", Severity.Error);
}
}
}
private void StartAddNew()
{
isAddingNew = true;
newRecord = new RecordDto { LayerId = layer?.Id ?? Guid.Empty };
}
private void CancelAddNew()
{
isAddingNew = false;
newRecord = new();
}
private async Task SaveNewRecord()
{
if (layer == null) return;
if (string.IsNullOrWhiteSpace(newRecord.Code))
{
Snackbar.Add("Code is required", Severity.Warning);
return;
}
if (string.IsNullOrWhiteSpace(newRecord.Desc1))
{
Snackbar.Add("Description is required", Severity.Warning);
return;
}
try
{
var created = await LayerService.CreateRecordAsync(layer.Id, newRecord);
if (created != null)
{
records.Add(created);
CalculateDisplayedColumns();
CalculateValueSum();
isAddingNew = false;
newRecord = new();
Snackbar.Add("Record added successfully", Severity.Success);
}
else
{
Snackbar.Add("Failed to add record", Severity.Error);
}
}
catch (Exception ex)
{
Console.Error.WriteLine($"Error adding record: {ex.Message}");
Snackbar.Add("Error adding record", Severity.Error);
}
}
}

34
DiunaBI.UI.Shared/Services/LayerService.cs
View File

@@ -56,4 +56,38 @@ public class LayerService
// For now we don't need it for read-only view
return await Task.FromResult(false);
}
public async Task<RecordDto?> CreateRecordAsync(Guid layerId, RecordDto record)
{
var response = await _httpClient.PostAsJsonAsync($"Layers/{layerId}/records", record);
if (!response.IsSuccessStatusCode)
{
var error = await response.Content.ReadAsStringAsync();
Console.Error.WriteLine($"CreateRecordAsync failed: {response.StatusCode} - {error}");
return null;
}
return await response.Content.ReadFromJsonAsync<RecordDto>();
}
public async Task<RecordDto?> UpdateRecordAsync(Guid layerId, Guid recordId, RecordDto record)
{
var response = await _httpClient.PutAsJsonAsync($"Layers/{layerId}/records/{recordId}", record);
if (!response.IsSuccessStatusCode)
{
var error = await response.Content.ReadAsStringAsync();
Console.Error.WriteLine($"UpdateRecordAsync failed: {response.StatusCode} - {error}");
return null;
}
return await response.Content.ReadFromJsonAsync<RecordDto>();
}
public async Task<bool> DeleteRecordAsync(Guid layerId, Guid recordId)
{
var response = await _httpClient.DeleteAsync($"Layers/{layerId}/records/{recordId}");
return response.IsSuccessStatusCode;
}
}

6
DiunaBI.UI.Shared/Services/TokenProvider.cs Normal file
View File

@@ -0,0 +1,6 @@
namespace DiunaBI.UI.Shared.Services;
public class TokenProvider
{
public string? Token { get; set; }
}