< Summary

Information
Class: RoleRadar.Application.Notes.Commands.NoteCreatedDto
Assembly: RoleRadar.Application
File(s): /home/runner/work/roleradar/roleradar/src/RoleRadar.Application/Notes/Commands/CreateNoteCommand.cs
Line coverage
100%
Covered lines: 11
Uncovered lines: 0
Coverable lines: 11
Total lines: 211
Line coverage: 100%
Branch coverage
N/A
Covered branches: 0
Total branches: 0
Branch coverage: N/A
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.ctor(...)100%11100%
get_Id()100%11100%
get_Title()100%11100%
get_Area()100%11100%
get_Tags()100%11100%
get_Provenance()100%11100%
get_Status()100%11100%
get_VersionToken()100%11100%
get_BodyHash()100%11100%
get_CreatedAtUtc()100%11100%
get_UpdatedAtUtc()100%11100%

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
 11815public sealed record NoteCreatedDto(
 13416    Guid Id,
 1017    string Title,
 818    string Area,
 819    IReadOnlyList<string> Tags,
 1220    ProvenanceDto Provenance,
 821    string Status,
 2022    Guid VersionToken,
 623    string BodyHash,
 624    DateTime CreatedAtUtc,
 12425    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    {
 42        ArgumentNullException.ThrowIfNull(command);
 43
 44        var actorError = CommandActor.Validate(command.Actor);
 45        if (actorError is not null)
 46        {
 47            return actorError;
 48        }
 49
 50        if (string.IsNullOrWhiteSpace(command.Title))
 51        {
 52            return new ResultError(ErrorCode.ValidationError, "Note title is required and cannot be blank.");
 53        }
 54
 55        var trimmedTitleLength = command.Title.Trim().Length;
 56        if (trimmedTitleLength > Note.MaxTitleChars)
 57        {
 58            return new ResultError(
 59                ErrorCode.ValidationError,
 60                $"Note title length ({trimmedTitleLength} characters) exceeds maximum allowed ({Note.MaxTitleChars} char
 61        }
 62
 63        if (command.Body is null)
 64        {
 65            return new ResultError(ErrorCode.ValidationError, "Note body is required.");
 66        }
 67
 68        var bodyByteCount = Encoding.UTF8.GetByteCount(command.Body);
 69        if (bodyByteCount > Note.MaxBodyBytes)
 70        {
 71            return new ResultError(
 72                ErrorCode.ValidationError,
 73                $"Note body UTF-8 size ({bodyByteCount} bytes) exceeds maximum allowed ({Note.MaxBodyBytes} bytes / 8 Mi
 74        }
 75
 76        if (string.IsNullOrWhiteSpace(command.Area))
 77        {
 78            return new ResultError(ErrorCode.ValidationError, "Note area is required and cannot be blank.");
 79        }
 80
 81        var trimmedAreaLength = command.Area.Trim().Length;
 82        if (trimmedAreaLength > Note.MaxAreaChars)
 83        {
 84            return new ResultError(
 85                ErrorCode.ValidationError,
 86                $"Note area length ({trimmedAreaLength} characters) exceeds maximum allowed ({Note.MaxAreaChars} charact
 87        }
 88
 89        if (command.Tags is not null)
 90        {
 91            if (command.Tags.Count > Note.MaxTagCount)
 92            {
 93                return new ResultError(
 94                    ErrorCode.ValidationError,
 95                    $"Tag count ({command.Tags.Count}) exceeds maximum allowed ({Note.MaxTagCount} tags).");
 96            }
 97
 98            foreach (var rawTag in command.Tags)
 99            {
 100                if (string.IsNullOrWhiteSpace(rawTag))
 101                {
 102                    return new ResultError(ErrorCode.ValidationError, "Tag values cannot be blank or whitespace.");
 103                }
 104
 105                var trimmedTagLength = rawTag.Trim().Length;
 106                if (trimmedTagLength > Note.MaxTagChars)
 107                {
 108                    return new ResultError(
 109                        ErrorCode.ValidationError,
 110                        $"Tag length ({trimmedTagLength} characters) exceeds maximum allowed ({Note.MaxTagChars} charact
 111                }
 112            }
 113        }
 114
 115        if (!ProvenanceKindExtensions.TryParseWireString(command.ProvenanceKind, out _))
 116        {
 117            return new ResultError(
 118                ErrorCode.ValidationError,
 119                $"Invalid provenance kind '{command.ProvenanceKind}'. Expected 'stated', 'researched', or 'inferred'.");
 120        }
 121
 122        if (!ProvenanceMarker.IsValidIsoDate(command.ProvenanceDate))
 123        {
 124            return new ResultError(
 125                ErrorCode.ValidationError,
 126                $"Invalid provenance date '{command.ProvenanceDate}'. Expected ISO-8601 date 'YYYY-MM-DD'.");
 127        }
 128
 129        return null;
 130    }
 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}