< Summary

Information
Class: RoleRadar.Application.Tracking.Import.Pipeline.CriteriaSeedingStep
Assembly: RoleRadar.Application
File(s): /home/runner/work/roleradar/roleradar/src/RoleRadar.Application/Tracking/Import/Pipeline/CriteriaSeedingStep.cs
Line coverage
97%
Covered lines: 93
Uncovered lines: 2
Coverable lines: 95
Total lines: 168
Line coverage: 97.8%
Branch coverage
73%
Covered branches: 19
Total branches: 26
Branch coverage: 73%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.ctor(...)50%22100%
SeedPredefinedCriteriaAsync()70%101097.91%
GetOrCreateReasonCriterionAsync()78.57%141497.67%

File(s)

/home/runner/work/roleradar/roleradar/src/RoleRadar.Application/Tracking/Import/Pipeline/CriteriaSeedingStep.cs

#LineLine coverage
 1using System.Collections.Concurrent;
 2using RoleRadar.Application.Abstractions;
 3using RoleRadar.Domain.Audit;
 4using RoleRadar.Domain.Common;
 5using RoleRadar.Domain.Tracking;
 6
 7namespace RoleRadar.Application.Tracking.Import.Pipeline;
 8
 9public sealed record CriteriaSeedingResult(int CreatedCount, int SkippedCount);
 10
 11/// <summary>
 12/// Step 0 in the tracker import pipeline: seeds predefined compensation criteria
 13/// (comp_preferred_floor, comp_high_priority_bar) idempotently with stated provenance,
 14/// and dynamically registers reason_primary criteria with inferred provenance on first use.
 15/// </summary>
 16public sealed class CriteriaSeedingStep
 17{
 18    private const string ImportActor = "cli-import-tracker";
 19    private readonly ITrackingTransactionContext _context;
 9820    private readonly ConcurrentDictionary<string, Criterion> _cache = new(StringComparer.OrdinalIgnoreCase);
 21
 9822    public CriteriaSeedingStep(ITrackingTransactionContext context)
 23    {
 9824        _context = context ?? throw new ArgumentNullException(nameof(context));
 9825    }
 26
 27    /// <summary>
 28    /// Idempotently seeds comp_preferred_floor=200000 and comp_high_priority_bar=220000
 29    /// for the given owner if they do not already exist.
 30    /// </summary>
 31    public async Task<Result<CriteriaSeedingResult>> SeedPredefinedCriteriaAsync(
 32        string ownerId,
 33        DateOnly defaultDate,
 34        CancellationToken cancellationToken = default)
 35    {
 4836        ArgumentException.ThrowIfNullOrWhiteSpace(ownerId);
 37
 4838        var createdCount = 0;
 4839        var skippedCount = 0;
 4840        var effectiveDateTime = defaultDate.ToDateTime(TimeOnly.MinValue, DateTimeKind.Utc);
 41
 4842        var seeds = new (string Key, string Value)[]
 4843        {
 4844            ("comp_preferred_floor", "200000"),
 4845            ("comp_high_priority_bar", "220000")
 4846        };
 47
 28848        foreach (var (key, value) in seeds)
 49        {
 9650            var existing = await _context.Criteria.GetActiveByKeyAsync(ownerId, key, cancellationToken);
 9651            if (existing.IsSuccess && existing.Value is not null)
 52            {
 2053                _cache[key] = existing.Value;
 2054                skippedCount++;
 2055                continue;
 56            }
 57
 7658            var criterion = Criterion.Create(
 7659                ownerId: ownerId,
 7660                key: key,
 7661                category: CriterionCategory.Preference,
 7662                value: value,
 7663                provenance: ProvenanceKind.Stated,
 7664                effectiveFrom: effectiveDateTime);
 65
 7666            var upsertResult = await _context.Criteria.UpsertCriterionAsync(criterion, cancellationToken);
 7667            if (!upsertResult.IsSuccess)
 68            {
 069                return Result<CriteriaSeedingResult>.Failure(upsertResult.Error ?? new ResultError(ErrorCode.ValidationE
 70            }
 71
 7672            var auditEntry = AuditLogEntry.CreateForTracking(
 7673                ownerId: ownerId,
 7674                actor: ImportActor,
 7675                operation: AuditOperation.ImportCriterionRevision,
 7676                entityType: "criterion",
 7677                entityId: criterion.Id,
 7678                resultingVersionToken: criterion.VersionToken,
 7679                occurredAtUtc: DateTime.UtcNow,
 7680                details: new AuditDetails(
 7681                    ChangedFields: ["key", "value", "category", "provenance"],
 7682                    After: new Dictionary<string, object?>
 7683                    {
 7684                        ["key"] = criterion.Key,
 7685                        ["value"] = criterion.Value,
 7686                        ["category"] = criterion.Category.ToString(),
 7687                        ["provenance"] = criterion.Provenance.ToString()
 7688                    }));
 89
 7690            await _context.AppendAuditEntryAsync(auditEntry, cancellationToken);
 7691            _cache[key] = criterion;
 7692            createdCount++;
 7693        }
 94
 4895        return Result<CriteriaSeedingResult>.Success(new CriteriaSeedingResult(createdCount, skippedCount));
 4896    }
 97
 98    /// <summary>
 99    /// Retrieves an existing criterion by key or registers a new criterion on first use
 100    /// with inferred provenance and HardSkip category.
 101    /// </summary>
 102    public async Task<Result<Criterion>> GetOrCreateReasonCriterionAsync(
 103        string ownerId,
 104        string reasonPrimary,
 105        DateTimeOffset effectiveDate,
 106        TrackerImportSummary? summary = null,
 107        CancellationToken cancellationToken = default)
 108    {
 104109        ArgumentException.ThrowIfNullOrWhiteSpace(ownerId);
 104110        ArgumentException.ThrowIfNullOrWhiteSpace(reasonPrimary);
 111
 104112        var rawKey = reasonPrimary.Trim();
 104113        var key = TrackerImportFieldLimiter.Limit(rawKey, TrackerImportFieldLimiter.CriteriaKeyLimit, "criteria_key", su
 104114        if (_cache.TryGetValue(key, out var cached))
 115        {
 38116            return Result<Criterion>.Success(cached);
 117        }
 118
 66119        var existing = await _context.Criteria.GetActiveByKeyAsync(ownerId, key, cancellationToken);
 66120        if (existing.IsSuccess && existing.Value is not null)
 121        {
 4122            _cache[key] = existing.Value;
 4123            return Result<Criterion>.Success(existing.Value);
 124        }
 125
 62126        var criterion = Criterion.Create(
 62127            ownerId: ownerId,
 62128            key: key,
 62129            category: CriterionCategory.HardSkip,
 62130            value: key,
 62131            provenance: ProvenanceKind.Inferred,
 62132            effectiveFrom: effectiveDate);
 133
 62134        var upsertResult = await _context.Criteria.UpsertCriterionAsync(criterion, cancellationToken);
 62135        if (!upsertResult.IsSuccess)
 136        {
 0137            return Result<Criterion>.Failure(upsertResult.Error ?? new ResultError(ErrorCode.ValidationError, "Failed to
 138        }
 139
 62140        if (summary is not null)
 141        {
 58142            summary.CriteriaCreated++;
 143        }
 144
 62145        var auditEntry = AuditLogEntry.CreateForTracking(
 62146            ownerId: ownerId,
 62147            actor: ImportActor,
 62148            operation: AuditOperation.ImportCriterionRevision,
 62149            entityType: "criterion",
 62150            entityId: criterion.Id,
 62151            resultingVersionToken: criterion.VersionToken,
 62152            occurredAtUtc: DateTime.UtcNow,
 62153            details: new AuditDetails(
 62154                ChangedFields: ["key", "value", "category", "provenance"],
 62155                After: new Dictionary<string, object?>
 62156                {
 62157                    ["key"] = criterion.Key,
 62158                    ["value"] = criterion.Value,
 62159                    ["category"] = criterion.Category.ToString(),
 62160                    ["provenance"] = criterion.Provenance.ToString()
 62161                }));
 162
 62163        await _context.AppendAuditEntryAsync(auditEntry, cancellationToken);
 62164        _cache[key] = criterion;
 165
 62166        return Result<Criterion>.Success(criterion);
 104167    }
 168}