< Summary

Information
Class: RoleRadar.Application.Tracking.Import.Pipeline.TrackerImportPipeline
Assembly: RoleRadar.Application
File(s): /home/runner/work/roleradar/roleradar/src/RoleRadar.Application/Tracking/Import/Pipeline/TrackerImportPipeline.cs
Line coverage
94%
Covered lines: 37
Uncovered lines: 2
Coverable lines: 39
Total lines: 208
Line coverage: 94.8%
Branch coverage
92%
Covered branches: 24
Total branches: 26
Branch coverage: 92.3%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.ctor(...)50%22100%
ExecuteAsync()91.66%242491.42%

File(s)

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

#LineLine coverage
 1using RoleRadar.Application.Abstractions;
 2using RoleRadar.Domain.Tracking;
 3
 4namespace RoleRadar.Application.Tracking.Import.Pipeline;
 5
 6public sealed class TrackerImportContext
 7{
 8    public required string OwnerId { get; init; }
 9    public required string BundleDirectory { get; init; }
 10    public DateOnly? DefaultDate { get; init; }
 11    public bool Apply { get; init; }
 12    public TrackerImportSummary Summary { get; } = new();
 13
 14    public Dictionary<string, string> CompanyAliases { get; } = new(StringComparer.OrdinalIgnoreCase);
 15    public Dictionary<string, Company> CanonicalCompanies { get; } = new(StringComparer.OrdinalIgnoreCase);
 16    public Dictionary<string, Posting> PostingsByUrl { get; } = new(StringComparer.OrdinalIgnoreCase);
 17    public Dictionary<string, Posting> PostingsByCompanyAndTitle { get; } = new(StringComparer.OrdinalIgnoreCase);
 18    public Dictionary<string, Posting> PostingsByCompanyAndReq { get; } = new(StringComparer.OrdinalIgnoreCase);
 19    public Dictionary<Guid, Posting> AllPostings { get; } = new();
 20    public HashSet<Guid> ClaimedPostingIds { get; } = new();
 21    public HashSet<Guid> ClaimedPostingIdsInRun { get; } = new();
 22
 23    public void IndexPosting(Posting posting, string? canonicalCompanyName)
 24    {
 25        AllPostings[posting.Id] = posting;
 26        if (!string.IsNullOrWhiteSpace(posting.OriginalUrl))
 27        {
 28            var normUrl = UrlNormalizer.Normalize(posting.OriginalUrl);
 29            if (normUrl is not null)
 30            {
 31                PostingsByUrl[normUrl] = posting;
 32            }
 33            PostingsByUrl[posting.OriginalUrl] = posting;
 34        }
 35
 36        if (!string.IsNullOrWhiteSpace(posting.RequisitionId))
 37        {
 38            PostingsByCompanyAndReq[$"{posting.CompanyId:D}|{posting.RequisitionId.Trim()}"] = posting;
 39            if (!string.IsNullOrWhiteSpace(canonicalCompanyName))
 40            {
 41                PostingsByCompanyAndReq[$"{canonicalCompanyName}|{posting.RequisitionId.Trim()}"] = posting;
 42            }
 43        }
 44
 45        if (!string.IsNullOrWhiteSpace(canonicalCompanyName) && !string.IsNullOrWhiteSpace(posting.NormalizedTitle))
 46        {
 47            PostingsByCompanyAndTitle[$"{canonicalCompanyName}|{posting.NormalizedTitle}"] = posting;
 48        }
 49    }
 50}
 51
 52public interface ITrackerImportStep
 53{
 54    Task<Result<bool>> ExecuteAsync(TrackerImportContext context, CancellationToken cancellationToken = default);
 55}
 56
 57public interface ITrackerImportPipelineFactory
 58{
 59    TrackerImportPipeline CreatePipeline(ITrackingTransactionContext context);
 60}
 61
 62public sealed class TrackerImportPipelineFactory : ITrackerImportPipelineFactory
 63{
 64    private readonly ICsvParser _csvParser;
 65    private readonly Func<int, Task>? _applicationsFaultHook;
 66
 67    public TrackerImportPipelineFactory(ICsvParser csvParser, Func<int, Task>? applicationsFaultHook = null)
 68    {
 69        _csvParser = csvParser ?? throw new ArgumentNullException(nameof(csvParser));
 70        _applicationsFaultHook = applicationsFaultHook;
 71    }
 72
 73    public TrackerImportPipeline CreatePipeline(ITrackingTransactionContext context)
 74    {
 75        ArgumentNullException.ThrowIfNull(context);
 76
 77        var criteriaStep = new CriteriaSeedingStep(context);
 78        var aliasesStep = new CompanyAliasesStep(_csvParser);
 79        var companiesStep = new WatchlistCompaniesStep(_csvParser, context);
 80        var postingsStep = new PostingsJsonStep(context, criteriaStep);
 81        var appendixStep = new AppendixRowsStep(_csvParser, context, criteriaStep);
 82        var applicationsStep = new ApplicationsStep(_csvParser, context, _applicationsFaultHook);
 83
 84        var steps = new ITrackerImportStep[]
 85        {
 86            new CriteriaSeedingPipelineStep(criteriaStep),
 87            aliasesStep,
 88            companiesStep,
 89            postingsStep,
 90            appendixStep,
 91            applicationsStep
 92        };
 93
 94        return new TrackerImportPipeline(steps, context);
 95    }
 96}
 97
 98internal sealed class CriteriaSeedingPipelineStep : ITrackerImportStep
 99{
 100    private readonly CriteriaSeedingStep _step;
 101
 102    public CriteriaSeedingPipelineStep(CriteriaSeedingStep step)
 103    {
 104        _step = step;
 105    }
 106
 107    public async Task<Result<bool>> ExecuteAsync(TrackerImportContext context, CancellationToken cancellationToken = def
 108    {
 109        // When --default-date is absent, use today's UTC date as the effective date for seeded criteria.
 110        var effectiveDate = context.DefaultDate ?? DateOnly.FromDateTime(DateTime.UtcNow);
 111
 112        var seedResult = await _step.SeedPredefinedCriteriaAsync(context.OwnerId, effectiveDate, cancellationToken);
 113        if (!seedResult.IsSuccess)
 114        {
 115            return Result<bool>.Failure(seedResult.Error!.Value);
 116        }
 117
 118        if (seedResult.Value is not null)
 119        {
 120            context.Summary.CriteriaCreated += seedResult.Value.CreatedCount;
 121        }
 122
 123        return Result<bool>.Success(true);
 124    }
 125}
 126
 127public sealed class TrackerImportPipeline
 128{
 129    private readonly IReadOnlyList<ITrackerImportStep> _steps;
 130    private readonly ITrackingTransactionContext? _trackingContext;
 131
 42132    public TrackerImportPipeline(IReadOnlyList<ITrackerImportStep> steps, ITrackingTransactionContext? trackingContext =
 133    {
 42134        _steps = steps ?? throw new ArgumentNullException(nameof(steps));
 42135        _trackingContext = trackingContext;
 42136    }
 137
 138    public async Task<Result<TrackerImportSummary>> ExecuteAsync(
 139        TrackerImportContext context,
 140        CancellationToken cancellationToken = default)
 141    {
 42142        ArgumentNullException.ThrowIfNull(context);
 143
 42144        var knownFiles = new[]
 42145        {
 42146            "company-aliases.csv",
 42147            "watchlist-companies.csv",
 42148            "postings.json",
 42149            "appendix-rows.csv",
 42150            "applications.csv"
 42151        };
 152
 504153        foreach (var file in knownFiles)
 154        {
 210155            var fullPath = Path.Combine(context.BundleDirectory, file);
 210156            var recon = context.Summary.GetOrCreateFileReconciliation(file);
 210157            if (!File.Exists(fullPath))
 158            {
 8159                recon.IsAbsent = true;
 160            }
 161        }
 162
 574163        foreach (var step in _steps)
 164        {
 246165            var result = await step.ExecuteAsync(context, cancellationToken);
 246166            if (!result.IsSuccess)
 167            {
 2168                return Result<TrackerImportSummary>.Failure(result.Error!.Value);
 169            }
 170        }
 171
 40172        context.Summary.DispositionHistogram.Clear();
 173
 40174        if (_trackingContext is not null)
 175        {
 40176            var page = 1;
 0177            while (true)
 178            {
 40179                var existingRes = await _trackingContext.Postings.ListPostingsAsync(context.OwnerId, page: page, pageSiz
 40180                if (!existingRes.IsSuccess || existingRes.Value is null || existingRes.Value.Count == 0)
 181                {
 182                    break;
 183                }
 292184                foreach (var p in existingRes.Value)
 185                {
 106186                    if (!context.AllPostings.ContainsKey(p.Id))
 187                    {
 4188                        context.AllPostings[p.Id] = p;
 189                    }
 190                }
 40191                if (existingRes.Value.Count < 200)
 192                {
 193                    break;
 194                }
 0195                page++;
 196            }
 197        }
 198
 296199        foreach (var p in context.AllPostings.Values)
 200        {
 108201            var dispName = p.Disposition.ToSnakeCase();
 108202            context.Summary.DispositionHistogram.TryGetValue(dispName, out var count);
 108203            context.Summary.DispositionHistogram[dispName] = count + 1;
 204        }
 205
 40206        return Result<TrackerImportSummary>.Success(context.Summary);
 42207    }
 208}