Added classes for CRD and chart

src/Infrastructure/Services/Mediator/ServiceProviderExtensions.cs

@@ -8,7 +8,7 @@ public static async Task<TResult> HandleBy<THandler, TRequest, TResult>(
         this IServiceProvider serviceProvider,
         TRequest request,
         CancellationToken cancellationToken = default)
-        where THandler : Infrastructure.Services.Mediator.IRequestHandler<TRequest, TResult>
+        where THandler : IRequestHandler<TRequest, TResult>
     {
         var handler = serviceProvider.GetRequiredService<THandler>();
         return await handler.Handle(request, cancellationToken);

src/Web.Api.Tests/Features/Currencies/CreateCurrenciesCollection/CreateCurrenciesCollectionHandlerTests.cs

@@ -0,0 +1,143 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Domain.Entities.Salaries;
+using Domain.Validation.Exceptions;
+using Microsoft.EntityFrameworkCore;
+using TestUtils.Db;
+using TestUtils.Fakes;
+using Web.Api.Features.Currencies.CreateCurrenciesCollection;
+using Xunit;
+
+namespace Web.Api.Tests.Features.Currencies.CreateCurrenciesCollection;
+
+public class CreateCurrenciesCollectionHandlerTests
+{
+    [Fact]
+    public async Task Handle_NoExistingRecordForDate_ValidData_CreatesNewRecord()
+    {
+        // Arrange
+        await using var context = new InMemoryDatabaseContext();
+        var handler = new CreateCurrenciesCollectionHandler(context);
+
+        var currencyDate = new DateTime(2024, 1, 15);
+        var request = new CreateCurrenciesCollectionRequest
+        {
+            CurrencyDate = currencyDate,
+            Currencies = new Dictionary<Currency, double>
+            {
+                { Currency.USD, 450.50 },
+                { Currency.EUR, 520.75 },
+                { Currency.KZT, 1.0 }
+            }
+        };
+
+        Assert.Equal(0, context.CurrencyCollections.Count());
+
+        // Act
+        var result = await handler.Handle(request, CancellationToken.None);
+
+        // Assert
+        Assert.NotNull(result);
+        Assert.Equal(currencyDate, result.CurrencyDate);
+        Assert.Equal(3, result.Currencies.Count);
+
+        var createdRecord = await context.CurrencyCollections
+            .FirstOrDefaultAsync(x => x.CurrencyDate == currencyDate);
+
+        Assert.NotNull(createdRecord);
+        Assert.Equal(currencyDate, createdRecord.CurrencyDate);
+        Assert.Equal(3, createdRecord.Currencies.Count);
+        Assert.Equal(450.50, createdRecord.Currencies[Currency.USD]);
+        Assert.Equal(520.75, createdRecord.Currencies[Currency.EUR]);
+        Assert.Equal(1.0, createdRecord.Currencies[Currency.KZT]);
+        Assert.Equal(1, context.CurrencyCollections.Count());
+    }
+
+    [Fact]
+    public async Task Handle_ExistingRecordForDate_ValidData_ThrowsBadRequestException()
+    {
+        // Arrange
+        await using var context = new InMemoryDatabaseContext();
+        var currencyDate = new DateTime(2024, 1, 15);
+
+        var existingRecord = new CurrenciesCollectionFake(currencyDate).Please(context);
+
+        var handler = new CreateCurrenciesCollectionHandler(context);
+
+        var request = new CreateCurrenciesCollectionRequest
+        {
+            CurrencyDate = currencyDate,
+            Currencies = new Dictionary<Currency, double>
+            {
+                { Currency.USD, 460.00 },
+                { Currency.EUR, 530.00 }
+            }
+        };
+
+        Assert.Equal(1, context.CurrencyCollections.Count());
+
+        // Act & Assert
+        var exception = await Assert.ThrowsAsync<BadRequestException>(() =>
+            handler.Handle(request, CancellationToken.None));
+
+        Assert.Contains("already exists", exception.Message);
+
+        var allRecords = context.CurrencyCollections.ToList();
+        Assert.Single(allRecords);
+        Assert.Equal(existingRecord.Id, allRecords[0].Id);
+    }
+
+    [Fact]
+    public async Task Handle_NoCurrencies_ThrowsBadRequestException()
+    {
+        // Arrange
+        await using var context = new InMemoryDatabaseContext();
+        var handler = new CreateCurrenciesCollectionHandler(context);
+
+        var request = new CreateCurrenciesCollectionRequest
+        {
+            CurrencyDate = new DateTime(2024, 1, 15),
+            Currencies = new Dictionary<Currency, double>()
+        };
+
+        Assert.Equal(0, context.CurrencyCollections.Count());
+
+        // Act & Assert
+        var exception = await Assert.ThrowsAsync<BadRequestException>(() =>
+            handler.Handle(request, CancellationToken.None));
+
+        Assert.Contains("at least one currency", exception.Message);
+        Assert.Equal(0, context.CurrencyCollections.Count());
+    }
+
+    [Fact]
+    public async Task Handle_FutureDate_ThrowsBadRequestException()
+    {
+        // Arrange
+        await using var context = new InMemoryDatabaseContext();
+        var handler = new CreateCurrenciesCollectionHandler(context);
+
+        var futureDate = DateTime.UtcNow.Date.AddDays(30);
+        var request = new CreateCurrenciesCollectionRequest
+        {
+            CurrencyDate = futureDate,
+            Currencies = new Dictionary<Currency, double>
+            {
+                { Currency.USD, 450.00 },
+                { Currency.EUR, 520.00 }
+            }
+        };
+
+        Assert.Equal(0, context.CurrencyCollections.Count());
+
+        // Act & Assert
+        var exception = await Assert.ThrowsAsync<BadRequestException>(() =>
+            handler.Handle(request, CancellationToken.None));
+
+        Assert.Contains("future", exception.Message, StringComparison.OrdinalIgnoreCase);
+        Assert.Equal(0, context.CurrencyCollections.Count());
+    }
+}

src/Web.Api/Features/Currencies/CreateCurrenciesCollection/CreateCurrenciesCollectionHandler.cs

@@ -0,0 +1,52 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Domain.Entities.Currencies;
+using Domain.Validation.Exceptions;
+using Infrastructure.Database;
+using Infrastructure.Services.Mediator;
+using Microsoft.EntityFrameworkCore;
+using Web.Api.Features.Currencies.Dtos;
+
+namespace Web.Api.Features.Currencies.CreateCurrenciesCollection;
+
+public class CreateCurrenciesCollectionHandler(
+    DatabaseContext context)
+    : IRequestHandler<CreateCurrenciesCollectionRequest, CurrenciesCollectionDto>
+{
+    public async Task<CurrenciesCollectionDto> Handle(
+        CreateCurrenciesCollectionRequest request,
+        CancellationToken cancellationToken)
+    {
+        if (request.Currencies == null || request.Currencies.Count == 0)
+        {
+            throw new BadRequestException("Currencies collection must have at least one currency.");
+        }
+
+        if (request.CurrencyDate > System.DateTime.UtcNow.Date)
+        {
+            throw new BadRequestException("Currency date cannot be in the future.");
+        }
+
+        var existingRecord = await context.CurrencyCollections
+            .AsNoTracking()
+            .FirstOrDefaultAsync(x => x.CurrencyDate == request.CurrencyDate, cancellationToken);
+
+        if (existingRecord != null)
+        {
+            throw new BadRequestException($"A currency collection for date {request.CurrencyDate:yyyy-MM-dd} already exists.");
+        }
+
+        var currencyContents = request.Currencies
+            .Select(x => new CurrencyContent(x.Value, x.Key, request.CurrencyDate))
+            .ToDictionary(x => x.Currency, x => x);
+
+        var entity = new CurrenciesCollection(currencyContents);
+
+        context.CurrencyCollections.Add(entity);
+        await context.TrySaveChangesAsync(cancellationToken);
+
+        return new CurrenciesCollectionDto(entity);
+    }
+}

src/Web.Api/Features/Currencies/CreateCurrenciesCollection/CreateCurrenciesCollectionRequest.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using Domain.Entities.Salaries;
+
+namespace Web.Api.Features.Currencies.CreateCurrenciesCollection;
+
+public record CreateCurrenciesCollectionRequest
+{
+    [Required]
+    public Dictionary<Currency, double> Currencies { get; init; }
+
+    [Required]
+    public DateTime CurrencyDate { get; init; }
+}

src/Web.Api/Features/Currencies/CurrenciesCollectionController.cs

@@ -0,0 +1,71 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using Domain.Enums;
+using Domain.ValueObjects.Pagination;
+using Infrastructure.Services.Mediator;
+using Microsoft.AspNetCore.Mvc;
+using Web.Api.Features.Currencies.CreateCurrenciesCollection;
+using Web.Api.Features.Currencies.DeleteCurrenciesCollection;
+using Web.Api.Features.Currencies.Dtos;
+using Web.Api.Features.Currencies.GetCurrenciesChartData;
+using Web.Api.Features.Currencies.GetCurrenciesCollection;
+using Web.Api.Setup.Attributes;
+
+namespace Web.Api.Features.Currencies;
+
+[ApiController]
+[Route("api/currencies")]
+public class CurrenciesCollectionController : ControllerBase
+{
+    private readonly IServiceProvider _serviceProvider;
+
+    public CurrenciesCollectionController(
+        IServiceProvider serviceProvider)
+    {
+        _serviceProvider = serviceProvider;
+    }
+
+    [HttpGet("chart")]
+    public Task<GetCurrenciesChartDataResponse> GetChartData(
+        [FromQuery] GetCurrenciesChartDataQueryParams queryParams,
+        CancellationToken cancellationToken)
+    {
+        return _serviceProvider.HandleBy<GetCurrenciesChartDataHandler, GetCurrenciesChartDataQueryParams, GetCurrenciesChartDataResponse>(
+            queryParams ?? new GetCurrenciesChartDataQueryParams(),
+            cancellationToken);
+    }
+
+    [HttpGet("")]
+    [HasAnyRole(Role.Admin)]
+    public Task<Pageable<CurrenciesCollectionDto>> GetAll(
+        [FromQuery] GetCurrenciesCollectionQueryParams queryParams,
+        CancellationToken cancellationToken)
+    {
+        return _serviceProvider.HandleBy<GetCurrenciesCollectionHandler, GetCurrenciesCollectionQueryParams, Pageable<CurrenciesCollectionDto>>(
+            queryParams ?? new GetCurrenciesCollectionQueryParams(),
+            cancellationToken);
+    }
+
+    [HttpPost("")]
+    [HasAnyRole(Role.Admin)]
+    public Task<CurrenciesCollectionDto> Create(
+        [FromBody] CreateCurrenciesCollectionRequest request,
+        CancellationToken cancellationToken)
+    {
+        return _serviceProvider.HandleBy<CreateCurrenciesCollectionHandler, CreateCurrenciesCollectionRequest, CurrenciesCollectionDto>(
+            request,
+            cancellationToken);
+    }
+
+    [HttpDelete("{id:guid}")]
+    [HasAnyRole(Role.Admin)]
+    public Task<bool> Delete(
+        [FromRoute] Guid id,
+        CancellationToken cancellationToken)
+    {
+        return _serviceProvider.HandleBy<DeleteCurrenciesCollectionHandler, DeleteCurrenciesCollectionRequest, bool>(
+            new DeleteCurrenciesCollectionRequest { Id = id },
+            cancellationToken);
+    }
+}

src/Web.Api/Features/Currencies/DeleteCurrenciesCollection/DeleteCurrenciesCollectionHandler.cs

@@ -0,0 +1,30 @@
+using System.Threading;
+using System.Threading.Tasks;
+using Infrastructure.Database;
+using Infrastructure.Services.Mediator;
+
+namespace Web.Api.Features.Currencies.DeleteCurrenciesCollection;
+
+public class DeleteCurrenciesCollectionHandler
+    : IRequestHandler<DeleteCurrenciesCollectionRequest, bool>
+{
+    private readonly DatabaseContext _context;
+
+    public DeleteCurrenciesCollectionHandler(DatabaseContext context)
+    {
+        _context = context;
+    }
+
+    public async Task<bool> Handle(
+        DeleteCurrenciesCollectionRequest request,
+        CancellationToken cancellationToken)
+    {
+        var entity = await _context.CurrencyCollections
+            .ByIdOrFailAsync(request.Id, cancellationToken: cancellationToken);
+
+        _context.CurrencyCollections.Remove(entity);
+        await _context.TrySaveChangesAsync(cancellationToken);
+
+        return true;
+    }
+}

src/Web.Api/Features/Currencies/DeleteCurrenciesCollection/DeleteCurrenciesCollectionRequest.cs

@@ -0,0 +1,8 @@
+using System;
+
+namespace Web.Api.Features.Currencies.DeleteCurrenciesCollection;
+
+public record DeleteCurrenciesCollectionRequest
+{
+    public Guid Id { get; init; }
+}

src/Web.Api/Features/Currencies/Dtos/CurrenciesCollectionDto.cs

@@ -0,0 +1,38 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Domain.Entities.Currencies;
+
+namespace Web.Api.Features.Currencies.Dtos;
+
+public record CurrenciesCollectionDto
+{
+    public Guid Id { get; init; }
+
+    public List<CurrencyItemDto> Currencies { get; init; }
+
+    public DateTime CurrencyDate { get; init; }
+
+    public DateTimeOffset CreatedAt { get; init; }
+
+    public DateTimeOffset UpdatedAt { get; init; }
+
+    public CurrenciesCollectionDto()
+    {
+    }
+
+    public CurrenciesCollectionDto(CurrenciesCollection entity)
+    {
+        Id = entity.Id;
+        CurrencyDate = entity.CurrencyDate;
+        CreatedAt = entity.CreatedAt;
+        UpdatedAt = entity.UpdatedAt;
+        Currencies = entity.Currencies
+            .Select(x => new CurrencyItemDto
+            {
+                Currency = x.Key,
+                Value = x.Value,
+            })
+            .ToList();
+    }
+}

src/Web.Api/Features/Currencies/Dtos/CurrencyItemDto.cs

@@ -0,0 +1,10 @@
+using Domain.Entities.Salaries;
+
+namespace Web.Api.Features.Currencies.Dtos;
+
+public record CurrencyItemDto
+{
+    public Currency Currency { get; init; }
+
+    public double Value { get; init; }
+}