< Summary

Information
Class: RoleRadar.Application.Notes.Commands.CreateNoteCommandValidator
Assembly: RoleRadar.Application
File(s): /home/runner/work/roleradar/roleradar/src/RoleRadar.Application/Notes/Commands/CreateNoteCommand.cs
Line coverage
85%
Covered lines: 41
Uncovered lines: 7
Coverable lines: 48
Total lines: 211
Line coverage: 85.4%
Branch coverage
82%
Covered branches: 23
Total branches: 28
Branch coverage: 82.1%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
Validate(...)82.14%302885.41%

File(s)

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

#LineLine coverage
 1using System.Text;
 2using System.Text.Json.Serialization;
 3using RoleRadar.Application.Abstractions;
 4using RoleRadar.Domain.Audit;
 5using RoleRadar.Domain.Common;
 6using RoleRadar.Domain.Notes;
 7
 8namespace RoleRadar.Application.Notes.Commands;
 9
 10public sealed record ProvenanceDto(
 11    string Kind,
 12    string Date,
 13    [property: JsonIgnore(Condition = JsonIgnoreCondition.Never)] string? Qualifier);
 14
 15public sealed record NoteCreatedDto(
 16    Guid Id,
 17    string Title,
 18    string Area,
 19    IReadOnlyList<string> Tags,
 20    ProvenanceDto Provenance,
 21    string Status,
 22    Guid VersionToken,
 23    string BodyHash,
 24    DateTime CreatedAtUtc,
 25    DateTime UpdatedAtUtc);
 26
 27public sealed record CreateNoteCommand(
 28    string Title,
 29    string Body,
 30    string Area,
 31    IReadOnlyList<string>? Tags,
 32    string ProvenanceKind,
 33    string ProvenanceDate,
 34    string? ProvenanceQualifier,
 35    string Actor,
 36    string? OwnerId = null) : ICommand<NoteCreatedDto>;
 37
 38public sealed class CreateNoteCommandValidator : ICommandValidator<CreateNoteCommand>
 39{
 40    public ResultError? Validate(CreateNoteCommand command)
 41    {
 22842        ArgumentNullException.ThrowIfNull(command);
 43
 22844        var actorError = CommandActor.Validate(command.Actor);
 22845        if (actorError is not null)
 46        {
 447            return actorError;
 48        }
 49
 22450        if (string.IsNullOrWhiteSpace(command.Title))
 51        {
 052            return new ResultError(ErrorCode.ValidationError, "Note title is required and cannot be blank.");
 53        }
 54
 22455        var trimmedTitleLength = command.Title.Trim().Length;
 22456        if (trimmedTitleLength > Note.MaxTitleChars)
 57        {
 258            return new ResultError(
 259                ErrorCode.ValidationError,
 260                $"Note title length ({trimmedTitleLength} characters) exceeds maximum allowed ({Note.MaxTitleChars} char
 61        }
 62
 22263        if (command.Body is null)
 64        {
 065            return new ResultError(ErrorCode.ValidationError, "Note body is required.");
 66        }
 67
 22268        var bodyByteCount = Encoding.UTF8.GetByteCount(command.Body);
 22269        if (bodyByteCount > Note.MaxBodyBytes)
 70        {
 471            return new ResultError(
 472                ErrorCode.ValidationError,
 473                $"Note body UTF-8 size ({bodyByteCount} bytes) exceeds maximum allowed ({Note.MaxBodyBytes} bytes / 8 Mi
 74        }
 75
 21876        if (string.IsNullOrWhiteSpace(command.Area))
 77        {
 078            return new ResultError(ErrorCode.ValidationError, "Note area is required and cannot be blank.");
 79        }
 80
 21881        var trimmedAreaLength = command.Area.Trim().Length;
 21882        if (trimmedAreaLength > Note.MaxAreaChars)
 83        {
 284            return new ResultError(
 285                ErrorCode.ValidationError,
 286                $"Note area length ({trimmedAreaLength} characters) exceeds maximum allowed ({Note.MaxAreaChars} charact
 87        }
 88
 21689        if (command.Tags is not null)
 90        {
 20691            if (command.Tags.Count > Note.MaxTagCount)
 92            {
 293                return new ResultError(
 294                    ErrorCode.ValidationError,
 295                    $"Tag count ({command.Tags.Count}) exceeds maximum allowed ({Note.MaxTagCount} tags).");
 96            }
 97
 127098            foreach (var rawTag in command.Tags)
 99            {
 432100                if (string.IsNullOrWhiteSpace(rawTag))
 101                {
 0102                    return new ResultError(ErrorCode.ValidationError, "Tag values cannot be blank or whitespace.");
 103                }
 104
 432105                var trimmedTagLength = rawTag.Trim().Length;
 432106                if (trimmedTagLength > Note.MaxTagChars)
 107                {
 2108                    return new ResultError(
 2109                        ErrorCode.ValidationError,
 2110                        $"Tag length ({trimmedTagLength} characters) exceeds maximum allowed ({Note.MaxTagChars} charact
 111                }
 112            }
 113        }
 114
 212115        if (!ProvenanceKindExtensions.TryParseWireString(command.ProvenanceKind, out _))
 116        {
 0117            return new ResultError(
 0118                ErrorCode.ValidationError,
 0119                $"Invalid provenance kind '{command.ProvenanceKind}'. Expected 'stated', 'researched', or 'inferred'.");
 120        }
 121
 212122        if (!ProvenanceMarker.IsValidIsoDate(command.ProvenanceDate))
 123        {
 2124            return new ResultError(
 2125                ErrorCode.ValidationError,
 2126                $"Invalid provenance date '{command.ProvenanceDate}'. Expected ISO-8601 date 'YYYY-MM-DD'.");
 127        }
 128
 210129        return null;
 2130    }
 131}
 132
 133public sealed class CreateNoteCommandHandler : ICommandHandler<CreateNoteCommand, NoteCreatedDto>
 134{
 135    private static readonly CreateNoteCommandValidator Validator = new();
 136    private readonly INoteRepository _repository;
 137    private readonly IUtcClock _clock;
 138
 139    public CreateNoteCommandHandler(INoteRepository repository, IUtcClock clock)
 140    {
 141        ArgumentNullException.ThrowIfNull(repository);
 142        ArgumentNullException.ThrowIfNull(clock);
 143        _repository = repository;
 144        _clock = clock;
 145    }
 146
 147    public async Task<Result<NoteCreatedDto>> HandleAsync(
 148        CreateNoteCommand command,
 149        CancellationToken cancellationToken = default)
 150    {
 151        ArgumentNullException.ThrowIfNull(command);
 152
 153        var validationError = Validator.Validate(command);
 154        if (validationError is not null)
 155        {
 156            return Result<NoteCreatedDto>.Failure(validationError.Value);
 157        }
 158
 159        var ownerId = string.IsNullOrWhiteSpace(command.OwnerId)
 160            ? OwnerId.Default.Value
 161            : new OwnerId(command.OwnerId).Value;
 162
 163        var actor = command.Actor.Trim();
 164        var now = _clock.UtcNow;
 165
 166        var provKind = ProvenanceKindExtensions.FromWireString(command.ProvenanceKind);
 167        var provenance = new ProvenanceMarker(provKind, command.ProvenanceDate, command.ProvenanceQualifier);
 168
 169        var note = Note.Create(
 170            ownerId: ownerId,
 171            title: command.Title,
 172            body: command.Body,
 173            tags: command.Tags,
 174            area: command.Area,
 175            provenance: provenance,
 176            createdAtUtc: now);
 177
 178        var audit = AuditLogEntry.CreateForCreate(
 179            ownerId: ownerId,
 180            actor: actor,
 181            targetNoteId: note.Id,
 182            resultingVersionToken: note.VersionToken,
 183            occurredAtUtc: now,
 184            afterSummary: AuditContentSummary.FromNote(note));
 185
 186        var outcome = await _repository.ExecuteInTransactionAsync(
 187            (tx, ct) => tx.CreateAsync(note, audit, ct),
 188            cancellationToken);
 189
 190        if (!outcome.IsSuccess)
 191        {
 192            return Result<NoteCreatedDto>.Failure(outcome.Error!.Value);
 193        }
 194
 195        var saved = outcome.Value!.Note;
 196        return Result<NoteCreatedDto>.Success(new NoteCreatedDto(
 197            Id: saved.Id,
 198            Title: saved.Title,
 199            Area: saved.Area,
 200            Tags: saved.Tags,
 201            Provenance: new ProvenanceDto(
 202                saved.Provenance.Kind.ToWireString(),
 203                saved.Provenance.Date,
 204                saved.Provenance.Qualifier),
 205            Status: saved.Status.ToWireString(),
 206            VersionToken: saved.VersionToken,
 207            BodyHash: saved.CurrentBodyHash,
 208            CreatedAtUtc: saved.CreatedAtUtc,
 209            UpdatedAtUtc: saved.UpdatedAtUtc));
 210    }
 211}