< Summary

Information
Class: RoleRadar.Application.Tracking.Commands.RecordCompanyCommandHandler
Assembly: RoleRadar.Application
File(s): /home/runner/work/roleradar/roleradar/src/RoleRadar.Application/Tracking/Commands/RecordCompanyCommand.cs
Line coverage
92%
Covered lines: 230
Uncovered lines: 18
Coverable lines: 248
Total lines: 533
Line coverage: 92.7%
Branch coverage
76%
Covered branches: 137
Total branches: 180
Branch coverage: 76.1%
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()82.91%17215891.78%
AppendAuditAsync(...)100%22100%

File(s)

/home/runner/work/roleradar/roleradar/src/RoleRadar.Application/Tracking/Commands/RecordCompanyCommand.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 record CareerSourceInputDto(
 9    Guid? Id = null,
 10    string AtsType = "",
 11    string? Tenant = null,
 12    string? Slug = null,
 13    string? FetchMethod = null,
 14    string? Notes = null,
 15    bool? IsActive = null,
 16    Guid? VersionToken = null);
 17
 18public sealed record CompanyRecordSummaryDto(
 19    Guid Id,
 20    string Name,
 21    string? Description,
 22    string OwnershipType,
 23    string Status,
 24    Guid VersionToken,
 25    int CareerSourceCount);
 26
 27public sealed record CompanyRecordResultDto(
 28    CompanyRecordSummaryDto Company,
 29    string Status = "created");
 30
 31public sealed record RecordCompanyCommand(
 32    string Actor,
 33    Guid? Id = null,
 34    string? Name = null,
 35    string? Description = null,
 36    string? ParentCompany = null,
 37    string? OwnershipType = null,
 38    string? Headquarters = null,
 39    string? Status = null,
 40    IReadOnlyList<string>? CategoryTags = null,
 41    IReadOnlyList<CareerSourceInputDto>? CareerSources = null,
 42    Guid? VersionToken = null,
 43    string? OwnerId = null) : ICommand<CompanyRecordResultDto>;
 44
 45public sealed class RecordCompanyCommandHandler : ICommandHandler<RecordCompanyCommand, CompanyRecordResultDto>
 46{
 47    private readonly ITrackingTransactionContext _context;
 48    private readonly IUtcClock _clock;
 49
 42650    public RecordCompanyCommandHandler(ITrackingTransactionContext context, IUtcClock clock)
 51    {
 42652        _context = context ?? throw new ArgumentNullException(nameof(context));
 42653        _clock = clock ?? throw new ArgumentNullException(nameof(clock));
 42654    }
 55
 56    public async Task<Result<CompanyRecordResultDto>> HandleAsync(
 57        RecordCompanyCommand command,
 58        CancellationToken cancellationToken = default)
 59    {
 30460        ArgumentNullException.ThrowIfNull(command);
 61
 30462        var ownerId = string.IsNullOrWhiteSpace(command.OwnerId)
 30463            ? OwnerId.Default.Value
 30464            : new OwnerId(command.OwnerId).Value;
 65
 30466        var now = _clock.UtcNow;
 67
 68        // Lookup existing company by ID or Normalized Name
 30469        Company? existing = null;
 30470        if (command.Id.HasValue)
 71        {
 4272            var byIdResult = await _context.Companies.GetByIdAsync(ownerId, command.Id.Value, cancellationToken);
 4273            if (byIdResult.IsSuccess && byIdResult.Value is not null)
 74            {
 4275                existing = byIdResult.Value;
 76            }
 77        }
 78
 30479        var trimmedName = string.IsNullOrWhiteSpace(command.Name) ? existing?.Name : command.Name.Trim();
 30480        if (string.IsNullOrWhiteSpace(trimmedName))
 81        {
 082            return Result<CompanyRecordResultDto>.Failure(ErrorCode.ValidationError, "Company name is required.");
 83        }
 84
 30485        if (trimmedName.Length > 150)
 86        {
 087            return Result<CompanyRecordResultDto>.Failure(ErrorCode.ValidationError, "Company name cannot exceed 150 cha
 88        }
 89
 30490        if (command.Description is not null && command.Description.Length > 300)
 91        {
 292            return Result<CompanyRecordResultDto>.Failure(ErrorCode.ValidationError, "Company description cannot exceed 
 93        }
 94
 30295        if (command.ParentCompany is not null && command.ParentCompany.Length > 150)
 96        {
 097            return Result<CompanyRecordResultDto>.Failure(ErrorCode.ValidationError, "Parent company cannot exceed 150 c
 98        }
 99
 302100        if (command.Headquarters is not null && command.Headquarters.Length > 150)
 101        {
 0102            return Result<CompanyRecordResultDto>.Failure(ErrorCode.ValidationError, "Headquarters cannot exceed 150 cha
 103        }
 104
 302105        if (existing is null)
 106        {
 260107            var byNameResult = await _context.Companies.GetByNormalizedNameAsync(ownerId, trimmedName.ToLowerInvariant()
 260108            if (byNameResult.IsSuccess && byNameResult.Value is not null)
 109            {
 16110                existing = byNameResult.Value;
 111            }
 112        }
 113
 114        Company company;
 115        bool isCreate;
 302116        List<string> changedFields = [];
 117
 118        OwnershipType parsedOwnership;
 119        CompanyStatus parsedStatus;
 120
 302121        if (existing is null)
 122        {
 244123            parsedOwnership = OwnershipType.Unknown;
 244124            if (!string.IsNullOrWhiteSpace(command.OwnershipType))
 125            {
 162126                if (!TrackingEnumExtensions.TryParseOwnershipType(command.OwnershipType, out parsedOwnership))
 127                {
 0128                    return Result<CompanyRecordResultDto>.Failure(ErrorCode.ValidationError, $"Invalid ownership type '{
 129                }
 130            }
 131
 244132            parsedStatus = CompanyStatus.Neutral;
 244133            if (!string.IsNullOrWhiteSpace(command.Status))
 134            {
 164135                if (!TrackingEnumExtensions.TryParseCompanyStatus(command.Status, out parsedStatus))
 136                {
 0137                    return Result<CompanyRecordResultDto>.Failure(ErrorCode.ValidationError, $"Invalid company status '{
 138                }
 139            }
 140        }
 141        else
 142        {
 58143            parsedOwnership = existing.OwnershipType;
 58144            if (!string.IsNullOrWhiteSpace(command.OwnershipType))
 145            {
 30146                if (!TrackingEnumExtensions.TryParseOwnershipType(command.OwnershipType, out parsedOwnership))
 147                {
 0148                    return Result<CompanyRecordResultDto>.Failure(ErrorCode.ValidationError, $"Invalid ownership type '{
 149                }
 150            }
 151
 58152            parsedStatus = existing.Status;
 58153            if (!string.IsNullOrWhiteSpace(command.Status))
 154            {
 38155                if (!TrackingEnumExtensions.TryParseCompanyStatus(command.Status, out parsedStatus))
 156                {
 0157                    return Result<CompanyRecordResultDto>.Failure(ErrorCode.ValidationError, $"Invalid company status '{
 158                }
 159            }
 160        }
 161
 302162        var companyFieldNamesChanged = new List<string>();
 302163        if (existing is not null)
 164        {
 58165            if (!string.IsNullOrWhiteSpace(trimmedName) && !string.Equals(trimmedName, existing.Name, StringComparison.O
 166            {
 16167                companyFieldNamesChanged.Add("name");
 168            }
 58169            if (command.Description is not null && !string.Equals(command.Description, existing.Description, StringCompa
 170            {
 8171                companyFieldNamesChanged.Add("description");
 172            }
 58173            if (command.ParentCompany is not null && !string.Equals(command.ParentCompany, existing.ParentCompany, Strin
 174            {
 0175                companyFieldNamesChanged.Add("parent_company");
 176            }
 58177            if (command.Headquarters is not null && !string.Equals(command.Headquarters, existing.Headquarters, StringCo
 178            {
 0179                companyFieldNamesChanged.Add("headquarters");
 180            }
 58181            if (!string.IsNullOrWhiteSpace(command.OwnershipType) && parsedOwnership != existing.OwnershipType)
 182            {
 2183                companyFieldNamesChanged.Add("ownership_type");
 184            }
 58185            if (!string.IsNullOrWhiteSpace(command.Status) && parsedStatus != existing.Status)
 186            {
 16187                companyFieldNamesChanged.Add("status");
 188            }
 58189            if (command.CategoryTags is not null && !command.CategoryTags.SequenceEqual(existing.CategoryTags))
 190            {
 2191                companyFieldNamesChanged.Add("category_tags");
 192            }
 193        }
 302194        var hasCompanyFieldChanges = companyFieldNamesChanged.Count > 0;
 302195        bool companyFieldsUpdated = false;
 196
 302197        if (existing is not null)
 198        {
 58199            if (!command.Id.HasValue && !command.VersionToken.HasValue && (command.CareerSources is null || command.Care
 200            {
 16201                var existingSources = await _context.Companies.GetCareerSourcesAsync(ownerId, existing.Id, includeInacti
 16202                var sourceCount = existingSources.IsSuccess && existingSources.Value is not null ? existingSources.Value
 16203                return Result<CompanyRecordResultDto>.Success(new CompanyRecordResultDto(
 16204                    Company: new CompanyRecordSummaryDto(
 16205                        Id: existing.Id,
 16206                        Name: existing.Name,
 16207                        Description: existing.Description,
 16208                        OwnershipType: existing.OwnershipType.ToSnakeCase(),
 16209                        Status: existing.Status.ToSnakeCase(),
 16210                        VersionToken: existing.VersionToken,
 16211                        CareerSourceCount: sourceCount),
 16212                    Status: "already_exists"));
 213            }
 214
 42215            if (command.VersionToken.HasValue && command.VersionToken.Value != existing.VersionToken)
 216            {
 4217                return Result<CompanyRecordResultDto>.Failure(
 4218                    ErrorCode.StaleVersionToken,
 4219                    "Company version token mismatch or stale.");
 220            }
 221
 38222            if (hasCompanyFieldChanges)
 223            {
 224                // Concurrency check for existing company
 24225                if (!command.VersionToken.HasValue || command.VersionToken.Value != existing.VersionToken)
 226                {
 0227                    return Result<CompanyRecordResultDto>.Failure(
 0228                        ErrorCode.StaleVersionToken,
 0229                        "Company version token mismatch or stale.");
 230                }
 231
 24232                existing.Update(
 24233                    name: trimmedName != existing.Name ? trimmedName : null,
 24234                    description: command.Description is not null ? command.Description : null,
 24235                    parentCompany: command.ParentCompany is not null ? command.ParentCompany : null,
 24236                    ownershipType: !string.IsNullOrWhiteSpace(command.OwnershipType) ? parsedOwnership : null,
 24237                    headquarters: command.Headquarters is not null ? command.Headquarters : null,
 24238                    categoryTags: command.CategoryTags is not null ? command.CategoryTags : null,
 24239                    status: !string.IsNullOrWhiteSpace(command.Status) ? parsedStatus : null,
 24240                    now: now);
 241
 24242                await _context.Companies.UpsertCompanyAsync(existing, cancellationToken);
 24243                companyFieldsUpdated = true;
 24244                changedFields = [.. companyFieldNamesChanged, "version_token"];
 245            }
 246
 38247            company = existing;
 38248            isCreate = false;
 249        }
 250        else
 251        {
 244252            company = Company.Create(
 244253                ownerId: ownerId,
 244254                name: trimmedName,
 244255                description: command.Description,
 244256                parentCompany: command.ParentCompany,
 244257                ownershipType: parsedOwnership,
 244258                headquarters: command.Headquarters,
 244259                categoryTags: command.CategoryTags,
 244260                status: parsedStatus,
 244261                id: command.Id,
 244262                now: now);
 263
 244264            await _context.Companies.UpsertCompanyAsync(company, cancellationToken);
 158265            isCreate = true;
 158266            changedFields = ["name", "status", "created_at"];
 267        }
 268
 269        // Upsert career sources if supplied
 196270        if (command.CareerSources is not null)
 271        {
 28272            var existingSourcesRes = await _context.Companies.GetCareerSourcesAsync(ownerId, company.Id, includeInactive
 28273            var currentSources = existingSourcesRes.IsSuccess && existingSourcesRes.Value is not null
 28274                ? existingSourcesRes.Value.ToList()
 28275                : [];
 276
 120277            foreach (var csInput in command.CareerSources)
 278            {
 32279                if (string.IsNullOrWhiteSpace(csInput.AtsType))
 280                {
 0281                    return Result<CompanyRecordResultDto>.Failure(ErrorCode.ValidationError, "Career source AtsType is r
 282                }
 283
 32284                CareerSource? matchedSource = null;
 32285                if (csInput.Id.HasValue)
 286                {
 8287                    matchedSource = currentSources.FirstOrDefault(s => s.Id == csInput.Id.Value);
 288                }
 289
 32290                if (matchedSource is null)
 291                {
 28292                    matchedSource = currentSources.FirstOrDefault(s =>
 36293                        string.Equals(s.AtsType, csInput.AtsType.Trim(), StringComparison.OrdinalIgnoreCase) &&
 36294                        string.Equals(s.Tenant ?? string.Empty, csInput.Tenant?.Trim() ?? string.Empty, StringComparison
 36295                        string.Equals(s.Slug ?? string.Empty, csInput.Slug?.Trim() ?? string.Empty, StringComparison.Ord
 296                }
 297
 32298                FetchMethod? fetchMethod = null;
 32299                if (!string.IsNullOrWhiteSpace(csInput.FetchMethod))
 300                {
 16301                    if (TrackingEnumExtensions.TryParseFetchMethod(csInput.FetchMethod, out var parsedFm))
 302                    {
 16303                        fetchMethod = parsedFm;
 304                    }
 305                    else
 306                    {
 0307                        return Result<CompanyRecordResultDto>.Failure(ErrorCode.ValidationError, $"Invalid career source
 308                    }
 309                }
 310
 32311                if (matchedSource is not null)
 312                {
 4313                    if (csInput.VersionToken.HasValue && csInput.VersionToken.Value != matchedSource.VersionToken)
 314                    {
 0315                        return Result<CompanyRecordResultDto>.Failure(
 0316                            ErrorCode.StaleVersionToken,
 0317                            "Career source version token mismatch or stale.");
 318                    }
 319
 4320                    matchedSource.Update(
 4321                        atsType: csInput.AtsType,
 4322                        tenant: csInput.Tenant,
 4323                        slug: csInput.Slug,
 4324                        fetchMethod: fetchMethod,
 4325                        notes: csInput.Notes,
 4326                        isActive: csInput.IsActive,
 4327                        now: now);
 328
 4329                    await _context.Companies.UpsertCareerSourceAsync(matchedSource, cancellationToken);
 330                }
 331                else
 332                {
 28333                    var newSource = CareerSource.Create(
 28334                        ownerId: ownerId,
 28335                        companyId: company.Id,
 28336                        atsType: csInput.AtsType,
 28337                        tenant: csInput.Tenant,
 28338                        slug: csInput.Slug,
 28339                        fetchMethod: fetchMethod ?? FetchMethod.Api,
 28340                        notes: csInput.Notes,
 28341                        isActive: csInput.IsActive ?? true,
 28342                        id: csInput.Id,
 28343                        now: now);
 344
 28345                    await _context.Companies.UpsertCareerSourceAsync(newSource, cancellationToken);
 28346                    currentSources.Add(newSource);
 28347                }
 348            }
 349
 28350            changedFields.Add("career_sources");
 28351        }
 352
 353        // Count total career sources
 196354        var totalSourcesRes = await _context.Companies.GetCareerSourcesAsync(ownerId, company.Id, includeInactive: true,
 196355        var totalCount = totalSourcesRes.IsSuccess && totalSourcesRes.Value is not null
 196356            ? totalSourcesRes.Value.Count
 196357            : 0;
 358
 359        // Append audit log entries
 196360        if (isCreate)
 361        {
 158362            var auditSummary = new CompanyAuditSummary(
 158363                CompanyId: company.Id,
 158364                ChangedFieldNames: changedFields,
 158365                Action: AuditOperation.CompanyCreate,
 158366                Timestamp: now);
 367
 158368            await AppendAuditAsync(
 158369                ownerId,
 158370                command.Actor,
 158371                AuditOperation.CompanyCreate,
 158372                company.Id,
 158373                company.VersionToken,
 158374                auditSummary,
 158375                company,
 158376                cancellationToken);
 377        }
 378        else
 379        {
 38380            if (companyFieldsUpdated)
 381            {
 24382                var auditSummary = new CompanyAuditSummary(
 24383                    CompanyId: company.Id,
 24384                    ChangedFieldNames: changedFields,
 24385                    Action: AuditOperation.CompanyUpdate,
 24386                    Timestamp: now);
 387
 24388                await AppendAuditAsync(
 24389                    ownerId,
 24390                    command.Actor,
 24391                    AuditOperation.CompanyUpdate,
 24392                    company.Id,
 24393                    company.VersionToken,
 24394                    auditSummary,
 24395                    company,
 24396                    cancellationToken);
 397            }
 398
 38399            if (command.CareerSources is not null && command.CareerSources.Count > 0)
 400            {
 16401                var csAuditSummary = new CompanyAuditSummary(
 16402                    CompanyId: company.Id,
 16403                    ChangedFieldNames: ["career_sources"],
 16404                    Action: AuditOperation.CareerSourceUpsert,
 16405                    Timestamp: now);
 406
 16407                await AppendAuditAsync(
 16408                    ownerId,
 16409                    command.Actor,
 16410                    AuditOperation.CareerSourceUpsert,
 16411                    company.Id,
 16412                    company.VersionToken,
 16413                    csAuditSummary,
 16414                    company,
 16415                    cancellationToken);
 416            }
 417        }
 418
 196419        return Result<CompanyRecordResultDto>.Success(new CompanyRecordResultDto(
 196420            Company: new CompanyRecordSummaryDto(
 196421                Id: company.Id,
 196422                Name: company.Name,
 196423                Description: company.Description,
 196424                OwnershipType: company.OwnershipType.ToSnakeCase(),
 196425                Status: company.Status.ToSnakeCase(),
 196426                VersionToken: company.VersionToken,
 196427                CareerSourceCount: totalCount),
 196428            Status: isCreate ? "created" : "updated"));
 218429    }
 430
 431    private Task AppendAuditAsync(
 432        string ownerId,
 433        string actor,
 434        string operation,
 435        Guid companyId,
 436        Guid versionToken,
 437        CompanyAuditSummary summary,
 438        Company company,
 439        CancellationToken cancellationToken)
 440    {
 198441        var isCreate = operation == AuditOperation.CompanyCreate;
 198442        var afterDict = new Dictionary<string, object?>
 198443        {
 198444            ["name"] = company.Name,
 198445            ["status"] = company.Status.ToSnakeCase(),
 198446            ["ownership_type"] = company.OwnershipType.ToSnakeCase()
 198447        };
 448
 198449        var details = AuditDetails.ForEntity(
 198450            changedFields: summary.ChangedFieldNames,
 198451            before: isCreate ? null : new Dictionary<string, object?>(),
 198452            after: afterDict);
 453
 198454        var entry = AuditLogEntry.CreateForTracking(
 198455            ownerId: ownerId,
 198456            actor: actor,
 198457            operation: operation,
 198458            entityType: "company",
 198459            entityId: companyId,
 198460            resultingVersionToken: versionToken,
 198461            occurredAtUtc: summary.Timestamp.UtcDateTime,
 198462            details: details);
 463
 198464        return _context.AppendAuditEntryAsync(entry, cancellationToken);
 465    }
 466}
 467
 468public sealed class RecordCompanyCommandValidator : ICommandValidator<RecordCompanyCommand>
 469{
 470    public ResultError? Validate(RecordCompanyCommand command)
 471    {
 472        ArgumentNullException.ThrowIfNull(command);
 473
 474        var actorError = CommandActor.Validate(command.Actor);
 475        if (actorError is not null)
 476        {
 477            return actorError;
 478        }
 479
 480        if (string.IsNullOrWhiteSpace(command.Name) && !command.Id.HasValue)
 481        {
 482            return new ResultError(ErrorCode.ValidationError, "Company name is required.");
 483        }
 484
 485        if (!string.IsNullOrWhiteSpace(command.Name) && command.Name.Trim().Length > 150)
 486        {
 487            return new ResultError(ErrorCode.ValidationError, "Company name cannot exceed 150 characters.");
 488        }
 489
 490        if (command.Description is not null && command.Description.Length > 300)
 491        {
 492            return new ResultError(ErrorCode.ValidationError, "Company description cannot exceed 300 characters.");
 493        }
 494
 495        if (command.ParentCompany is not null && command.ParentCompany.Length > 150)
 496        {
 497            return new ResultError(ErrorCode.ValidationError, "Parent company cannot exceed 150 characters.");
 498        }
 499
 500        if (command.Headquarters is not null && command.Headquarters.Length > 150)
 501        {
 502            return new ResultError(ErrorCode.ValidationError, "Headquarters cannot exceed 150 characters.");
 503        }
 504
 505        if (!string.IsNullOrWhiteSpace(command.OwnershipType) && !TrackingEnumExtensions.TryParseOwnershipType(command.O
 506        {
 507            return new ResultError(ErrorCode.ValidationError, $"Invalid ownership type '{command.OwnershipType}'.");
 508        }
 509
 510        if (!string.IsNullOrWhiteSpace(command.Status) && !TrackingEnumExtensions.TryParseCompanyStatus(command.Status, 
 511        {
 512            return new ResultError(ErrorCode.ValidationError, $"Invalid company status '{command.Status}'.");
 513        }
 514
 515        if (command.CategoryTags is not null)
 516        {
 517            if (command.CategoryTags.Count > 20)
 518            {
 519                return new ResultError(ErrorCode.ValidationError, "Category tags count cannot exceed 20.");
 520            }
 521
 522            foreach (var tag in command.CategoryTags)
 523            {
 524                if (tag.Trim().Length > 50)
 525                {
 526                    return new ResultError(ErrorCode.ValidationError, $"Category tag '{tag}' exceeds 50 characters.");
 527                }
 528            }
 529        }
 530
 531        return null;
 532    }
 533}