< Summary

Information
Class: RoleRadar.Application.Tracking.Commands.AddContactCommandHandler
Assembly: RoleRadar.Application
File(s): /home/runner/work/roleradar/roleradar/src/RoleRadar.Application/Tracking/Commands/ContactCommands.cs
Line coverage
86%
Covered lines: 65
Uncovered lines: 10
Coverable lines: 75
Total lines: 237
Line coverage: 86.6%
Branch coverage
66%
Covered branches: 28
Total branches: 42
Branch coverage: 66.6%
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()68.42%423885.91%

File(s)

/home/runner/work/roleradar/roleradar/src/RoleRadar.Application/Tracking/Commands/ContactCommands.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 AddContactCommand(
 9    string Name,
 10    string Actor,
 11    string? Role = null,
 12    string? Company = null,
 13    Guid? CompanyId = null,
 14    string? Relationship = null,
 15    string? Notes = null,
 16    string? OwnerId = null,
 17    Guid? Id = null) : ICommand<ContactResultDto>;
 18
 19public sealed record RedactContactCommand(
 20    Guid Id,
 21    string Actor,
 22    Guid? VersionToken = null,
 23    string? OwnerId = null) : ICommand<ContactRedactResultDto>;
 24
 25public sealed record ContactResultDto(
 26    Guid Id,
 27    string Name,
 28    string? Role,
 29    string? CompanyAffiliation,
 30    Guid? CompanyId,
 31    string Relationship,
 32    string? Notes,
 33    bool IsRedacted,
 34    Guid VersionToken,
 35    DateTime CreatedAt,
 36    DateTime UpdatedAt);
 37
 38public sealed record ContactRedactResultDto(
 39    Guid Id,
 40    Guid VersionToken,
 41    string Status);
 42
 43public sealed class AddContactCommandHandler : ICommandHandler<AddContactCommand, ContactResultDto>
 44{
 45    private readonly ITrackingTransactionContext _context;
 46    private readonly IUtcClock _clock;
 47
 1248    public AddContactCommandHandler(ITrackingTransactionContext context, IUtcClock clock)
 49    {
 1250        _context = context ?? throw new ArgumentNullException(nameof(context));
 1251        _clock = clock ?? throw new ArgumentNullException(nameof(clock));
 1252    }
 53
 54    public async Task<Result<ContactResultDto>> HandleAsync(AddContactCommand command, CancellationToken cancellationTok
 55    {
 856        ArgumentNullException.ThrowIfNull(command);
 57
 858        var actorError = CommandActor.Validate(command.Actor);
 859        if (actorError is not null)
 60        {
 061            return Result<ContactResultDto>.Failure(actorError.Value);
 62        }
 63
 864        if (string.IsNullOrWhiteSpace(command.Name))
 65        {
 066            return Result<ContactResultDto>.Failure(ErrorCode.ValidationError, "Contact name is required.");
 67        }
 68
 869        var trimmedName = command.Name.Trim();
 870        if (trimmedName.Length > Contact.MaxNameLength)
 71        {
 072            return Result<ContactResultDto>.Failure(ErrorCode.ValidationError, $"Contact name cannot exceed {Contact.Max
 73        }
 74
 875        if (command.Role is not null && command.Role.Trim().Length > Contact.MaxRoleLength)
 76        {
 077            return Result<ContactResultDto>.Failure(ErrorCode.ValidationError, $"Contact role cannot exceed {Contact.Max
 78        }
 79
 880        if (command.Company is not null && command.Company.Trim().Length > Contact.MaxCompanyAffiliationLength)
 81        {
 082            return Result<ContactResultDto>.Failure(ErrorCode.ValidationError, $"Company affiliation cannot exceed {Cont
 83        }
 84
 885        if (command.Notes is not null && command.Notes.Length > Contact.MaxNotesLength)
 86        {
 087            return Result<ContactResultDto>.Failure(ErrorCode.ValidationError, $"Contact notes cannot exceed {Contact.Ma
 88        }
 89
 890        var relationship = ContactRelationship.Peer;
 891        if (!string.IsNullOrWhiteSpace(command.Relationship))
 92        {
 893            var relStr = command.Relationship.Trim().ToLowerInvariant();
 894            relationship = relStr switch
 895            {
 096                "recruiter" => ContactRelationship.Recruiter,
 097                "referral" => ContactRelationship.Referral,
 098                "hiring_manager" or "hiringmanager" => ContactRelationship.HiringManager,
 899                "peer" => ContactRelationship.Peer,
 0100                _ => ContactRelationship.Peer
 8101            };
 102        }
 103
 8104        var ownerId = string.IsNullOrWhiteSpace(command.OwnerId)
 8105            ? OwnerId.Default.Value
 8106            : new OwnerId(command.OwnerId).Value;
 107
 8108        var now = _clock.UtcNow;
 109
 8110        var contact = Contact.Create(
 8111            ownerId: ownerId,
 8112            name: trimmedName,
 8113            role: command.Role,
 8114            companyAffiliation: command.Company,
 8115            companyId: command.CompanyId,
 8116            relationship: relationship,
 8117            notes: command.Notes,
 8118            id: command.Id,
 8119            now: now);
 120
 8121        await _context.Contacts.UpsertContactAsync(contact, cancellationToken);
 122
 123        // Audit entry: operation "contact_add", changed fields only, zero names/notes
 8124        var changedFields = new List<string> { "name" };
 16125        if (contact.Role is not null) changedFields.Add("role");
 14126        if (contact.CompanyAffiliation is not null) changedFields.Add("company_affiliation");
 8127        if (contact.CompanyId.HasValue) changedFields.Add("company_id");
 8128        changedFields.Add("relationship");
 12129        if (contact.Notes is not null) changedFields.Add("notes");
 130
 8131        var details = AuditDetails.ForContact(contact.Id, changedFields);
 8132        var auditEntry = AuditLogEntry.CreateForTracking(
 8133            ownerId: ownerId,
 8134            actor: command.Actor.Trim(),
 8135            operation: AuditOperation.ContactAdd,
 8136            entityType: "contact",
 8137            entityId: contact.Id,
 8138            resultingVersionToken: contact.VersionToken,
 8139            occurredAtUtc: now,
 8140            details: details);
 141
 8142        await _context.AppendAuditEntryAsync(auditEntry, cancellationToken);
 143
 8144        return Result<ContactResultDto>.Success(new ContactResultDto(
 8145            contact.Id,
 8146            contact.Name,
 8147            contact.Role,
 8148            contact.CompanyAffiliation,
 8149            contact.CompanyId,
 8150            contact.Relationship.ToSnakeCase(),
 8151            contact.Notes,
 8152            contact.IsRedacted,
 8153            contact.VersionToken,
 8154            contact.CreatedAt,
 8155            contact.UpdatedAt));
 8156    }
 157}
 158
 159public sealed class RedactContactCommandHandler : ICommandHandler<RedactContactCommand, ContactRedactResultDto>
 160{
 161    private readonly ITrackingTransactionContext _context;
 162    private readonly IUtcClock _clock;
 163
 164    public RedactContactCommandHandler(ITrackingTransactionContext context, IUtcClock clock)
 165    {
 166        _context = context ?? throw new ArgumentNullException(nameof(context));
 167        _clock = clock ?? throw new ArgumentNullException(nameof(clock));
 168    }
 169
 170    public async Task<Result<ContactRedactResultDto>> HandleAsync(RedactContactCommand command, CancellationToken cancel
 171    {
 172        ArgumentNullException.ThrowIfNull(command);
 173
 174        var actorError = CommandActor.Validate(command.Actor);
 175        if (actorError is not null)
 176        {
 177            return Result<ContactRedactResultDto>.Failure(actorError.Value);
 178        }
 179
 180        if (command.Id == Guid.Empty)
 181        {
 182            return Result<ContactRedactResultDto>.Failure(ErrorCode.ValidationError, "Contact ID cannot be empty.");
 183        }
 184
 185        var ownerId = string.IsNullOrWhiteSpace(command.OwnerId)
 186            ? OwnerId.Default.Value
 187            : new OwnerId(command.OwnerId).Value;
 188
 189        var existingResult = await _context.Contacts.GetByIdAsync(ownerId, command.Id, cancellationToken);
 190        if (!existingResult.IsSuccess || existingResult.Value is null)
 191        {
 192            return Result<ContactRedactResultDto>.Failure(ErrorCode.NotFound, $"Contact '{command.Id}' not found.");
 193        }
 194
 195        var contact = existingResult.Value;
 196
 197        // Idempotency: if already redacted, write nothing and return already_redacted
 198        if (contact.IsRedacted)
 199        {
 200            return Result<ContactRedactResultDto>.Success(new ContactRedactResultDto(
 201                contact.Id,
 202                contact.VersionToken,
 203                "already_redacted"));
 204        }
 205
 206        // Concurrency token check
 207        if (command.VersionToken.HasValue && command.VersionToken.Value != contact.VersionToken)
 208        {
 209            return Result<ContactRedactResultDto>.Failure(ErrorCode.StaleVersionToken, "Contact version token mismatch o
 210        }
 211
 212        var now = _clock.UtcNow;
 213        contact.Redact(now);
 214
 215        await _context.Contacts.UpsertContactAsync(contact, cancellationToken);
 216
 217        // Audit entry: operation "contact_redact", changed fields only, zero names/notes
 218        var changedFields = new[] { "name", "role", "company_affiliation", "company_id", "relationship", "notes", "is_re
 219        var details = AuditDetails.ForContact(contact.Id, changedFields);
 220        var auditEntry = AuditLogEntry.CreateForTracking(
 221            ownerId: ownerId,
 222            actor: command.Actor.Trim(),
 223            operation: AuditOperation.ContactRedact,
 224            entityType: "contact",
 225            entityId: contact.Id,
 226            resultingVersionToken: contact.VersionToken,
 227            occurredAtUtc: now,
 228            details: details);
 229
 230        await _context.AppendAuditEntryAsync(auditEntry, cancellationToken);
 231
 232        return Result<ContactRedactResultDto>.Success(new ContactRedactResultDto(
 233            contact.Id,
 234            contact.VersionToken,
 235            "redacted"));
 236    }
 237}