Add dashboard cruds and widgets

.vscode/settings.json

@@ -24,6 +24,7 @@
     "banktrackingfrontend",
     "bankuser",
     "codegen",
+    "Gridster",
     "healthcheck",
     "isready",
     "xaxis",

PhantomDave.BankTracking.Api/Program.cs

@@ -33,6 +33,7 @@ public static void Main(string[] args)
         builder.Services.AddScoped<FinanceRecordService>();
         builder.Services.AddScoped<FileImportService>();
         builder.Services.AddScoped<ColumnDetectionService>();
+        builder.Services.AddScoped<DashboardService>();
         builder.Services.AddHttpContextAccessor();
         builder.Services.Configure<JwtSettings>(builder.Configuration.GetSection("Jwt"));
         builder.Services.AddSingleton<IJwtTokenService, JwtTokenService>();
@@ -94,6 +95,7 @@ public static void Main(string[] args)
             .AddMutationType()
             .AddType<UploadType>()
             .BindRuntimeType<RecurrenceFrequency, EnumType<RecurrenceFrequency>>()
+            .BindRuntimeType<WidgetType, EnumType<WidgetType>>()
             .ModifyRequestOptions(options =>
             {
                 options.IncludeExceptionDetails = builder.Environment.IsDevelopment();

PhantomDave.BankTracking.Api/Services/DashboardService.cs

@@ -0,0 +1,216 @@
+using Microsoft.EntityFrameworkCore;
+using PhantomDave.BankTracking.Data.UnitOfWork;
+using PhantomDave.BankTracking.Library.Models;
+
+namespace PhantomDave.BankTracking.Api.Services;
+
+public class DashboardService
+{
+    private readonly IUnitOfWork _unitOfWork;
+
+    public DashboardService(IUnitOfWork unitOfWork)
+    {
+        _unitOfWork = unitOfWork;
+    }
+
+    public Task<Dashboard?> GetDashboardAsync(int id) =>
+        _unitOfWork.Dashboards.GetByIdAsync(id);
+
+    public async Task<IEnumerable<Dashboard>> GetAllDashboardsAsync()
+    {
+        var dashboards = await _unitOfWork.Dashboards
+            .Query()
+            .AsNoTracking()
+            .OrderBy(d => d.Id)
+            .ToListAsync();
+
+        foreach (var dashboard in dashboards)
+        {
+            var widgets = await _unitOfWork.DashboardWidgets
+                .Query()
+                .Where(w => w.DashboardId == dashboard.Id)
+                .OrderBy(w => w.Id)
+                .ToListAsync();
+            dashboard.Widgets = widgets.ToList();
+        }
+
+        return dashboards;
+    }
+
+    public async Task<Dashboard?> CreateDashboardAsync(string name)
+    {
+        if (string.IsNullOrWhiteSpace(name))
+        {
+            return null;
+        }
+
+        var normalizedName = NormalizeName(name);
+        if (normalizedName.Length == 0)
+        {
+            return null;
+        }
+
+        var dashboard = new Dashboard
+        {
+            Name = normalizedName,
+            Widgets = []
+        };
+
+        await _unitOfWork.Dashboards.AddAsync(dashboard);
+        await _unitOfWork.SaveChangesAsync();
+
+        return dashboard;
+    }
+
+    public async Task<Dashboard?> UpdateDashboardAsync(
+        int id,
+        string? name = null)
+    {
+        var dashboard = await _unitOfWork.Dashboards.GetByIdAsync(id);
+        if (dashboard is null)
+        {
+            return null;
+        }
+
+        if (!string.IsNullOrWhiteSpace(name))
+        {
+            var normalizedName = NormalizeName(name);
+            if (normalizedName.Length == 0)
+            {
+                return null;
+            }
+
+            dashboard.Name = normalizedName;
+        }
+
+        await _unitOfWork.Dashboards.UpdateAsync(dashboard);
+        await _unitOfWork.SaveChangesAsync();
+
+        return dashboard;
+    }
+
+    public async Task<bool> DeleteDashboardAsync(int id)
+    {
+        var deleted = await _unitOfWork.Dashboards.DeleteAsync(id);
+        if (!deleted)
+        {
+            return false;
+        }
+
+        await _unitOfWork.SaveChangesAsync();
+        return true;
+    }
+
+    public async Task<DashboardWidget?> AddWidgetAsync(
+        int dashboardId,
+        WidgetType type,
+        int x,
+        int y,
+        int rows,
+        int cols)
+    {
+        var dashboard = await _unitOfWork.Dashboards.GetByIdAsync(dashboardId);
+        if (dashboard is null)
+        {
+            return null;
+        }
+
+        if (rows <= 0 || cols <= 0)
+        {
+            return null;
+        }
+
+        var widget = new DashboardWidget
+        {
+            DashboardId = dashboardId,
+            Type = type,
+            X = Math.Max(0, x),
+            Y = Math.Max(0, y),
+            Rows = rows,
+            Cols = cols
+        };
+
+        await _unitOfWork.DashboardWidgets.AddAsync(widget);
+        await _unitOfWork.SaveChangesAsync();
+
+        return widget;
+    }
+
+    public async Task<DashboardWidget?> UpdateWidgetAsync(
+        int id,
+        WidgetType? type = null,
+        int? x = null,
+        int? y = null,
+        int? rows = null,
+        int? cols = null)
+    {
+        var widget = await _unitOfWork.DashboardWidgets.GetByIdAsync(id);
+        if (widget is null)
+        {
+            return null;
+        }
+
+        if (type.HasValue)
+        {
+            widget.Type = type.Value;
+        }
+
+        if (x.HasValue)
+        {
+            widget.X = Math.Max(0, x.Value);
+        }
+
+        if (y.HasValue)
+        {
+            widget.Y = Math.Max(0, y.Value);
+        }
+
+        if (rows.HasValue)
+        {
+            if (rows.Value <= 0)
+            {
+                return null;
+            }
+
+            widget.Rows = rows.Value;
+        }
+
+        if (cols.HasValue)
+        {
+            if (cols.Value <= 0)
+            {
+                return null;
+            }
+
+            widget.Cols = cols.Value;
+        }
+
+        await _unitOfWork.DashboardWidgets.UpdateAsync(widget);
+        await _unitOfWork.SaveChangesAsync();
+
+        return widget;
+    }
+
+    public async Task<bool> RemoveWidgetAsync(int id)
+    {
+        var deleted = await _unitOfWork.DashboardWidgets.DeleteAsync(id);
+        if (!deleted)
+        {
+            return false;
+        }
+
+        await _unitOfWork.SaveChangesAsync();
+        return true;
+    }
+
+    private static string NormalizeName(string name)
+    {
+        if (string.IsNullOrWhiteSpace(name))
+        {
+            return string.Empty;
+        }
+
+        var trimmed = name.Trim();
+        return trimmed.Length <= 100 ? trimmed : trimmed[..100];
+    }
+}

PhantomDave.BankTracking.Api/Services/FileImportService.cs

@@ -102,7 +102,7 @@ private async Task<ParsedFileData> ParseXlsxAsync(Stream stream)
     {
         var parsedData = new ParsedFileData();
 
-        parsedData.Rows = new List<Dictionary<string, string>>();
+        parsedData.Rows = [];
 
         using var package = new ExcelPackage(stream);
         var worksheet = package.Workbook.Worksheets.FirstOrDefault();
@@ -114,7 +114,7 @@ private async Task<ParsedFileData> ParseXlsxAsync(Stream stream)
 
         var headerRowIndex = DetectHeaderRow(worksheet);
 
-        parsedData.Headers = new List<string>();
+        parsedData.Headers = [];
         for (var col = 1; col <= worksheet.Dimension.End.Column; col++)
         {
             var headerValue = worksheet.Cells[headerRowIndex, col].Text ?? $"Column{col}";

PhantomDave.BankTracking.Api/Services/FinanceRecordService.cs

@@ -216,7 +216,7 @@ public async Task<List<FinanceRecord>> FindDuplicatesAsync(
         var candidateKeys = CreateDuplicateKeys(candidates);
         if (candidateKeys.Count == 0)
         {
-            return new List<FinanceRecord>();
+            return [];
         }
 
         var allRecords = await _unitOfWork.FinanceRecords.Query()

PhantomDave.BankTracking.Api/Types/Inputs/AddWidgetInput.cs

@@ -0,0 +1,13 @@
+using PhantomDave.BankTracking.Library.Models;
+
+namespace PhantomDave.BankTracking.Api.Types.Inputs;
+
+public sealed class AddWidgetInput
+{
+    public int DashboardId { get; init; }
+    public WidgetType Type { get; init; }
+    public int X { get; init; }
+    public int Y { get; init; }
+    public int Rows { get; init; }
+    public int Cols { get; init; }
+}

PhantomDave.BankTracking.Api/Types/Inputs/CreateDashboardInput.cs

@@ -0,0 +1,6 @@
+namespace PhantomDave.BankTracking.Api.Types.Inputs;
+
+public sealed class CreateDashboardInput
+{
+    public string? Name { get; init; }
+}

PhantomDave.BankTracking.Api/Types/Inputs/UpdateDashboardInput.cs

@@ -0,0 +1,7 @@
+namespace PhantomDave.BankTracking.Api.Types.Inputs;
+
+public sealed class UpdateDashboardInput
+{
+    public int Id { get; init; }
+    public string? Name { get; init; }
+}

PhantomDave.BankTracking.Api/Types/Inputs/UpdateWidgetInput.cs

@@ -0,0 +1,13 @@
+using PhantomDave.BankTracking.Library.Models;
+
+namespace PhantomDave.BankTracking.Api.Types.Inputs;
+
+public sealed class UpdateWidgetInput
+{
+    public int Id { get; init; }
+    public WidgetType? Type { get; init; }
+    public int? X { get; init; }
+    public int? Y { get; init; }
+    public int? Rows { get; init; }
+    public int? Cols { get; init; }
+}

PhantomDave.BankTracking.Api/Types/Mutations/DashboardMutations.cs

@@ -0,0 +1,81 @@
+using HotChocolate;
+using HotChocolate.Types;
+using PhantomDave.BankTracking.Api.Types.Inputs;
+using PhantomDave.BankTracking.Api.Types.ObjectTypes;
+using PhantomDave.BankTracking.Data.UnitOfWork;
+using PhantomDave.BankTracking.Library.Models;
+
+namespace PhantomDave.BankTracking.Api.Types.Mutations;
+
+[ExtendObjectType(OperationTypeNames.Mutation)]
+public class DashboardMutations
+{
+    public async Task<DashboardType> CreateDashboard(
+        [Service] IUnitOfWork unitOfWork,
+        [Service] IHttpContextAccessor httpContextAccessor,
+        CreateDashboardInput input)
+    {
+        var accountId = httpContextAccessor.GetAccountIdFromContext();
+
+        var dashboard = new Dashboard
+        {
+            AccountId = accountId,
+            Name = input.Name?.Trim() ?? string.Empty
+        };
+
+        await unitOfWork.Dashboards.AddAsync(dashboard);
+        await unitOfWork.SaveChangesAsync();
+
+        return DashboardType.FromDashboard(dashboard);
+    }
+
+    public async Task<DashboardType> UpdateDashboard(
+        [Service] IUnitOfWork unitOfWork,
+        [Service] IHttpContextAccessor httpContextAccessor,
+        UpdateDashboardInput input)
+    {
+        var accountId = httpContextAccessor.GetAccountIdFromContext();
+
+        var dashboard = await unitOfWork.Dashboards.GetByIdAsync(input.Id);
+        if (dashboard == null || dashboard.AccountId != accountId)
+        {
+            throw new GraphQLException(
+                ErrorBuilder.New()
+                    .SetMessage("Dashboard not found.")
+                    .SetCode("NOT_FOUND")
+                    .Build());
+        }
+
+        if (input.Name != null)
+        {
+            dashboard.Name = input.Name.Trim();
+        }
+
+        await unitOfWork.SaveChangesAsync();
+
+        return DashboardType.FromDashboard(dashboard);
+    }
+
+    public async Task<bool> DeleteDashboard(
+        [Service] IUnitOfWork unitOfWork,
+        [Service] IHttpContextAccessor httpContextAccessor,
+        int id)
+    {
+        var accountId = httpContextAccessor.GetAccountIdFromContext();
+
+        var dashboard = await unitOfWork.Dashboards.GetByIdAsync(id);
+        if (dashboard == null || dashboard.AccountId != accountId)
+        {
+            throw new GraphQLException(
+                ErrorBuilder.New()
+                    .SetMessage("Dashboard not found.")
+                    .SetCode("NOT_FOUND")
+                    .Build());
+        }
+
+        await unitOfWork.Dashboards.DeleteAsync(id);
+        await unitOfWork.SaveChangesAsync();
+
+        return true;
+    }
+}