< Summary

Information
Class: RoleRadar.Application.Notes.Commands.AppendToNoteCommandHandler
Assembly: RoleRadar.Application
File(s): /home/runner/work/roleradar/roleradar/src/RoleRadar.Application/Notes/Commands/AppendToNoteCommand.cs
Line coverage
100%
Covered lines: 29
Uncovered lines: 0
Coverable lines: 29
Total lines: 105
Line coverage: 100%
Branch coverage
83%
Covered branches: 5
Total branches: 6
Branch coverage: 83.3%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.cctor()100%11100%
.ctor(...)100%11100%
HandleAsync()83.33%66100%

File(s)

/home/runner/work/roleradar/roleradar/src/RoleRadar.Application/Notes/Commands/AppendToNoteCommand.cs

#LineLine coverage
 1using System.Text;
 2using RoleRadar.Application.Abstractions;
 3using RoleRadar.Domain.Common;
 4using RoleRadar.Domain.Notes;
 5
 6namespace RoleRadar.Application.Notes.Commands;
 7
 8public sealed record NoteUpdatedDto(
 9    Guid Id,
 10    Guid VersionToken,
 11    string BodyHash,
 12    int ByteLength,
 13    DateTime UpdatedAtUtc);
 14
 15public sealed record AppendToNoteCommand(
 16    Guid Id,
 17    string TextToAppend,
 18    string Actor,
 19    string? OwnerId = null) : ICommand<NoteUpdatedDto>;
 20
 21public sealed class AppendToNoteCommandValidator : ICommandValidator<AppendToNoteCommand>
 22{
 23    public ResultError? Validate(AppendToNoteCommand command)
 24    {
 25        ArgumentNullException.ThrowIfNull(command);
 26
 27        var actorError = CommandActor.Validate(command.Actor);
 28        if (actorError is not null)
 29        {
 30            return actorError;
 31        }
 32
 33        if (command.Id == Guid.Empty)
 34        {
 35            return new ResultError(ErrorCode.ValidationError, "Note ID cannot be Guid.Empty.");
 36        }
 37
 38        if (string.IsNullOrEmpty(command.TextToAppend))
 39        {
 40            return new ResultError(ErrorCode.ValidationError, "TextToAppend cannot be empty.");
 41        }
 42
 43        var appendBytes = Encoding.UTF8.GetByteCount(command.TextToAppend);
 44        if (appendBytes > Note.MaxBodyBytes)
 45        {
 46            return new ResultError(
 47                ErrorCode.ValidationError,
 48                $"TextToAppend UTF-8 size ({appendBytes} bytes) exceeds maximum allowed ({Note.MaxBodyBytes} bytes / 8 M
 49        }
 50
 51        return null;
 52    }
 53}
 54
 55public sealed class AppendToNoteCommandHandler : ICommandHandler<AppendToNoteCommand, NoteUpdatedDto>
 56{
 457    private static readonly AppendToNoteCommandValidator Validator = new();
 58    private readonly INoteRepository _repository;
 59    private readonly IUtcClock _clock;
 60
 11661    public AppendToNoteCommandHandler(INoteRepository repository, IUtcClock clock)
 62    {
 11663        ArgumentNullException.ThrowIfNull(repository);
 11664        ArgumentNullException.ThrowIfNull(clock);
 11665        _repository = repository;
 11666        _clock = clock;
 11667    }
 68
 69    public async Task<Result<NoteUpdatedDto>> HandleAsync(
 70        AppendToNoteCommand command,
 71        CancellationToken cancellationToken = default)
 72    {
 1873        ArgumentNullException.ThrowIfNull(command);
 74
 1875        var validationError = Validator.Validate(command);
 1876        if (validationError is not null)
 77        {
 278            return Result<NoteUpdatedDto>.Failure(validationError.Value);
 79        }
 80
 1681        var ownerId = string.IsNullOrWhiteSpace(command.OwnerId)
 1682            ? OwnerId.Default.Value
 1683            : new OwnerId(command.OwnerId).Value;
 84
 1685        var actor = command.Actor.Trim();
 1686        var now = _clock.UtcNow;
 87
 1688        var outcome = await _repository.ExecuteInTransactionAsync(
 1689            (tx, ct) => tx.AppendAsync(ownerId, command.Id, command.TextToAppend, actor, now, ct),
 1690            cancellationToken);
 91
 1692        if (!outcome.IsSuccess)
 93        {
 494            return Result<NoteUpdatedDto>.Failure(outcome.Error!.Value);
 95        }
 96
 1297        var updated = outcome.Value!.Note;
 1298        return Result<NoteUpdatedDto>.Success(new NoteUpdatedDto(
 1299            Id: updated.Id,
 12100            VersionToken: updated.VersionToken,
 12101            BodyHash: updated.CurrentBodyHash,
 12102            ByteLength: Encoding.UTF8.GetByteCount(updated.Body),
 12103            UpdatedAtUtc: updated.UpdatedAtUtc));
 18104    }
 105}