< Summary

Information
Class: RoleRadar.Application.Tracking.Import.Pipeline.AppendixRowsStep
Assembly: RoleRadar.Application
File(s): /home/runner/work/roleradar/roleradar/src/RoleRadar.Application/Tracking/Import/Pipeline/AppendixRowsStep.cs
Line coverage
92%
Covered lines: 379
Uncovered lines: 30
Coverable lines: 409
Total lines: 547
Line coverage: 92.6%
Branch coverage
71%
Covered branches: 191
Total branches: 266
Branch coverage: 71.8%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.cctor()100%11100%
.ctor(...)50%66100%
ExecuteAsync()70.88%18315889.96%
<ExecuteAsync()65.68%12510287.02%

File(s)

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

#LineLine coverage
 1using System.Globalization;
 2using System.Net;
 3using RoleRadar.Application.Abstractions;
 4using RoleRadar.Domain.Audit;
 5using RoleRadar.Domain.Common;
 6using RoleRadar.Domain.Tracking;
 7
 8namespace RoleRadar.Application.Tracking.Import.Pipeline;
 9
 10public sealed class AppendixRowsStep : ITrackerImportStep
 11{
 812    private static readonly char[] ReasonSeparators = [',', ';'];
 13    private const string ImportActor = "cli-import-tracker";
 14    private readonly ICsvParser _csvParser;
 15    private readonly ITrackingTransactionContext _context;
 16    private readonly CriteriaSeedingStep _criteriaStep;
 17
 6218    public AppendixRowsStep(ICsvParser csvParser, ITrackingTransactionContext context, CriteriaSeedingStep criteriaStep)
 19    {
 6220        _csvParser = csvParser ?? throw new ArgumentNullException(nameof(csvParser));
 6221        _context = context ?? throw new ArgumentNullException(nameof(context));
 6222        _criteriaStep = criteriaStep ?? throw new ArgumentNullException(nameof(criteriaStep));
 6223    }
 24
 25    public async Task<Result<bool>> ExecuteAsync(TrackerImportContext context, CancellationToken cancellationToken = def
 26    {
 6027        ArgumentNullException.ThrowIfNull(context);
 28
 6029        var filePath = Path.Combine(context.BundleDirectory, "appendix-rows.csv");
 6030        var recon = context.Summary.GetOrCreateFileReconciliation("appendix-rows.csv");
 31
 6032        if (!File.Exists(filePath))
 33        {
 034            recon.IsAbsent = true;
 035            return Result<bool>.Success(true);
 36        }
 37
 6038        recon.IsAbsent = false;
 39
 6040        var content = await File.ReadAllTextAsync(filePath, cancellationToken);
 6041        if (string.IsNullOrWhiteSpace(content))
 42        {
 243            recon.RecordErrored();
 244            context.Summary.Errors.Add(new TrackerImportRowError(
 245                "appendix-rows.csv",
 246                1,
 247                ErrorCode.ValidationError.ToString(),
 248                "File is present but empty."));
 249            return Result<bool>.Failure(ErrorCode.ValidationError, "appendix-rows.csv is present but empty.");
 50        }
 51
 5852        using var headerReader = new StringReader(content);
 5853        var headers = _csvParser.ReadHeader(headerReader);
 5854        var headerValidation = CsvHeaderValidator.Validate("appendix-rows.csv", headers, CsvHeaderValidator.AppendixHead
 5855        if (!headerValidation.IsSuccess)
 56        {
 257            recon.RecordErrored();
 258            context.Summary.Errors.Add(new TrackerImportRowError(
 259                "appendix-rows.csv",
 260                1,
 261                ErrorCode.ValidationError.ToString(),
 262                headerValidation.Error!.Value.Message));
 263            return Result<bool>.Failure(headerValidation.Error!.Value);
 64        }
 65
 5666        var records = new List<ICsvRecord>();
 5667        using (var reader = new StringReader(content))
 68        {
 5669            records.AddRange(_csvParser.Read(reader, hasHeader: true));
 5670        }
 71
 72        // Partition records: non-duplicates before duplicates so duplicate_of_id can resolve
 5673        var nonDuplicates = new List<ICsvRecord>();
 5674        var duplicates = new List<ICsvRecord>();
 75
 32876        foreach (var row in records)
 77        {
 10878            var rawProposedDisp = (TrackerImportTextSanitizer.SanitizePlainText(row["proposed_disposition"]) ?? TrackerI
 10879            var isDuplicate = string.Equals(rawProposedDisp, "duplicate", StringComparison.OrdinalIgnoreCase);
 80
 10881            if (isDuplicate)
 82            {
 1483                duplicates.Add(row);
 84            }
 85            else
 86            {
 9487                nonDuplicates.Add(row);
 88            }
 89        }
 90
 5691        var defaultDate = context.DefaultDate ?? DateOnly.FromDateTime(DateTime.UtcNow);
 92
 93        // Process non-duplicates first, then duplicates
 32894        foreach (var row in nonDuplicates.Concat(duplicates))
 95        {
 10896            cancellationToken.ThrowIfCancellationRequested();
 10897            recon.RecordRead();
 98
 410499            foreach (var def in SourceFieldCatalog.ByFile["appendix-rows.csv"])
 100            {
 1944101                var val = TrackerImportTextSanitizer.SanitizePlainText(row[def.Field])?.Trim();
 1944102                context.Summary.RecordFieldRead("appendix-rows.csv", def.Field, !string.IsNullOrWhiteSpace(val));
 103            }
 104
 105            try
 106            {
 250107                if (!row.Fields.Any(f => !string.IsNullOrWhiteSpace(f)))
 108                {
 2109                    recon.RecordSkipped("empty_row");
 2110                    continue;
 111                }
 112
 106113                var companyName = TrackerImportTextSanitizer.SanitizePlainText(row["company"])?.Trim();
 106114                var title = TrackerImportTextSanitizer.SanitizePlainText(row["title"])?.Trim();
 115
 106116                if (string.IsNullOrWhiteSpace(companyName) || string.IsNullOrWhiteSpace(title))
 117                {
 2118                    context.Summary.Errors.Add(new TrackerImportRowError(
 2119                        "appendix-rows.csv",
 2120                        row.LineNumber,
 2121                        ErrorCode.ValidationError.ToString(),
 2122                        "Missing required company or title."));
 2123                    recon.RecordErrored();
 2124                    continue;
 125                }
 126
 104127                var decision = TrackerImportTextSanitizer.SanitizePlainText(row["decision"])?.Trim();
 104128                if (string.Equals(decision, "skip", StringComparison.OrdinalIgnoreCase))
 129                {
 2130                    context.Summary.PostingsUnchanged++;
 2131                    recon.RecordSkipped("decision_skip");
 2132                    continue;
 133                }
 134
 102135                if (!string.IsNullOrWhiteSpace(decision))
 136                {
 0137                    context.Summary.Errors.Add(new TrackerImportRowError(
 0138                        "appendix-rows.csv",
 0139                        row.LineNumber,
 0140                        ErrorCode.ValidationError.ToString(),
 0141                        $"Invalid decision value '{decision}'. Expected blank or 'skip'."));
 0142                    recon.RecordErrored();
 0143                    continue;
 144                }
 145
 102146                var canonicalCompany = context.CompanyAliases.TryGetValue(companyName, out var alias) ? alias : companyN
 147
 148                // Enforce domain limits
 102149                canonicalCompany = TrackerImportFieldLimiter.LimitCompanyName(canonicalCompany, context.Summary)!;
 102150                title = TrackerImportFieldLimiter.LimitTitle(title, context.Summary)!;
 151
 152                // 2. Parse date
 102153                var addedRaw = TrackerImportTextSanitizer.SanitizePlainText(row["added_md"])?.Trim();
 102154                var dateOutcome = DateInferenceRule.Resolve(addedRaw, defaultDate);
 100155                if (dateOutcome.Kind == DateResolutionKind.DefaultedBlank) context.Summary.DatesDefaulted++;
 144156                if (dateOutcome.Kind is DateResolutionKind.InferredRollback or DateResolutionKind.InferredSameYear) cont
 106157                if (dateOutcome.IsFlagged) context.Summary.DatesFlagged++;
 158
 100159                var effectiveDate = dateOutcome.ResolvedDate.ToDateTime(TimeOnly.MinValue, DateTimeKind.Utc);
 160
 100161                var autoCreatedCompany = false;
 100162                Company? newCompany = null;
 100163                Posting? updatedPosting = null;
 100164                Posting? createdPosting = null;
 100165                var isUnchanged = false;
 166
 100167                var rawReqId = (TrackerImportTextSanitizer.SanitizePlainText(row["req"]) ?? TrackerImportTextSanitizer.S
 100168                var reqId = TrackerImportFieldLimiter.LimitRequisitionId(rawReqId, context.Summary);
 100169                var rawReasonPrimary = TrackerImportTextSanitizer.SanitizeFreeText(row["reason_primary"])?.Trim();
 100170                var reasonPrimary = TrackerImportFieldLimiter.LimitDispositionReason(rawReasonPrimary, context.Summary);
 100171                var reasonAll = TrackerImportTextSanitizer.SanitizeFreeText(row["reason_all"])?.Trim();
 100172                var rawProposedDisp = (TrackerImportTextSanitizer.SanitizePlainText(row["proposed_disposition"]) ?? Trac
 173
 100174                var rawComp = TrackerImportTextSanitizer.SanitizePlainText(row["comp_detected"])?.Trim();
 100175                var rawCompEstimate = TrackerImportTextSanitizer.SanitizePlainText(row["comp_is_estimate"])?.Trim();
 100176                Compensation? compensation = null;
 100177                if (!string.IsNullOrWhiteSpace(rawComp))
 178                {
 6179                    if (string.Equals(rawCompEstimate, "yes", StringComparison.OrdinalIgnoreCase) || string.Equals(rawCo
 180                    {
 4181                        if (!rawComp.Contains("estimate", StringComparison.OrdinalIgnoreCase))
 182                        {
 4183                            rawComp = $"{rawComp} (estimate)";
 184                        }
 185                    }
 6186                    var compText = TrackerImportFieldLimiter.LimitCompensationText(rawComp, context.Summary);
 6187                    var (compMin, compMax) = PostingsJsonStep.TryParseCompensationRange(compText);
 6188                    compensation = compText != null ? new Compensation(compMin, compMax, "USD", compText) : null;
 189                }
 190
 100191                var remoteMentioned = TrackerImportTextSanitizer.SanitizePlainText(row["remote_mentioned"])?.Trim();
 100192                var isRemoteMentioned = string.Equals(remoteMentioned, "yes", StringComparison.OrdinalIgnoreCase) || str
 100193                if (isRemoteMentioned || (!string.IsNullOrWhiteSpace(remoteMentioned) && !string.Equals(remoteMentioned,
 194                {
 96195                    context.Summary.RecordUnmappedValue("remote_mentioned", "not stored");
 196                }
 100197                var remoteType = RemoteType.Unknown;
 100198                string? cultureSummary = null;
 199
 100200                var isDuplicateRow = string.Equals(rawProposedDisp, "duplicate", StringComparison.OrdinalIgnoreCase);
 201
 202                PostingDisposition targetDisposition;
 100203                var normalizedDisp = rawProposedDisp?.ToLowerInvariant().Replace("-", "_").Replace(" ", "_");
 204
 100205                if (isDuplicateRow)
 206                {
 14207                    targetDisposition = PostingDisposition.ScreenedOut;
 208                }
 86209                else if (normalizedDisp is "screened_out" or "screenedout")
 210                {
 58211                    targetDisposition = PostingDisposition.ScreenedOut;
 212                }
 28213                else if (normalizedDisp is "closed")
 214                {
 10215                    targetDisposition = PostingDisposition.Closed;
 216                }
 18217                else if (normalizedDisp is "unscored")
 218                {
 8219                    targetDisposition = PostingDisposition.Unscored;
 220                }
 10221                else if (normalizedDisp is "dismissed")
 222                {
 8223                    targetDisposition = PostingDisposition.ScreenedOut;
 224                }
 2225                else if (string.IsNullOrWhiteSpace(normalizedDisp))
 226                {
 0227                    targetDisposition = PostingDisposition.ScreenedOut;
 228                }
 229                else
 230                {
 2231                    context.Summary.Errors.Add(new TrackerImportRowError(
 2232                        "appendix-rows.csv",
 2233                        row.LineNumber,
 2234                        ErrorCode.ValidationError.ToString(),
 2235                        $"Invalid proposed_disposition '{rawProposedDisp}'."));
 2236                    recon.RecordErrored();
 2237                    continue;
 238                }
 239
 98240                var rawReasonText = TrackerImportTextSanitizer.SanitizeFreeText(row["reason_text"])?.Trim();
 98241                var rawDetails = TrackerImportTextSanitizer.SanitizeFreeText(row["details_raw"])?.Trim();
 242
 98243                var baseReason = !string.IsNullOrWhiteSpace(rawReasonText)
 98244                    ? rawReasonText
 98245                    : rawReasonPrimary;
 246
 98247                var combinedReason = baseReason ?? (isDuplicateRow ? "duplicate" : (normalizedDisp == "dismissed" ? "dis
 248
 98249                if (!string.IsNullOrWhiteSpace(rawDetails))
 250                {
 98251                    combinedReason += " | details: " + rawDetails;
 252                }
 253
 98254                if (!string.IsNullOrWhiteSpace(reasonAll))
 255                {
 98256                    var otherCodes = reasonAll
 98257                        .Split(ReasonSeparators, StringSplitOptions.RemoveEmptyEntries)
 102258                        .Select(s => s.Trim())
 102259                        .Where(s => !string.IsNullOrWhiteSpace(s) && !string.Equals(s, rawReasonPrimary, StringCompariso
 98260                        .ToList();
 261
 98262                    if (otherCodes.Count > 0)
 263                    {
 4264                        combinedReason += " | also: " + string.Join(", ", otherCodes);
 265                    }
 266                }
 267
 98268                var finalReason = TrackerImportFieldLimiter.LimitDispositionReason(combinedReason, context.Summary);
 269
 98270                var closedDate = targetDisposition == PostingDisposition.Closed
 98271                    ? dateOutcome.ResolvedDate.ToString("yyyy-MM-dd", CultureInfo.InvariantCulture)
 98272                    : null;
 273
 98274                var rawSource = TrackerImportTextSanitizer.SanitizePlainText(row["source"])?.Trim();
 98275                var sourceKind = TrackingEnumExtensions.TryParseSourceKind(rawSource, out var parsedSrc) ? parsedSrc : S
 276
 98277                var rowResult = await _context.ExecuteInTransactionAsync(async (txCtx, ct) =>
 98278                {
 98279                    Company? company = null;
 98280                    if (!context.CanonicalCompanies.TryGetValue(canonicalCompany, out company))
 98281                    {
 16282                        var existing = await txCtx.Companies.GetByNormalizedNameAsync(context.OwnerId, canonicalCompany,
 16283                        if (existing.IsSuccess && existing.Value is not null)
 98284                        {
 0285                            company = existing.Value;
 98286                        }
 98287                        else
 98288                        {
 16289                            company = Company.Create(
 16290                                ownerId: context.OwnerId,
 16291                                name: canonicalCompany,
 16292                                status: CompanyStatus.Neutral,
 16293                                description: string.Empty);
 98294
 16295                            var saveCompany = await txCtx.Companies.UpsertCompanyAsync(company, ct);
 16296                            if (!saveCompany.IsSuccess)
 98297                            {
 0298                                return Result<bool>.Failure(saveCompany.Error ?? new ResultError(ErrorCode.ValidationErr
 98299                            }
 98300
 16301                            var audit = AuditLogEntry.CreateForTracking(
 16302                                ownerId: context.OwnerId,
 16303                                actor: ImportActor,
 16304                                operation: AuditOperation.ImportCompanyCreate,
 16305                                entityType: "company",
 16306                                entityId: company.Id,
 16307                                resultingVersionToken: company.VersionToken,
 16308                                occurredAtUtc: DateTime.UtcNow,
 16309                                details: new AuditDetails(
 16310                                    ChangedFields: ["name", "status"],
 16311                                    After: new Dictionary<string, object?>
 16312                                    {
 16313                                        ["name"] = company.Name,
 16314                                        ["status"] = company.Status.ToString()
 16315                                    }));
 16316                            await txCtx.AppendAuditEntryAsync(audit, ct);
 16317                            autoCreatedCompany = true;
 16318                            newCompany = company;
 98319                        }
 98320                    }
 98321
 98322                    // 3. Resolve or create criterion from reason_primary
 98323                    Guid? criterionId = null;
 98324                    var criterionReason = !string.IsNullOrWhiteSpace(rawReasonPrimary)
 98325                        ? rawReasonPrimary
 98326                        : (normalizedDisp == "dismissed" ? "dismissed" : (isDuplicateRow ? "duplicate" : null));
 98327
 98328                    if (!string.IsNullOrWhiteSpace(criterionReason))
 98329                    {
 98330                        var critResult = await _criteriaStep.GetOrCreateReasonCriterionAsync(
 98331                            context.OwnerId, criterionReason, effectiveDate, context.Summary, ct);
 98332                        if (critResult.IsSuccess && critResult.Value is not null)
 98333                        {
 98334                            criterionId = critResult.Value.Id;
 98335                        }
 98336                    }
 98337
 98338                    // Duplicate link resolution
 98339                    Guid? duplicateOfId = null;
 98340                    if (isDuplicateRow)
 98341                    {
 14342                        var lookupKey = $"{canonicalCompany}|{TitleNormalizer.Normalize(title)}";
 14343                        if (context.PostingsByCompanyAndTitle.TryGetValue(lookupKey, out var targetPosting))
 98344                        {
 8345                            duplicateOfId = targetPosting.Id;
 98346                        }
 6347                        else if (company is not null)
 98348                        {
 6349                            var candRes = await txCtx.Postings.FindCandidatesByCompanyAndTitleAsync(context.OwnerId, com
 6350                            if (candRes.IsSuccess && candRes.Value is { Count: > 0 } candidates)
 98351                            {
 2352                                duplicateOfId = candidates[0].Id;
 98353                            }
 98354                        }
 98355                    }
 98356
 98357                    // Match against existing posting in context or repository
 98358                    Posting? existingPosting = null;
 98359                    if (!string.IsNullOrWhiteSpace(reqId))
 98360                    {
 96361                        if (context.PostingsByCompanyAndReq.TryGetValue($"{canonicalCompany}|{reqId}", out var byReq))
 98362                        {
 6363                            existingPosting = byReq;
 98364                        }
 90365                        else if (company is not null)
 98366                        {
 90367                            var dedupC = $"{company.Id:D}|{reqId.Trim()}";
 90368                            var byCRes = await txCtx.Postings.GetByDedupKeyCAsync(context.OwnerId, dedupC, ct);
 90369                            if (byCRes.IsSuccess && byCRes.Value is not null)
 98370                            {
 12371                                existingPosting = byCRes.Value;
 98372                            }
 98373                        }
 98374                    }
 98375
 98376                    // If not matched by req, match by company + title ONLY IF candidate has no requisitionId (or same r
 98377                    if (existingPosting is null && !isDuplicateRow)
 98378                    {
 68379                        var titleKey = $"{canonicalCompany}|{TitleNormalizer.Normalize(title)}";
 68380                        if (context.PostingsByCompanyAndTitle.TryGetValue(titleKey, out var candByTitle))
 98381                        {
 6382                            if (string.IsNullOrWhiteSpace(candByTitle.RequisitionId) || string.Equals(candByTitle.Requis
 98383                            {
 2384                                existingPosting = candByTitle;
 98385                            }
 98386                        }
 62387                        else if (company is not null)
 98388                        {
 62389                            var candRes = await txCtx.Postings.FindCandidatesByCompanyAndTitleAsync(context.OwnerId, com
 62390                            if (candRes.IsSuccess && candRes.Value is { Count: > 0 } candidates)
 98391                            {
 0392                                foreach (var c in candidates)
 98393                                {
 0394                                    var byIdRes = await txCtx.Postings.GetByIdAsync(context.OwnerId, c.Id, ct);
 0395                                    if (byIdRes.IsSuccess && byIdRes.Value is not null)
 98396                                    {
 0397                                        if (string.IsNullOrWhiteSpace(byIdRes.Value.RequisitionId) || string.Equals(byId
 98398                                        {
 0399                                            existingPosting = byIdRes.Value;
 0400                                            break;
 98401                                        }
 98402                                    }
 98403                                }
 98404                            }
 98405                        }
 98406                    }
 98407
 98408                    // Resurface policy
 98409                    var proposedResurface = TrackerImportTextSanitizer.SanitizePlainText(row["proposed_resurface"])?.Tri
 98410                    ResurfacePolicy resurfacePolicy;
 98411                    if (string.IsNullOrWhiteSpace(proposedResurface))
 98412                    {
 18413                        resurfacePolicy = existingPosting?.ResurfacePolicy ?? ResurfacePolicy.Never;
 98414                    }
 98415                    else
 98416                    {
 80417                        var s = proposedResurface.Trim().ToLowerInvariant().Replace("-", "_").Replace(" ", "_");
 80418                        if (s is "if_reopened" or "ifreopened")
 98419                        {
 12420                            resurfacePolicy = ResurfacePolicy.IfReopened;
 98421                        }
 68422                        else if (s is "never")
 98423                        {
 68424                            resurfacePolicy = ResurfacePolicy.Never;
 98425                        }
 98426                        else
 98427                        {
 0428                            context.Summary.RecordUnmappedValue("proposed_resurface", proposedResurface);
 0429                            resurfacePolicy = existingPosting?.ResurfacePolicy ?? ResurfacePolicy.Never;
 98430                        }
 98431                    }
 98432
 98433                    if (existingPosting is not null)
 98434                    {
 20435                        isUnchanged = true;
 20436                        updatedPosting = existingPosting;
 20437                        return Result<bool>.Success(true);
 98438                    }
 98439
 98440                    // Create new posting directly with target disposition
 78441                    var newPosting = Posting.Create(
 78442                        ownerId: context.OwnerId,
 78443                        companyId: company?.Id ?? Guid.NewGuid(),
 78444                        title: title,
 78445                        sourceKind: sourceKind,
 78446                        originalUrl: null,
 78447                        requisitionId: reqId,
 78448                        remoteType: remoteType,
 78449                        compensation: compensation,
 78450                        cultureSummary: cultureSummary,
 78451                        disposition: targetDisposition,
 78452                        dispositionReason: finalReason,
 78453                        dispositionCriterionId: criterionId,
 78454                        resurfacePolicy: resurfacePolicy,
 78455                        decidedAt: targetDisposition is PostingDisposition.ScreenedOut or PostingDisposition.Closed ? ef
 78456                        duplicateOfId: duplicateOfId,
 78457                        now: effectiveDate,
 78458                        closedDate: closedDate);
 98459
 78460                    var saveNew = await txCtx.Postings.UpsertPostingAsync(newPosting, ct);
 78461                    if (!saveNew.IsSuccess)
 98462                    {
 0463                        return Result<bool>.Failure(saveNew.Error ?? new ResultError(ErrorCode.ValidationError, "Failed 
 98464                    }
 98465
 78466                    var newChangedFields = new List<string> { "title", "company_id", "disposition" };
 78467                    var newAfterDetails = new Dictionary<string, object?>
 78468                    {
 78469                        ["title"] = newPosting.Title,
 78470                        ["disposition"] = newPosting.Disposition.ToString()
 78471                    };
 78472                    if (closedDate is not null)
 98473                    {
 8474                        newChangedFields.Add("closed_date");
 8475                        newAfterDetails["closed_date"] = closedDate;
 98476                    }
 98477
 78478                    var auditNew = AuditLogEntry.CreateForTracking(
 78479                        ownerId: context.OwnerId,
 78480                        actor: ImportActor,
 78481                        operation: AuditOperation.ImportPostingCreate,
 78482                        entityType: "posting",
 78483                        entityId: newPosting.Id,
 78484                        resultingVersionToken: newPosting.VersionToken,
 78485                        occurredAtUtc: DateTime.UtcNow,
 78486                        details: new AuditDetails(
 78487                            ChangedFields: newChangedFields,
 78488                            After: newAfterDetails));
 78489                    await txCtx.AppendAuditEntryAsync(auditNew, ct);
 78490                    createdPosting = newPosting;
 78491                    return Result<bool>.Success(true);
 196492                }, cancellationToken);
 493
 98494                if (!rowResult.IsSuccess)
 495                {
 0496                    context.Summary.Errors.Add(new TrackerImportRowError(
 0497                        "appendix-rows.csv",
 0498                        row.LineNumber,
 0499                        rowResult.Error?.Code.ToString() ?? ErrorCode.ValidationError.ToString(),
 0500                        rowResult.Error?.Message ?? "Failed to save appendix row"));
 0501                    recon.RecordErrored();
 0502                    continue;
 503                }
 504
 98505                if (autoCreatedCompany && newCompany is not null)
 506                {
 16507                    context.CanonicalCompanies[canonicalCompany] = newCompany;
 16508                    context.Summary.CompaniesCreated++;
 16509                    context.Summary.AutoCreatedCompanies.Add(canonicalCompany);
 510                }
 511
 98512                var affectedPosting = updatedPosting ?? createdPosting;
 98513                if (affectedPosting is not null)
 514                {
 98515                    context.IndexPosting(affectedPosting, canonicalCompany);
 516                }
 517
 98518                if (isUnchanged && updatedPosting is not null)
 519                {
 20520                    context.Summary.PostingsUnchanged++;
 20521                    recon.RecordUnchanged("merged");
 522                }
 78523                else if (updatedPosting is not null)
 524                {
 0525                    context.Summary.PostingsUpdated++;
 0526                    recon.RecordUpdated();
 527                }
 78528                else if (createdPosting is not null)
 529                {
 78530                    context.Summary.PostingsCreated++;
 78531                    recon.RecordCreated();
 532                }
 98533            }
 2534            catch (Exception ex) when (ex is not OperationCanceledException)
 535            {
 2536                context.Summary.Errors.Add(new TrackerImportRowError(
 2537                    "appendix-rows.csv",
 2538                    row.LineNumber,
 2539                    ErrorCode.ValidationError.ToString(),
 2540                    ex.Message));
 2541                recon.RecordErrored();
 2542            }
 100543        }
 544
 56545        return Result<bool>.Success(true);
 60546    }
 547}