< Summary

Information
Class: RoleRadar.Application.Tracking.Commands.TrackerLogCommandHandler
Assembly: RoleRadar.Application
File(s): /home/runner/work/roleradar/roleradar/src/RoleRadar.Application/Tracking/Commands/TrackerLogCommandHandler.cs
Line coverage
90%
Covered lines: 217
Uncovered lines: 22
Coverable lines: 239
Total lines: 394
Line coverage: 90.7%
Branch coverage
67%
Covered branches: 63
Total branches: 94
Branch coverage: 67%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.ctor(...)50%44100%
HandleAsync()87.5%88100%
HandleCriterionRevisionAsync()47.36%463882.47%
HandleCriterionDeactivateAsync()60%212086.04%
AppendAuditAsync(...)100%11100%
HandleSearchRunAsync()66.66%272482.53%

File(s)

/home/runner/work/roleradar/roleradar/src/RoleRadar.Application/Tracking/Commands/TrackerLogCommandHandler.cs

#LineLine coverage
 1using RoleRadar.Application.Abstractions;
 2using RoleRadar.Domain.Audit;
 3using RoleRadar.Domain.Common;
 4using RoleRadar.Domain.Tracking;
 5
 6namespace RoleRadar.Application.Tracking.Commands;
 7
 8public sealed class TrackerLogCommandHandler : ICommandHandler<TrackerLogCommand, TrackerLogResultDto>
 9{
 10    private readonly ITrackingTransactionContext _context;
 11    private readonly IUtcClock _clock;
 12
 30613    public TrackerLogCommandHandler(ITrackingTransactionContext context, IUtcClock clock)
 14    {
 30615        _context = context ?? throw new ArgumentNullException(nameof(context));
 30616        _clock = clock ?? throw new ArgumentNullException(nameof(clock));
 30617    }
 18
 19    public async Task<Result<TrackerLogResultDto>> HandleAsync(TrackerLogCommand command, CancellationToken cancellation
 20    {
 11021        ArgumentNullException.ThrowIfNull(command);
 22
 11023        if (string.IsNullOrWhiteSpace(command.Action))
 24        {
 225            return Result<TrackerLogResultDto>.Failure(ErrorCode.ValidationError, "Action is required for tracker_log.")
 26        }
 27
 10828        var action = command.Action.Trim().ToLowerInvariant();
 10829        var ownerId = string.IsNullOrWhiteSpace(command.OwnerId)
 10830            ? OwnerId.Default.Value
 10831            : new OwnerId(command.OwnerId).Value;
 10832        var now = _clock.UtcNow;
 33
 10834        return action switch
 10835        {
 5036            "criterion_revision" => await HandleCriterionRevisionAsync(command, ownerId, now, cancellationToken),
 1037            "criterion_deactivate" => await HandleCriterionDeactivateAsync(command, ownerId, now, cancellationToken),
 3238            "search_run" => await HandleSearchRunAsync(command, ownerId, now, cancellationToken),
 239            _ => Result<TrackerLogResultDto>.Failure(
 240                ErrorCode.ValidationError,
 241                $"Action '{command.Action}' is not supported by tracker_log.")
 10842        };
 9643    }
 44
 45    private async Task<Result<TrackerLogResultDto>> HandleCriterionRevisionAsync(
 46        TrackerLogCommand command,
 47        string ownerId,
 48        DateTimeOffset now,
 49        CancellationToken cancellationToken)
 50    {
 5051        if (string.IsNullOrWhiteSpace(command.Key))
 52        {
 253            return Result<TrackerLogResultDto>.Failure(ErrorCode.ValidationError, "Key is required for criterion_revisio
 54        }
 55
 4856        var key = command.Key.Trim();
 57
 4858        if (string.IsNullOrWhiteSpace(command.Category) ||
 4859            !TrackingEnumExtensions.TryParseCriterionCategory(command.Category, out var category))
 60        {
 261            return Result<TrackerLogResultDto>.Failure(
 262                ErrorCode.ValidationError,
 263                "Category is required for criterion_revision ('hard_skip', 'weight', 'preference').");
 64        }
 65
 4666        if (string.IsNullOrWhiteSpace(command.Value))
 67        {
 268            return Result<TrackerLogResultDto>.Failure(ErrorCode.ValidationError, "Value is required for criterion_revis
 69        }
 70
 4471        if (string.IsNullOrWhiteSpace(command.Provenance) ||
 4472            !TrackingEnumExtensions.TryParseProvenanceKind(command.Provenance, out var provenance))
 73        {
 274            return Result<TrackerLogResultDto>.Failure(
 275                ErrorCode.ValidationError,
 276                "Provenance is required for criterion_revision ('stated', 'inferred').");
 77        }
 78
 4279        if (string.IsNullOrWhiteSpace(command.EffectiveFrom) ||
 4280            !DateTimeOffset.TryParse(command.EffectiveFrom, System.Globalization.CultureInfo.InvariantCulture, out var e
 81        {
 282            return Result<TrackerLogResultDto>.Failure(
 283                ErrorCode.ValidationError,
 284                "EffectiveFrom timestamp is required for criterion_revision (ISO 8601).");
 85        }
 86
 4087        var activeRes = await _context.Criteria.GetActiveByKeyAsync(ownerId, key, cancellationToken);
 4088        if (!activeRes.IsSuccess)
 89        {
 090            return Result<TrackerLogResultDto>.Failure(activeRes.Error ?? new ResultError(ErrorCode.ValidationError, "Fa
 91        }
 92
 4093        var currentActive = activeRes.Value;
 94
 4095        if (currentActive is null)
 96        {
 97            // Initial version creation: insert active version
 98            Criterion newCriterion;
 99            try
 100            {
 12101                newCriterion = Criterion.Create(
 12102                    ownerId: ownerId,
 12103                    key: key,
 12104                    category: category,
 12105                    value: command.Value,
 12106                    provenance: provenance,
 12107                    effectiveFrom: effectiveFrom,
 12108                    createdAt: now);
 12109            }
 0110            catch (ArgumentException ex)
 111            {
 0112                return Result<TrackerLogResultDto>.Failure(ErrorCode.ValidationError, ex.Message);
 113            }
 114
 12115            var upsertRes = await _context.Criteria.UpsertCriterionAsync(newCriterion, cancellationToken);
 12116            if (!upsertRes.IsSuccess)
 117            {
 0118                return Result<TrackerLogResultDto>.Failure(upsertRes.Error ?? new ResultError(ErrorCode.ValidationError,
 119            }
 120
 12121            var auditSummary = new CriterionAuditSummary(
 12122                CriterionId: newCriterion.Id,
 12123                Key: newCriterion.Key,
 12124                Action: AuditOperation.CriterionRevision,
 12125                Timestamp: now);
 126
 12127            await AppendAuditAsync(
 12128                ownerId,
 12129                "system",
 12130                AuditOperation.CriterionRevision,
 12131                newCriterion.Id,
 12132                newCriterion.VersionToken,
 12133                auditSummary,
 12134                cancellationToken);
 135
 12136            return Result<TrackerLogResultDto>.Success(new TrackerLogResultDto(
 12137                Action: "criterion_revision",
 12138                RecordId: newCriterion.Id,
 12139                Status: "success",
 12140                UpdatedAtUtc: now,
 12141                VersionToken: newCriterion.VersionToken));
 142        }
 143
 144        // Active version exists: version token is mandatory
 28145        if (!command.VersionToken.HasValue || command.VersionToken.Value != currentActive.VersionToken)
 146        {
 18147            return Result<TrackerLogResultDto>.Failure(
 18148                ErrorCode.StaleVersionToken,
 18149                "Active criterion version token mismatch or missing.");
 150        }
 151
 152        Criterion replacement;
 153        try
 154        {
 10155            replacement = currentActive.Supersede(
 10156                newCategory: category,
 10157                newValue: command.Value,
 10158                newProvenance: provenance,
 10159                newEffectiveFrom: effectiveFrom,
 10160                now: now);
 8161        }
 2162        catch (ArgumentException ex)
 163        {
 2164            return Result<TrackerLogResultDto>.Failure(ErrorCode.ValidationError, ex.Message);
 165        }
 166
 167        // Persist both closed previous version and new active replacement
 8168        var closeOldRes = await _context.Criteria.UpsertCriterionAsync(currentActive, cancellationToken);
 8169        if (!closeOldRes.IsSuccess)
 170        {
 0171            return Result<TrackerLogResultDto>.Failure(closeOldRes.Error ?? new ResultError(ErrorCode.ValidationError, "
 172        }
 173
 8174        var saveNewRes = await _context.Criteria.UpsertCriterionAsync(replacement, cancellationToken);
 8175        if (!saveNewRes.IsSuccess)
 176        {
 0177            return Result<TrackerLogResultDto>.Failure(saveNewRes.Error ?? new ResultError(ErrorCode.ValidationError, "F
 178        }
 179
 8180        var revisionAuditSummary = new CriterionAuditSummary(
 8181            CriterionId: replacement.Id,
 8182            Key: replacement.Key,
 8183            Action: "criterion_revision",
 8184            Timestamp: now);
 185
 8186        await AppendAuditAsync(
 8187            ownerId,
 8188            "system",
 8189            AuditOperation.CriterionRevision,
 8190            replacement.Id,
 8191            replacement.VersionToken,
 8192            revisionAuditSummary,
 8193            cancellationToken);
 194
 8195        return Result<TrackerLogResultDto>.Success(new TrackerLogResultDto(
 8196            Action: "criterion_revision",
 8197            RecordId: replacement.Id,
 8198            Status: "success",
 8199            UpdatedAtUtc: now,
 8200            VersionToken: replacement.VersionToken));
 50201    }
 202
 203    private async Task<Result<TrackerLogResultDto>> HandleCriterionDeactivateAsync(
 204        TrackerLogCommand command,
 205        string ownerId,
 206        DateTimeOffset now,
 207        CancellationToken cancellationToken)
 208    {
 10209        if (string.IsNullOrWhiteSpace(command.Key))
 210        {
 2211            return Result<TrackerLogResultDto>.Failure(ErrorCode.ValidationError, "Key is required for criterion_deactiv
 212        }
 213
 8214        var key = command.Key.Trim();
 215
 8216        var activeRes = await _context.Criteria.GetActiveByKeyAsync(ownerId, key, cancellationToken);
 8217        if (!activeRes.IsSuccess)
 218        {
 0219            return Result<TrackerLogResultDto>.Failure(activeRes.Error ?? new ResultError(ErrorCode.ValidationError, "Fa
 220        }
 221
 8222        var currentActive = activeRes.Value;
 8223        if (currentActive is null)
 224        {
 0225            return Result<TrackerLogResultDto>.Failure(
 0226                ErrorCode.NotFound,
 0227                $"No active criterion found for key '{key}'.");
 228        }
 229
 8230        if (!command.VersionToken.HasValue || command.VersionToken.Value != currentActive.VersionToken)
 231        {
 2232            return Result<TrackerLogResultDto>.Failure(
 2233                ErrorCode.StaleVersionToken,
 2234                "Active criterion version token mismatch or missing.");
 235        }
 236
 6237        DateTimeOffset deactivationDate = now;
 6238        if (!string.IsNullOrWhiteSpace(command.EffectiveFrom) &&
 6239            DateTimeOffset.TryParse(command.EffectiveFrom, System.Globalization.CultureInfo.InvariantCulture, out var pa
 240        {
 2241            deactivationDate = parsedDeactDate;
 242        }
 243
 6244        currentActive.Deactivate(deactivationDate);
 245
 6246        var upsertRes = await _context.Criteria.UpsertCriterionAsync(currentActive, cancellationToken);
 6247        if (!upsertRes.IsSuccess)
 248        {
 0249            return Result<TrackerLogResultDto>.Failure(upsertRes.Error ?? new ResultError(ErrorCode.ValidationError, "Fa
 250        }
 251
 6252        var auditSummary = new CriterionAuditSummary(
 6253            CriterionId: currentActive.Id,
 6254            Key: currentActive.Key,
 6255            Action: "criterion_deactivate",
 6256            Timestamp: now);
 257
 6258        await AppendAuditAsync(
 6259            ownerId,
 6260            "system",
 6261            AuditOperation.CriterionDeactivate,
 6262            currentActive.Id,
 6263            currentActive.VersionToken,
 6264            auditSummary,
 6265            cancellationToken);
 266
 6267        return Result<TrackerLogResultDto>.Success(new TrackerLogResultDto(
 6268            Action: "criterion_deactivate",
 6269            RecordId: currentActive.Id,
 6270            Status: "success",
 6271            UpdatedAtUtc: now,
 6272            VersionToken: currentActive.VersionToken));
 10273    }
 274
 275    private Task AppendAuditAsync(
 276        string ownerId,
 277        string actor,
 278        string operation,
 279        Guid criterionId,
 280        Guid versionToken,
 281        CriterionAuditSummary summary,
 282        CancellationToken cancellationToken)
 283    {
 26284        var details = AuditDetails.ForEntity(
 26285            changedFields: [summary.Key, summary.Action],
 26286            before: null,
 26287            after: new Dictionary<string, object?> { ["key"] = summary.Key, ["action"] = summary.Action });
 288
 26289        var entry = AuditLogEntry.CreateForTracking(
 26290            ownerId: ownerId,
 26291            actor: actor,
 26292            operation: operation,
 26293            entityType: "criterion",
 26294            entityId: criterionId,
 26295            resultingVersionToken: versionToken,
 26296            occurredAtUtc: summary.Timestamp.UtcDateTime,
 26297            details: details);
 298
 26299        return _context.AppendAuditEntryAsync(entry, cancellationToken);
 300    }
 301
 302    private async Task<Result<TrackerLogResultDto>> HandleSearchRunAsync(
 303        TrackerLogCommand command,
 304        string ownerId,
 305        DateTimeOffset now,
 306        CancellationToken cancellationToken)
 307    {
 46308        if (string.IsNullOrWhiteSpace(command.StartedAt) ||
 46309            !DateTimeOffset.TryParse(command.StartedAt, System.Globalization.CultureInfo.InvariantCulture, out var start
 310        {
 4311            return Result<TrackerLogResultDto>.Failure(
 4312                ErrorCode.ValidationError,
 4313                "StartedAt is required for search_run (ISO 8601).");
 314        }
 315
 42316        if (!command.NewPostingsCount.HasValue || command.NewPostingsCount.Value < 0)
 317        {
 2318            return Result<TrackerLogResultDto>.Failure(
 2319                ErrorCode.ValidationError,
 2320                "NewPostingsCount must be >= 0.");
 321        }
 322
 40323        if (command.Notes is not null && command.Notes.Length > SearchRun.MaxNotesLength)
 324        {
 0325            return Result<TrackerLogResultDto>.Failure(
 0326                ErrorCode.ValidationError,
 0327                $"Notes cannot exceed {SearchRun.MaxNotesLength} characters.");
 328        }
 329
 40330        var startedAtUtc = startedAt.ToUniversalTime();
 331
 40332        var existingRes = await _context.SearchRuns.GetByStartedAtAsync(ownerId, startedAtUtc, cancellationToken);
 40333        if (existingRes.IsSuccess && existingRes.Value is not null)
 334        {
 16335            return Result<TrackerLogResultDto>.Success(new TrackerLogResultDto(
 16336                Action: "search_run",
 16337                RecordId: existingRes.Value.Id,
 16338                Status: "already_logged",
 16339                UpdatedAtUtc: existingRes.Value.CreatedAt));
 340        }
 341
 24342        var searchRun = SearchRun.Create(
 24343            ownerId: ownerId,
 24344            startedAt: startedAtUtc,
 24345            newPostingsCount: command.NewPostingsCount.Value,
 24346            reportNoteId: command.ReportNoteId,
 24347            notes: command.Notes,
 24348            createdAt: now);
 349
 24350        var upsertRes = await _context.SearchRuns.UpsertSearchRunAsync(searchRun, cancellationToken);
 10351        if (!upsertRes.IsSuccess)
 352        {
 0353            var raceExisting = await _context.SearchRuns.GetByStartedAtAsync(ownerId, startedAtUtc, cancellationToken);
 0354            if (raceExisting.IsSuccess && raceExisting.Value is not null)
 355            {
 0356                return Result<TrackerLogResultDto>.Success(new TrackerLogResultDto(
 0357                    Action: "search_run",
 0358                    RecordId: raceExisting.Value.Id,
 0359                    Status: "already_logged",
 0360                    UpdatedAtUtc: raceExisting.Value.CreatedAt));
 361            }
 362
 0363            return Result<TrackerLogResultDto>.Failure(upsertRes.Error ?? new ResultError(ErrorCode.ValidationError, "Fa
 364        }
 365
 10366        var details = AuditDetails.ForEntity(
 10367            changedFields: ["started_at", "new_postings_count"],
 10368            before: null,
 10369            after: new Dictionary<string, object?>
 10370            {
 10371                ["started_at"] = startedAtUtc.ToString("O"),
 10372                ["new_postings_count"] = searchRun.NewPostingsCount,
 10373                ["notes"] = searchRun.Notes
 10374            });
 375
 10376        var auditEntry = AuditLogEntry.CreateForTracking(
 10377            ownerId: ownerId,
 10378            actor: "mcp-user",
 10379            operation: AuditOperation.SearchRunLog,
 10380            entityType: "search_run",
 10381            entityId: searchRun.Id,
 10382            resultingVersionToken: searchRun.Id,
 10383            occurredAtUtc: now.UtcDateTime,
 10384            details: details);
 385
 10386        await _context.AppendAuditEntryAsync(auditEntry, cancellationToken);
 387
 10388        return Result<TrackerLogResultDto>.Success(new TrackerLogResultDto(
 10389            Action: "search_run",
 10390            RecordId: searchRun.Id,
 10391            Status: "success",
 10392            UpdatedAtUtc: searchRun.CreatedAt));
 32393    }
 394}