< Summary

Information
Class: RoleRadar.Application.Tracking.Queries.TrackerQueryHandler
Assembly: RoleRadar.Application
File(s): /home/runner/work/roleradar/roleradar/src/RoleRadar.Application/Tracking/Queries/TrackerQueryPostingsHandler.cs
Line coverage
96%
Covered lines: 281
Uncovered lines: 11
Coverable lines: 292
Total lines: 592
Line coverage: 96.2%
Branch coverage
67%
Covered branches: 91
Total branches: 134
Branch coverage: 67.9%
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()95%202093.1%
HandlePostingsQueryAsync()60.71%282896.49%
HandleDecidedPostingsQueryAsync()50%101094.44%
HandleDedupLookupQueryAsync()68.75%181680%
BuildSinglePostingResult(...)100%11100%
HandleCompaniesQueryAsync()80%202097.95%
HandleCriteriaQueryAsync()50%161690.9%
HandleApplicationsQueryAsync()55.55%181895.91%

File(s)

/home/runner/work/roleradar/roleradar/src/RoleRadar.Application/Tracking/Queries/TrackerQueryPostingsHandler.cs

#LineLine coverage
 1using RoleRadar.Application.Abstractions;
 2using RoleRadar.Domain.Common;
 3using RoleRadar.Domain.Tracking;
 4
 5namespace RoleRadar.Application.Tracking.Queries;
 6
 7public sealed record PostingSummaryItemDto(
 8    Guid Id,
 9    Guid CompanyId,
 10    string Title,
 11    string NormalizedTitle,
 12    string Disposition,
 13    string GhostLikelihood,
 14    string ResurfacePolicy,
 15    Guid VersionToken,
 16    string? Location = null,
 17    string? RemoteType = null,
 18    decimal? Score = null,
 19    DateTimeOffset? LastVerifiedAt = null,
 20    bool? CompHighPriority = null);
 21
 22public sealed record DecidedPostingSummaryItemDto(
 23    Guid Id,
 24    Guid CompanyId,
 25    string Title,
 26    string Disposition,
 27    string? DispositionReason,
 28    string ResurfacePolicy,
 29    DateTimeOffset? DecidedAtUtc,
 30    bool? CompHighPriority = null);
 31
 32public sealed record CareerSourceSummaryItemDto(
 33    Guid Id,
 34    Guid CompanyId,
 35    string AtsType,
 36    string? Tenant,
 37    string? Slug,
 38    string FetchMethod,
 39    string? Notes,
 40    bool IsActive,
 41    Guid VersionToken);
 42
 43public sealed record CompanySummaryItemDto(
 44    Guid Id,
 45    string Name,
 46    string? Description,
 47    string? ParentCompany,
 48    string OwnershipType,
 49    string? Headquarters,
 50    string Status,
 51    IReadOnlyList<string> CategoryTags,
 52    IReadOnlyList<CareerSourceSummaryItemDto> CareerSources,
 53    DateTimeOffset? LastCheckedAt,
 54    string? LastCheckResult,
 55    Guid VersionToken,
 56    DateTimeOffset CreatedAt,
 57    DateTimeOffset UpdatedAt);
 58
 59public sealed record CriterionSummaryItemDto(
 60    Guid Id,
 61    string Key,
 62    string Category,
 63    string Value,
 64    string Provenance,
 65    DateTimeOffset EffectiveFrom,
 66    DateTimeOffset? EffectiveTo,
 67    bool IsActive,
 68    Guid VersionToken,
 69    DateTimeOffset CreatedAt);
 70
 71public sealed record ApplicationEventSummaryItemDto(
 72    Guid Id,
 73    Guid ApplicationId,
 74    string EventType,
 75    string EventDate,
 76    string? EventSource,
 77    string? Notes,
 78    DateTimeOffset CreatedAt);
 79
 80public sealed record ApplicationSummaryItemDto(
 81    Guid Id,
 82    Guid PostingId,
 83    string SubmittedDate,
 84    decimal? DesiredSalaryMin,
 85    decimal? DesiredSalaryMax,
 86    string DesiredSalaryCurrency,
 87    string? TargetStartDate,
 88    string ResumeVariant,
 89    string? ResumePointer,
 90    Guid? ReferralContactId,
 91    string? ConfirmationCode,
 92    string Outcome,
 93    string? OutcomeReason,
 94    Guid VersionToken,
 95    IReadOnlyList<ApplicationEventSummaryItemDto> Events,
 96    DateTimeOffset CreatedAt,
 97    DateTimeOffset UpdatedAt);
 98
 99public sealed record TrackerQueryResultDto(
 100    string Entity,
 101    int Page,
 102    int PageSize,
 103    int TotalCount,
 104    IReadOnlyList<object> Items);
 105
 106public sealed record TrackerQueryRequest(
 107    string Entity,
 108    Guid? PostingId = null,
 109    Guid? CompanyId = null,
 110    string? Disposition = null,
 111    string? Status = null,
 112    string? Tag = null,
 113    string? Name = null,
 114    bool IncludeRetired = false,
 115    bool IncludeStale = false,
 116    int StaleAfterDays = 7,
 117    string? EffectiveDate = null,
 118    string? DedupKey = null,
 119    int Page = 1,
 120    int PageSize = 50,
 121    string? OwnerId = null) : IQuery<TrackerQueryResultDto>;
 122
 123public sealed class TrackerQueryHandler : IQueryHandler<TrackerQueryRequest, TrackerQueryResultDto>
 124{
 125    private readonly ITrackingTransactionContext _context;
 126    private readonly IUtcClock _clock;
 127
 308128    public TrackerQueryHandler(ITrackingTransactionContext context, IUtcClock clock)
 129    {
 308130        _context = context ?? throw new ArgumentNullException(nameof(context));
 308131        _clock = clock ?? throw new ArgumentNullException(nameof(clock));
 308132    }
 133
 134    public async Task<Result<TrackerQueryResultDto>> HandleAsync(
 135        TrackerQueryRequest query,
 136        CancellationToken cancellationToken = default)
 137    {
 296138        ArgumentNullException.ThrowIfNull(query);
 139
 294140        if (string.IsNullOrWhiteSpace(query.Entity))
 141        {
 2142            return Result<TrackerQueryResultDto>.Failure(ErrorCode.ValidationError, "Entity discriminator is required.")
 143        }
 144
 292145        var entity = query.Entity.Trim().ToLowerInvariant();
 292146        if (entity == "contacts" || entity == "contact")
 147        {
 6148            return Result<TrackerQueryResultDto>.Failure(
 6149                ErrorCode.ValidationError,
 6150                "Contacts are accessible exclusively via CLI commands (roleradar contact add|get|redact).");
 151        }
 152
 286153        var ownerId = string.IsNullOrWhiteSpace(query.OwnerId)
 286154            ? OwnerId.Default.Value
 286155            : new OwnerId(query.OwnerId).Value;
 286156        var now = _clock.UtcNow;
 157
 158        // Bounded paging: default 50, max 200, min 1
 286159        var page = Math.Max(1, query.Page);
 286160        var pageSize = Math.Clamp(query.PageSize <= 0 ? 50 : query.PageSize, 1, 200);
 161
 162        try
 163        {
 286164            return entity switch
 286165            {
 110166                "postings" => await HandlePostingsQueryAsync(query, ownerId, page, pageSize, now, cancellationToken),
 6167                "decided_postings" => await HandleDecidedPostingsQueryAsync(ownerId, page, pageSize, cancellationToken),
 108168                "posting_dedup_lookup" => await HandleDedupLookupQueryAsync(query, ownerId, cancellationToken),
 30169                "companies" => await HandleCompaniesQueryAsync(query, ownerId, page, pageSize, now, cancellationToken),
 16170                "criteria" => await HandleCriteriaQueryAsync(query, ownerId, page, pageSize, cancellationToken),
 8171                "applications" => await HandleApplicationsQueryAsync(query, ownerId, page, pageSize, cancellationToken),
 4172                _ => Result<TrackerQueryResultDto>.Failure(
 4173                    ErrorCode.ValidationError,
 4174                    $"Entity discriminator '{query.Entity}' is not supported by tracker_query postings handler.")
 286175            };
 176        }
 4177        catch (TrackingIndexValidationException ex)
 178        {
 4179            return Result<TrackerQueryResultDto>.Failure(ErrorCode.ValidationError, ex.Message);
 180        }
 294181    }
 182
 183    private async Task<Result<TrackerQueryResultDto>> HandlePostingsQueryAsync(
 184        TrackerQueryRequest query,
 185        string ownerId,
 186        int page,
 187        int pageSize,
 188        DateTimeOffset now,
 189        CancellationToken cancellationToken)
 190    {
 191        // Single posting lookup by ID
 114192        if (query.PostingId.HasValue)
 193        {
 6194            var singleResult = await _context.Postings.GetByIdAsync(ownerId, query.PostingId.Value, cancellationToken);
 6195            if (!singleResult.IsSuccess || singleResult.Value is null)
 196            {
 0197                return Result<TrackerQueryResultDto>.Success(new TrackerQueryResultDto("postings", 1, pageSize, 0, []));
 198            }
 199
 6200            var p = singleResult.Value;
 6201            var signalsResult = await _context.Postings.GetSignalsAsync(ownerId, p.Id, cancellationToken);
 6202            var signals = signalsResult.IsSuccess && signalsResult.Value is not null ? signalsResult.Value : [];
 6203            var ghost = GhostLikelihoodEvaluator.Evaluate(p, signals, now);
 204
 6205            var item = new PostingSummaryItemDto(
 6206                Id: p.Id,
 6207                CompanyId: p.CompanyId,
 6208                Title: p.Title,
 6209                NormalizedTitle: p.NormalizedTitle,
 6210                Disposition: p.Disposition.ToSnakeCase(),
 6211                GhostLikelihood: ghost,
 6212                ResurfacePolicy: p.ResurfacePolicy.ToSnakeCase(),
 6213                VersionToken: p.VersionToken,
 6214                Location: p.Location,
 6215                RemoteType: p.RemoteType.ToSnakeCase(),
 6216                Score: p.Score,
 6217                LastVerifiedAt: p.LastVerifiedAt,
 6218                CompHighPriority: p.CompHighPriority);
 219
 6220            return Result<TrackerQueryResultDto>.Success(new TrackerQueryResultDto("postings", 1, pageSize, 1, [item]));
 221        }
 222
 223        // Paged listing with optional disposition and company filters
 108224        PostingDisposition? dispositionFilter = null;
 108225        if (!string.IsNullOrWhiteSpace(query.Disposition) &&
 108226            TrackingEnumExtensions.TryParseDisposition(query.Disposition, out var parsedDisp))
 227        {
 82228            dispositionFilter = parsedDisp;
 229        }
 230
 108231        var postingsResult = await _context.Postings.ListPostingsAsync(
 108232            ownerId, query.CompanyId, dispositionFilter, page, pageSize, cancellationToken);
 104233        if (!postingsResult.IsSuccess || postingsResult.Value is null)
 234        {
 0235            return Result<TrackerQueryResultDto>.Failure(postingsResult.Error ?? new ResultError(ErrorCode.ValidationErr
 236        }
 237
 104238        var countResult = await _context.Postings.CountPostingsAsync(
 104239            ownerId, query.CompanyId, dispositionFilter, cancellationToken);
 104240        var totalCount = countResult.IsSuccess ? countResult.Value : postingsResult.Value.Count;
 241
 4746242        var postingIds = postingsResult.Value.Select(p => p.Id).ToList();
 104243        var signalsLookupResult = await _context.Postings.GetSignalsForPostingsAsync(ownerId, postingIds, cancellationTo
 104244        var signalsLookup = signalsLookupResult.IsSuccess && signalsLookupResult.Value is not null
 104245            ? signalsLookupResult.Value
 104246            : Enumerable.Empty<PostingSignal>().ToLookup(s => s.PostingId);
 247
 104248        var items = new List<object>(postingsResult.Value.Count);
 9492249        foreach (var p in postingsResult.Value)
 250        {
 4642251            var sigs = signalsLookup[p.Id].ToList();
 4642252            var ghost = GhostLikelihoodEvaluator.Evaluate(p, sigs, now);
 253
 4642254            items.Add(new PostingSummaryItemDto(
 4642255                Id: p.Id,
 4642256                CompanyId: p.CompanyId,
 4642257                Title: p.Title,
 4642258                NormalizedTitle: p.NormalizedTitle,
 4642259                Disposition: p.Disposition.ToSnakeCase(),
 4642260                GhostLikelihood: ghost,
 4642261                ResurfacePolicy: p.ResurfacePolicy.ToSnakeCase(),
 4642262                VersionToken: p.VersionToken,
 4642263                Location: p.Location,
 4642264                RemoteType: p.RemoteType.ToSnakeCase(),
 4642265                Score: p.Score,
 4642266                LastVerifiedAt: p.LastVerifiedAt,
 4642267                CompHighPriority: p.CompHighPriority));
 268        }
 269
 104270        return Result<TrackerQueryResultDto>.Success(new TrackerQueryResultDto("postings", page, pageSize, totalCount, i
 110271    }
 272
 273    private async Task<Result<TrackerQueryResultDto>> HandleDecidedPostingsQueryAsync(
 274        string ownerId,
 275        int page,
 276        int pageSize,
 277        CancellationToken cancellationToken)
 278    {
 6279        var postingsResult = await _context.Postings.ListDecidedPostingsAsync(ownerId, page, pageSize, cancellationToken
 6280        if (!postingsResult.IsSuccess || postingsResult.Value is null)
 281        {
 0282            return Result<TrackerQueryResultDto>.Failure(postingsResult.Error ?? new ResultError(ErrorCode.ValidationErr
 283        }
 284
 6285        var countResult = await _context.Postings.CountDecidedPostingsAsync(ownerId, cancellationToken);
 6286        var totalCount = countResult.IsSuccess ? countResult.Value : postingsResult.Value.Count;
 287
 6288        var items = new List<object>(postingsResult.Value.Count);
 24289        foreach (var p in postingsResult.Value)
 290        {
 6291            items.Add(new DecidedPostingSummaryItemDto(
 6292                Id: p.Id,
 6293                CompanyId: p.CompanyId,
 6294                Title: p.Title,
 6295                Disposition: p.Disposition.ToSnakeCase(),
 6296                DispositionReason: p.DispositionReason,
 6297                ResurfacePolicy: p.ResurfacePolicy.ToSnakeCase(),
 6298                DecidedAtUtc: p.DecidedAt,
 6299                CompHighPriority: p.CompHighPriority));
 300        }
 301
 6302        return Result<TrackerQueryResultDto>.Success(new TrackerQueryResultDto("decided_postings", page, pageSize, total
 6303    }
 304
 305    private async Task<Result<TrackerQueryResultDto>> HandleDedupLookupQueryAsync(
 306        TrackerQueryRequest query,
 307        string ownerId,
 308        CancellationToken cancellationToken)
 309    {
 108310        if (string.IsNullOrWhiteSpace(query.DedupKey))
 311        {
 0312            return Result<TrackerQueryResultDto>.Failure(ErrorCode.ValidationError, "DedupKey is required for entity 'po
 313        }
 314
 108315        var key = query.DedupKey.Trim();
 316
 317        // 1. Try Tier A
 108318        var matchA = await _context.Postings.GetByDedupKeyAAsync(ownerId, key, cancellationToken);
 108319        if (matchA.IsSuccess && matchA.Value is not null)
 320        {
 106321            return BuildSinglePostingResult(matchA.Value);
 322        }
 323
 324        // 2. Try Tier B
 2325        var normalizedKey = UrlNormalizer.Normalize(key) ?? key;
 2326        var matchB = await _context.Postings.GetByDedupKeyBAsync(ownerId, normalizedKey, cancellationToken);
 2327        if (matchB.IsSuccess && matchB.Value is not null)
 328        {
 0329            return BuildSinglePostingResult(matchB.Value);
 330        }
 331
 332        // 3. Try Tier C
 2333        var matchC = await _context.Postings.GetByDedupKeyCAsync(ownerId, key, cancellationToken);
 2334        if (matchC.IsSuccess && matchC.Value is not null)
 335        {
 2336            return BuildSinglePostingResult(matchC.Value);
 337        }
 338
 0339        return Result<TrackerQueryResultDto>.Success(new TrackerQueryResultDto("posting_dedup_lookup", 1, 1, 0, []));
 108340    }
 341
 342    private Result<TrackerQueryResultDto> BuildSinglePostingResult(Posting p)
 343    {
 108344        var item = new PostingSummaryItemDto(
 108345            Id: p.Id,
 108346            CompanyId: p.CompanyId,
 108347            Title: p.Title,
 108348            NormalizedTitle: p.NormalizedTitle,
 108349            Disposition: p.Disposition.ToSnakeCase(),
 108350            GhostLikelihood: "low",
 108351            ResurfacePolicy: p.ResurfacePolicy.ToSnakeCase(),
 108352            VersionToken: p.VersionToken,
 108353            Location: p.Location,
 108354            RemoteType: p.RemoteType.ToSnakeCase(),
 108355            Score: p.Score,
 108356            LastVerifiedAt: p.LastVerifiedAt,
 108357            CompHighPriority: p.CompHighPriority);
 358
 108359        return Result<TrackerQueryResultDto>.Success(new TrackerQueryResultDto("posting_dedup_lookup", 1, 1, 1, [item]))
 360    }
 361
 362    private async Task<Result<TrackerQueryResultDto>> HandleCompaniesQueryAsync(
 363        TrackerQueryRequest query,
 364        string ownerId,
 365        int page,
 366        int pageSize,
 367        DateTimeOffset now,
 368        CancellationToken cancellationToken)
 369    {
 30370        CompanyStatus? statusFilter = null;
 30371        if (!string.IsNullOrWhiteSpace(query.Status) &&
 30372            TrackingEnumExtensions.TryParseCompanyStatus(query.Status, out var parsedStatus))
 373        {
 4374            statusFilter = parsedStatus;
 375        }
 376
 30377        var listResult = await _context.Companies.ListAsync(ownerId, statusFilter, cancellationToken);
 30378        if (!listResult.IsSuccess || listResult.Value is null)
 379        {
 0380            return Result<TrackerQueryResultDto>.Success(new TrackerQueryResultDto("companies", page, pageSize, 0, []));
 381        }
 382
 30383        var companies = listResult.Value.AsEnumerable();
 384
 30385        if (!string.IsNullOrWhiteSpace(query.Tag))
 386        {
 4387            var tag = query.Tag.Trim();
 12388            companies = companies.Where(c => c.CategoryTags.Contains(tag, StringComparer.OrdinalIgnoreCase));
 389        }
 390
 30391        if (!string.IsNullOrWhiteSpace(query.Name))
 392        {
 12393            var name = query.Name.Trim();
 36394            companies = companies.Where(c => c.Name.Contains(name, StringComparison.OrdinalIgnoreCase));
 395        }
 396
 30397        if (query.IncludeStale)
 398        {
 2399            var threshold = now.AddDays(-query.StaleAfterDays);
 8400            companies = companies.Where(c => !c.LastCheckedAt.HasValue || c.LastCheckedAt.Value <= threshold);
 401        }
 402
 30403        var filteredList = companies.ToList();
 30404        var totalCount = filteredList.Count;
 30405        var pagedCompanies = filteredList.Skip((page - 1) * pageSize).Take(pageSize).ToList();
 406
 30407        var items = new List<object>(pagedCompanies.Count);
 124408        foreach (var c in pagedCompanies)
 409        {
 32410            var sourcesRes = await _context.Companies.GetCareerSourcesAsync(
 32411                ownerId,
 32412                c.Id,
 32413                includeInactive: query.IncludeRetired,
 32414                cancellationToken);
 415
 32416            var sources = sourcesRes.IsSuccess && sourcesRes.Value is not null
 18417                ? sourcesRes.Value.Select(s => new CareerSourceSummaryItemDto(
 18418                    Id: s.Id,
 18419                    CompanyId: s.CompanyId,
 18420                    AtsType: s.AtsType,
 18421                    Tenant: s.Tenant,
 18422                    Slug: s.Slug,
 18423                    FetchMethod: s.FetchMethod.ToSnakeCase(),
 18424                    Notes: s.Notes,
 18425                    IsActive: s.IsActive,
 18426                    VersionToken: s.VersionToken)).ToArray()
 32427                : [];
 428
 32429            items.Add(new CompanySummaryItemDto(
 32430                Id: c.Id,
 32431                Name: c.Name,
 32432                Description: c.Description,
 32433                ParentCompany: c.ParentCompany,
 32434                OwnershipType: c.OwnershipType.ToSnakeCase(),
 32435                Headquarters: c.Headquarters,
 32436                Status: c.Status.ToSnakeCase(),
 32437                CategoryTags: c.CategoryTags,
 32438                CareerSources: sources,
 32439                LastCheckedAt: c.LastCheckedAt,
 32440                LastCheckResult: c.LastCheckResult,
 32441                VersionToken: c.VersionToken,
 32442                CreatedAt: c.CreatedAt,
 32443                UpdatedAt: c.UpdatedAt));
 32444        }
 445
 30446        return Result<TrackerQueryResultDto>.Success(new TrackerQueryResultDto(
 30447            Entity: "companies",
 30448            Page: page,
 30449            PageSize: pageSize,
 30450            TotalCount: totalCount,
 30451            Items: items));
 30452    }
 453
 454    private async Task<Result<TrackerQueryResultDto>> HandleCriteriaQueryAsync(
 455        TrackerQueryRequest query,
 456        string ownerId,
 457        int page,
 458        int pageSize,
 459        CancellationToken cancellationToken)
 460    {
 461        IReadOnlyList<Criterion> criteria;
 462
 16463        if (!string.IsNullOrWhiteSpace(query.EffectiveDate))
 464        {
 14465            if (!DateTimeOffset.TryParse(query.EffectiveDate, System.Globalization.CultureInfo.InvariantCulture, out var
 466            {
 2467                return Result<TrackerQueryResultDto>.Failure(
 2468                    ErrorCode.ValidationError,
 2469                    $"Invalid EffectiveDate format '{query.EffectiveDate}'. Expected YYYY-MM-DD or ISO 8601 string.");
 470            }
 471
 12472            var effResult = await _context.Criteria.GetEffectiveAtAsync(ownerId, parsedEffectiveDate, cancellationToken)
 12473            if (!effResult.IsSuccess || effResult.Value is null)
 474            {
 0475                return Result<TrackerQueryResultDto>.Failure(effResult.Error ?? new ResultError(ErrorCode.ValidationErro
 476            }
 477
 12478            criteria = effResult.Value;
 479        }
 480        else
 481        {
 2482            var activeResult = await _context.Criteria.ListActiveAsync(ownerId, cancellationToken);
 2483            if (!activeResult.IsSuccess || activeResult.Value is null)
 484            {
 0485                return Result<TrackerQueryResultDto>.Failure(activeResult.Error ?? new ResultError(ErrorCode.ValidationE
 486            }
 487
 2488            criteria = activeResult.Value;
 489        }
 490
 14491        var totalCount = criteria.Count;
 14492        var pagedCriteria = criteria.Skip((page - 1) * pageSize).Take(pageSize).ToList();
 493
 24494        var items = pagedCriteria.Select(c => new CriterionSummaryItemDto(
 24495            Id: c.Id,
 24496            Key: c.Key,
 24497            Category: c.Category.ToSnakeCase(),
 24498            Value: c.Value,
 24499            Provenance: c.Provenance.ToSnakeCase(),
 24500            EffectiveFrom: c.EffectiveFrom,
 24501            EffectiveTo: c.EffectiveTo,
 24502            IsActive: c.IsActive,
 24503            VersionToken: c.VersionToken,
 24504            CreatedAt: c.CreatedAt)).ToArray();
 505
 14506        return Result<TrackerQueryResultDto>.Success(new TrackerQueryResultDto(
 14507            Entity: "criteria",
 14508            Page: page,
 14509            PageSize: pageSize,
 14510            TotalCount: totalCount,
 14511            Items: items));
 16512    }
 513
 514    private async Task<Result<TrackerQueryResultDto>> HandleApplicationsQueryAsync(
 515        TrackerQueryRequest query,
 516        string ownerId,
 517        int page,
 518        int pageSize,
 519        CancellationToken cancellationToken)
 520    {
 8521        string? outcomeFilter = null;
 8522        if (!string.IsNullOrWhiteSpace(query.Status))
 523        {
 4524            outcomeFilter = query.Status.Trim();
 525        }
 4526        else if (!string.IsNullOrWhiteSpace(query.Disposition))
 527        {
 0528            outcomeFilter = query.Disposition.Trim();
 529        }
 530
 8531        var listResult = await _context.Applications.ListApplicationsAsync(
 8532            ownerId,
 8533            outcomeFilter,
 8534            page,
 8535            pageSize,
 8536            cancellationToken);
 537
 8538        if (!listResult.IsSuccess || listResult.Value is null)
 539        {
 0540            return Result<TrackerQueryResultDto>.Failure(listResult.Error ?? new ResultError(ErrorCode.ValidationError, 
 541        }
 542
 8543        var countResult = await _context.Applications.CountApplicationsAsync(
 8544            ownerId,
 8545            outcomeFilter,
 8546            cancellationToken);
 547
 8548        var totalCount = countResult.IsSuccess ? countResult.Value : listResult.Value.Count;
 549
 8550        var items = new List<object>(listResult.Value.Count);
 28551        foreach (var app in listResult.Value)
 552        {
 6553            var eventsResult = await _context.Applications.GetEventsAsync(ownerId, app.Id, cancellationToken);
 6554            var events = eventsResult.IsSuccess && eventsResult.Value is not null
 10555                ? eventsResult.Value.Select(e => new ApplicationEventSummaryItemDto(
 10556                    Id: e.Id,
 10557                    ApplicationId: e.ApplicationId,
 10558                    EventType: e.EventType.ToSnakeCase(),
 10559                    EventDate: e.EventDate,
 10560                    EventSource: e.EventSource,
 10561                    Notes: e.Notes,
 10562                    CreatedAt: e.CreatedAt)).ToArray()
 6563                : [];
 564
 6565            items.Add(new ApplicationSummaryItemDto(
 6566                Id: app.Id,
 6567                PostingId: app.PostingId,
 6568                SubmittedDate: app.SubmittedDate,
 6569                DesiredSalaryMin: app.DesiredSalary.Min,
 6570                DesiredSalaryMax: app.DesiredSalary.Max,
 6571                DesiredSalaryCurrency: app.DesiredSalary.Currency,
 6572                TargetStartDate: app.TargetStartDate,
 6573                ResumeVariant: app.ResumeVariant.ToSnakeCase(),
 6574                ResumePointer: app.ResumePointer,
 6575                ReferralContactId: app.ReferralContactId,
 6576                ConfirmationCode: app.ConfirmationCode,
 6577                Outcome: app.Outcome.ToSnakeCase(),
 6578                OutcomeReason: app.OutcomeReason,
 6579                VersionToken: app.VersionToken,
 6580                Events: events,
 6581                CreatedAt: app.CreatedAt,
 6582                UpdatedAt: app.UpdatedAt));
 6583        }
 584
 8585        return Result<TrackerQueryResultDto>.Success(new TrackerQueryResultDto(
 8586            Entity: "applications",
 8587            Page: page,
 8588            PageSize: pageSize,
 8589            TotalCount: totalCount,
 8590            Items: items));
 8591    }
 592}