| | | 1 | | using System.Globalization; |
| | | 2 | | using System.Net; |
| | | 3 | | using System.Text.Json; |
| | | 4 | | using System.Text.RegularExpressions; |
| | | 5 | | using RoleRadar.Application.Abstractions; |
| | | 6 | | using RoleRadar.Domain.Audit; |
| | | 7 | | using RoleRadar.Domain.Common; |
| | | 8 | | using RoleRadar.Domain.Notes; |
| | | 9 | | using RoleRadar.Domain.Tracking; |
| | | 10 | | |
| | | 11 | | namespace RoleRadar.Application.Tracking.Import.Pipeline; |
| | | 12 | | |
| | | 13 | | public sealed class PostingsJsonStep : ITrackerImportStep |
| | | 14 | | { |
| | | 15 | | private const string ImportActor = "cli-import-tracker"; |
| | | 16 | | private readonly ITrackingTransactionContext _context; |
| | | 17 | | private readonly CriteriaSeedingStep _criteriaStep; |
| | | 18 | | |
| | 72 | 19 | | public PostingsJsonStep(ITrackingTransactionContext context, CriteriaSeedingStep criteriaStep) |
| | | 20 | | { |
| | 72 | 21 | | _context = context ?? throw new ArgumentNullException(nameof(context)); |
| | 72 | 22 | | _criteriaStep = criteriaStep ?? throw new ArgumentNullException(nameof(criteriaStep)); |
| | 72 | 23 | | } |
| | | 24 | | |
| | | 25 | | public async Task<Result<bool>> ExecuteAsync(TrackerImportContext context, CancellationToken cancellationToken = def |
| | | 26 | | { |
| | 78 | 27 | | ArgumentNullException.ThrowIfNull(context); |
| | | 28 | | |
| | 78 | 29 | | var filePath = Path.Combine(context.BundleDirectory, "postings.json"); |
| | 78 | 30 | | var recon = context.Summary.GetOrCreateFileReconciliation("postings.json"); |
| | | 31 | | |
| | 78 | 32 | | if (!File.Exists(filePath)) |
| | | 33 | | { |
| | 0 | 34 | | recon.IsAbsent = true; |
| | 0 | 35 | | return Result<bool>.Success(true); |
| | | 36 | | } |
| | | 37 | | |
| | 78 | 38 | | recon.IsAbsent = false; |
| | | 39 | | |
| | 78 | 40 | | var json = await File.ReadAllTextAsync(filePath, cancellationToken); |
| | 78 | 41 | | if (string.IsNullOrWhiteSpace(json)) |
| | | 42 | | { |
| | 4 | 43 | | recon.RecordErrored(); |
| | 4 | 44 | | context.Summary.Errors.Add(new TrackerImportRowError( |
| | 4 | 45 | | "postings.json", |
| | 4 | 46 | | 1, |
| | 4 | 47 | | ErrorCode.ValidationError.ToString(), |
| | 4 | 48 | | "File is present but empty.")); |
| | 4 | 49 | | return Result<bool>.Failure(ErrorCode.ValidationError, "postings.json is present but empty."); |
| | | 50 | | } |
| | | 51 | | |
| | | 52 | | JsonDocument doc; |
| | | 53 | | try |
| | | 54 | | { |
| | 74 | 55 | | doc = JsonDocument.Parse(json); |
| | 72 | 56 | | } |
| | 2 | 57 | | catch (JsonException ex) |
| | | 58 | | { |
| | 2 | 59 | | recon.RecordErrored(); |
| | 2 | 60 | | context.Summary.Errors.Add(new TrackerImportRowError( |
| | 2 | 61 | | "postings.json", |
| | 2 | 62 | | 1, |
| | 2 | 63 | | ErrorCode.ValidationError.ToString(), |
| | 2 | 64 | | "Malformed JSON: " + ex.Message)); |
| | 2 | 65 | | return Result<bool>.Failure(ErrorCode.ValidationError, "postings.json contains malformed JSON."); |
| | | 66 | | } |
| | | 67 | | |
| | 72 | 68 | | using (doc) |
| | | 69 | | { |
| | 72 | 70 | | if (doc.RootElement.ValueKind != JsonValueKind.Object && doc.RootElement.ValueKind != JsonValueKind.Array) |
| | | 71 | | { |
| | 2 | 72 | | recon.RecordErrored(); |
| | 2 | 73 | | context.Summary.Errors.Add(new TrackerImportRowError( |
| | 2 | 74 | | "postings.json", |
| | 2 | 75 | | 1, |
| | 2 | 76 | | ErrorCode.ValidationError.ToString(), |
| | 2 | 77 | | "Root must be a JSON object keyed by slug (or JSON array).")); |
| | 2 | 78 | | return Result<bool>.Failure(ErrorCode.ValidationError, "postings.json root must be a JSON object keyed b |
| | | 79 | | } |
| | | 80 | | |
| | | 81 | | IEnumerable<(string? Slug, JsonElement Element)> entries; |
| | 70 | 82 | | if (doc.RootElement.ValueKind == JsonValueKind.Object) |
| | | 83 | | { |
| | 180 | 84 | | entries = doc.RootElement.EnumerateObject().Select(p => ((string?)TrackerImportTextSanitizer.SanitizePla |
| | | 85 | | } |
| | | 86 | | else |
| | | 87 | | { |
| | 2 | 88 | | entries = doc.RootElement.EnumerateArray().Select(e => |
| | 2 | 89 | | { |
| | 2 | 90 | | string? slug = e.TryGetProperty("slug", out var sProp) && sProp.GetString() is { } ss ? TrackerImpor |
| | 2 | 91 | | return (slug, e); |
| | 2 | 92 | | }); |
| | | 93 | | } |
| | | 94 | | |
| | 70 | 95 | | var defaultDate = context.DefaultDate ?? DateOnly.FromDateTime(DateTime.UtcNow); |
| | 70 | 96 | | var entryOrdinal = 0; |
| | | 97 | | |
| | 368 | 98 | | foreach (var (slug, element) in entries) |
| | | 99 | | { |
| | 114 | 100 | | cancellationToken.ThrowIfCancellationRequested(); |
| | 114 | 101 | | entryOrdinal++; |
| | 114 | 102 | | recon.RecordRead(); |
| | | 103 | | |
| | 4560 | 104 | | foreach (var def in SourceFieldCatalog.ByFile["postings.json"]) |
| | | 105 | | { |
| | 2166 | 106 | | var isNonEmpty = false; |
| | 2166 | 107 | | if (element.TryGetProperty(def.Field, out var prop) && prop.ValueKind != JsonValueKind.Null && prop. |
| | | 108 | | { |
| | 810 | 109 | | if (prop.ValueKind == JsonValueKind.String) |
| | | 110 | | { |
| | 692 | 111 | | isNonEmpty = !string.IsNullOrWhiteSpace(prop.GetString()); |
| | | 112 | | } |
| | 118 | 113 | | else if (prop.ValueKind is JsonValueKind.True or JsonValueKind.False or JsonValueKind.Number) |
| | | 114 | | { |
| | 118 | 115 | | isNonEmpty = true; |
| | | 116 | | } |
| | | 117 | | } |
| | 2166 | 118 | | context.Summary.RecordFieldRead("postings.json", def.Field, isNonEmpty); |
| | | 119 | | } |
| | | 120 | | |
| | 114 | 121 | | if (element.ValueKind != JsonValueKind.Object) |
| | | 122 | | { |
| | 0 | 123 | | context.Summary.Errors.Add(new TrackerImportRowError( |
| | 0 | 124 | | "postings.json", |
| | 0 | 125 | | entryOrdinal, |
| | 0 | 126 | | ErrorCode.ValidationError.ToString(), |
| | 0 | 127 | | "Posting entry must be a JSON object")); |
| | 0 | 128 | | recon.RecordErrored(); |
| | 0 | 129 | | continue; |
| | | 130 | | } |
| | | 131 | | |
| | | 132 | | try |
| | | 133 | | { |
| | 114 | 134 | | var rawTitle = element.TryGetProperty("title", out var titleProp) && titleProp.GetString() is { } ts |
| | 114 | 135 | | ? TrackerImportTextSanitizer.SanitizePlainText(ts)?.Trim() |
| | 114 | 136 | | : null; |
| | 114 | 137 | | var rawCompanyName = element.TryGetProperty("company", out var compProp) && compProp.GetString() is |
| | 114 | 138 | | ? TrackerImportTextSanitizer.SanitizePlainText(cs)?.Trim() |
| | 114 | 139 | | : null; |
| | | 140 | | |
| | 114 | 141 | | if (string.IsNullOrWhiteSpace(rawTitle) || string.IsNullOrWhiteSpace(rawCompanyName)) |
| | | 142 | | { |
| | 4 | 143 | | context.Summary.Errors.Add(new TrackerImportRowError( |
| | 4 | 144 | | "postings.json", |
| | 4 | 145 | | entryOrdinal, |
| | 4 | 146 | | ErrorCode.ValidationError.ToString(), |
| | 4 | 147 | | "Missing required title or company")); |
| | 4 | 148 | | recon.RecordErrored(); |
| | 4 | 149 | | continue; |
| | | 150 | | } |
| | | 151 | | |
| | 110 | 152 | | var title = TrackerImportFieldLimiter.LimitTitle(rawTitle, context.Summary)!; |
| | 110 | 153 | | var canonicalName = context.CompanyAliases.TryGetValue(rawCompanyName, out var alias) ? alias : rawC |
| | 110 | 154 | | canonicalName = TrackerImportFieldLimiter.LimitCompanyName(canonicalName, context.Summary)!; |
| | | 155 | | |
| | | 156 | | // 2. Parse Culture and CultureLevel |
| | 110 | 157 | | string? cultureSummary = null; |
| | 110 | 158 | | if (element.TryGetProperty("culture", out var cultProp) && cultProp.GetString() is { } cultStr) |
| | | 159 | | { |
| | 34 | 160 | | var decodedCult = TrackerImportTextSanitizer.SanitizeFreeText(cultStr); |
| | 34 | 161 | | cultureSummary = TrackerImportFieldLimiter.LimitCultureSummary(decodedCult, context.Summary); |
| | | 162 | | } |
| | | 163 | | |
| | 110 | 164 | | var cultureLevel = CultureLevel.Unknown; |
| | 110 | 165 | | if (element.TryGetProperty("cultureLevel", out var cultLvlProp) && cultLvlProp.GetString() is { } cu |
| | | 166 | | { |
| | 30 | 167 | | var decodedCultLvl = TrackerImportTextSanitizer.SanitizePlainText(cultLvlStr); |
| | 30 | 168 | | if (!string.IsNullOrWhiteSpace(decodedCultLvl)) |
| | | 169 | | { |
| | 30 | 170 | | var s = decodedCultLvl.Trim().ToLowerInvariant().Replace('-', '_').Replace(' ', '_'); |
| | 30 | 171 | | cultureLevel = s switch |
| | 30 | 172 | | { |
| | 16 | 173 | | "stable" => CultureLevel.Stable, |
| | 8 | 174 | | "moderate" => CultureLevel.Moderate, |
| | 4 | 175 | | "high_risk" or "highrisk" => CultureLevel.HighRisk, |
| | 0 | 176 | | "unknown" => CultureLevel.Unknown, |
| | 2 | 177 | | _ => FallbackCultureLevel(context, cultLvlStr) |
| | 30 | 178 | | }; |
| | | 179 | | } |
| | | 180 | | } |
| | | 181 | | |
| | 110 | 182 | | var remoteType = RemoteType.Unknown; |
| | 110 | 183 | | if (element.TryGetProperty("remoteType", out var remProp) && remProp.GetString() is { } remStr) |
| | | 184 | | { |
| | 0 | 185 | | var decodedRem = TrackerImportTextSanitizer.SanitizePlainText(remStr); |
| | 0 | 186 | | if (!string.IsNullOrWhiteSpace(decodedRem)) |
| | | 187 | | { |
| | 0 | 188 | | var s = decodedRem.Trim().ToLowerInvariant().Replace('-', '_').Replace(' ', '_'); |
| | 0 | 189 | | remoteType = s switch |
| | 0 | 190 | | { |
| | 0 | 191 | | "remote" => RemoteType.Remote, |
| | 0 | 192 | | "hybrid" => RemoteType.Hybrid, |
| | 0 | 193 | | "onsite" => RemoteType.Onsite, |
| | 0 | 194 | | "unknown" => RemoteType.Unknown, |
| | 0 | 195 | | _ => FallbackRemoteType(context, remStr) |
| | 0 | 196 | | }; |
| | | 197 | | } |
| | | 198 | | } |
| | | 199 | | |
| | | 200 | | // 3. Parse Score (flag and store empty if out of range, do not clamp) |
| | 110 | 201 | | double? score = null; |
| | 110 | 202 | | if (element.TryGetProperty("score", out var scoreProp) && scoreProp.TryGetDouble(out var rawScore)) |
| | | 203 | | { |
| | 44 | 204 | | if (rawScore is < 0.0 or > 10.0) |
| | | 205 | | { |
| | 12 | 206 | | score = null; |
| | 12 | 207 | | context.Summary.DatesFlagged++; // Track out of range score flag |
| | | 208 | | } |
| | | 209 | | else |
| | | 210 | | { |
| | 32 | 211 | | score = rawScore; |
| | | 212 | | } |
| | | 213 | | } |
| | | 214 | | |
| | | 215 | | // 4. Parse Dates |
| | 110 | 216 | | var addedRaw = element.TryGetProperty("added", out var addedProp) && addedProp.GetString() is { } as |
| | 110 | 217 | | ? TrackerImportTextSanitizer.SanitizePlainText(as1)?.Trim() |
| | 110 | 218 | | : (element.TryGetProperty("first", out var firstProp) && firstProp.GetString() is { } as2 ? Trac |
| | | 219 | | |
| | 110 | 220 | | var dateOutcome = DateInferenceRule.Resolve(addedRaw, defaultDate); |
| | 172 | 221 | | if (dateOutcome.Kind == DateResolutionKind.DefaultedBlank) context.Summary.DatesDefaulted++; |
| | 110 | 222 | | if (dateOutcome.Kind is DateResolutionKind.InferredRollback or DateResolutionKind.InferredSameYear) |
| | 110 | 223 | | if (dateOutcome.IsFlagged) context.Summary.DatesFlagged++; |
| | | 224 | | |
| | 110 | 225 | | var rawCompText = element.TryGetProperty("comp", out var cProp) && cProp.GetString() is { } cp |
| | 110 | 226 | | ? TrackerImportTextSanitizer.SanitizePlainText(cp)?.Trim() |
| | 110 | 227 | | : null; |
| | 110 | 228 | | var compText = TrackerImportFieldLimiter.LimitCompensationText(rawCompText, context.Summary); |
| | 110 | 229 | | var (compMin, compMax) = TryParseCompensationRange(compText); |
| | | 230 | | |
| | 110 | 231 | | bool? compHigh = null; |
| | 110 | 232 | | if (element.TryGetProperty("compHigh", out var chProp) && |
| | 110 | 233 | | chProp.ValueKind is JsonValueKind.True or JsonValueKind.False) |
| | | 234 | | { |
| | 22 | 235 | | compHigh = chProp.GetBoolean(); |
| | | 236 | | } |
| | | 237 | | |
| | 110 | 238 | | var rawReqId = element.TryGetProperty("req_id", out var reqProp) && reqProp.GetString() is { } rs1 |
| | 110 | 239 | | ? TrackerImportTextSanitizer.SanitizePlainText(rs1)?.Trim() |
| | 110 | 240 | | : (element.TryGetProperty("requisitionId", out var reqProp2) && reqProp2.GetString() is { } rs2 |
| | 110 | 241 | | var reqId = TrackerImportFieldLimiter.LimitRequisitionId(rawReqId, context.Summary); |
| | | 242 | | |
| | 110 | 243 | | var rawUrl = element.TryGetProperty("href", out var hrefProp) && hrefProp.GetString() is { } us1 |
| | 110 | 244 | | ? TrackerImportTextSanitizer.SanitizePlainText(us1)?.Trim() |
| | 110 | 245 | | : (element.TryGetProperty("url", out var urlProp) && urlProp.GetString() is { } us2 ? TrackerImp |
| | 110 | 246 | | var url = TrackerImportFieldLimiter.LimitUrl(rawUrl, context.Summary); |
| | | 247 | | |
| | 110 | 248 | | var rawLoc = element.TryGetProperty("loc", out var locProp) && locProp.GetString() is { } ls1 |
| | 110 | 249 | | ? TrackerImportTextSanitizer.SanitizePlainText(ls1)?.Trim() |
| | 110 | 250 | | : (element.TryGetProperty("location", out var locProp2) && locProp2.GetString() is { } ls2 ? Tra |
| | 110 | 251 | | var location = TrackerImportFieldLimiter.LimitLocation(rawLoc, context.Summary); |
| | | 252 | | |
| | 110 | 253 | | var sourceKind = SourceKind.Aggregator; |
| | 110 | 254 | | if (element.TryGetProperty("source", out var srcProp) && srcProp.GetString() is { } srcStr && |
| | 110 | 255 | | TrackingEnumExtensions.TryParseSourceKind(TrackerImportTextSanitizer.SanitizePlainText(srcStr)?. |
| | | 256 | | { |
| | 0 | 257 | | sourceKind = parsedSrc; |
| | | 258 | | } |
| | | 259 | | |
| | 110 | 260 | | var rawPosted = element.TryGetProperty("posted", out var pProp) && pProp.GetString() is { } ps |
| | 110 | 261 | | ? TrackerImportTextSanitizer.SanitizePlainText(ps)?.Trim() |
| | 110 | 262 | | : null; |
| | | 263 | | |
| | 110 | 264 | | var rawNote = element.TryGetProperty("note", out var noteProp) && noteProp.GetString() is { } ns |
| | 110 | 265 | | ? TrackerImportTextSanitizer.SanitizeFreeText(ns)?.Trim() |
| | 110 | 266 | | : null; |
| | | 267 | | |
| | 110 | 268 | | var candidateSignals = ParseGhostSignals(element, context); |
| | | 269 | | |
| | | 270 | | // Postings with status "applied" are imported with disposition "scored" |
| | 110 | 271 | | var rawStatus = element.TryGetProperty("status", out var stProp) && stProp.GetString() is { } stStr |
| | 110 | 272 | | ? TrackerImportTextSanitizer.SanitizePlainText(stStr)?.Trim() |
| | 110 | 273 | | : null; |
| | 110 | 274 | | var originalWasApplied = string.Equals(rawStatus, "applied", StringComparison.OrdinalIgnoreCase); |
| | | 275 | | |
| | | 276 | | // 1. Resolve or auto-create company, and 2. Save posting atomically inside one transaction per row |
| | 110 | 277 | | var autoCreatedCompany = false; |
| | 110 | 278 | | var isNewlyCreated = false; |
| | 110 | 279 | | var signalsCreatedInRow = 0; |
| | 110 | 280 | | var notesCreatedInRow = 0; |
| | 110 | 281 | | Company? newCompany = null; |
| | 110 | 282 | | Company? updatedCompany = null; |
| | 110 | 283 | | Posting? newPosting = null; |
| | | 284 | | |
| | 110 | 285 | | var parentText = element.TryGetProperty("parent", out var parentProp) && parentProp.GetString() is { |
| | 110 | 286 | | ? TrackerImportTextSanitizer.SanitizeFreeText(parStr)?.Trim() |
| | 110 | 287 | | : null; |
| | | 288 | | |
| | 110 | 289 | | var rowResult = await _context.ExecuteInTransactionAsync(async (txCtx, ct) => |
| | 110 | 290 | | { |
| | 110 | 291 | | signalsCreatedInRow = 0; |
| | 110 | 292 | | notesCreatedInRow = 0; |
| | 110 | 293 | | Company? resolvedCompany = null; |
| | 110 | 294 | | if (!context.CanonicalCompanies.TryGetValue(canonicalName, out resolvedCompany)) |
| | 110 | 295 | | { |
| | 58 | 296 | | var existing = await txCtx.Companies.GetByNormalizedNameAsync(context.OwnerId, canonicalName |
| | 58 | 297 | | if (existing.IsSuccess && existing.Value is not null) |
| | 110 | 298 | | { |
| | 16 | 299 | | resolvedCompany = existing.Value; |
| | 110 | 300 | | } |
| | 110 | 301 | | else |
| | 110 | 302 | | { |
| | 42 | 303 | | string description = string.Empty; |
| | 42 | 304 | | if (!string.IsNullOrWhiteSpace(parentText)) |
| | 110 | 305 | | { |
| | 14 | 306 | | if (parentText.Length <= Company.MaxDescriptionLength) |
| | 110 | 307 | | { |
| | 14 | 308 | | description = parentText; |
| | 110 | 309 | | } |
| | 110 | 310 | | else |
| | 110 | 311 | | { |
| | 0 | 312 | | context.Summary.RecordFieldTruncation("company_description"); |
| | 110 | 313 | | } |
| | 110 | 314 | | } |
| | 110 | 315 | | |
| | 42 | 316 | | resolvedCompany = Company.Create( |
| | 42 | 317 | | ownerId: context.OwnerId, |
| | 42 | 318 | | name: canonicalName, |
| | 42 | 319 | | status: CompanyStatus.Neutral, |
| | 42 | 320 | | description: description); |
| | 110 | 321 | | |
| | 42 | 322 | | var saveCompany = await txCtx.Companies.UpsertCompanyAsync(resolvedCompany, ct); |
| | 42 | 323 | | if (!saveCompany.IsSuccess) |
| | 110 | 324 | | { |
| | 0 | 325 | | return Result<bool>.Failure(saveCompany.Error ?? new ResultError(ErrorCode.Validatio |
| | 110 | 326 | | } |
| | 110 | 327 | | |
| | 42 | 328 | | var audit = AuditLogEntry.CreateForTracking( |
| | 42 | 329 | | ownerId: context.OwnerId, |
| | 42 | 330 | | actor: ImportActor, |
| | 42 | 331 | | operation: AuditOperation.ImportCompanyCreate, |
| | 42 | 332 | | entityType: "company", |
| | 42 | 333 | | entityId: resolvedCompany.Id, |
| | 42 | 334 | | resultingVersionToken: resolvedCompany.VersionToken, |
| | 42 | 335 | | occurredAtUtc: DateTime.UtcNow, |
| | 42 | 336 | | details: new AuditDetails( |
| | 42 | 337 | | ChangedFields: ["name", "status", "description"], |
| | 42 | 338 | | After: new Dictionary<string, object?> |
| | 42 | 339 | | { |
| | 42 | 340 | | ["name"] = resolvedCompany.Name, |
| | 42 | 341 | | ["status"] = resolvedCompany.Status.ToString(), |
| | 42 | 342 | | ["description"] = resolvedCompany.Description |
| | 42 | 343 | | })); |
| | 42 | 344 | | await txCtx.AppendAuditEntryAsync(audit, ct); |
| | 42 | 345 | | autoCreatedCompany = true; |
| | 42 | 346 | | newCompany = resolvedCompany; |
| | 110 | 347 | | } |
| | 110 | 348 | | } |
| | 110 | 349 | | |
| | 110 | 350 | | if (!autoCreatedCompany && resolvedCompany is not null) |
| | 110 | 351 | | { |
| | 68 | 352 | | updatedCompany = resolvedCompany; |
| | 68 | 353 | | if (!string.IsNullOrWhiteSpace(parentText)) |
| | 110 | 354 | | { |
| | 18 | 355 | | var currentDesc = resolvedCompany.Description; |
| | 18 | 356 | | if (string.IsNullOrWhiteSpace(currentDesc)) |
| | 110 | 357 | | { |
| | 0 | 358 | | if (parentText.Length <= Company.MaxDescriptionLength) |
| | 110 | 359 | | { |
| | 0 | 360 | | resolvedCompany.Update(description: parentText); |
| | 0 | 361 | | var updateRes = await txCtx.Companies.UpsertCompanyAsync(resolvedCompany, ct); |
| | 0 | 362 | | if (!updateRes.IsSuccess) |
| | 110 | 363 | | { |
| | 0 | 364 | | return Result<bool>.Failure(updateRes.Error ?? new ResultError(ErrorCode.Val |
| | 110 | 365 | | } |
| | 110 | 366 | | |
| | 0 | 367 | | var audit = AuditLogEntry.CreateForTracking( |
| | 0 | 368 | | ownerId: context.OwnerId, |
| | 0 | 369 | | actor: ImportActor, |
| | 0 | 370 | | operation: AuditOperation.ImportCompanyUpdate, |
| | 0 | 371 | | entityType: "company", |
| | 0 | 372 | | entityId: resolvedCompany.Id, |
| | 0 | 373 | | resultingVersionToken: resolvedCompany.VersionToken, |
| | 0 | 374 | | occurredAtUtc: DateTime.UtcNow, |
| | 0 | 375 | | details: new AuditDetails( |
| | 0 | 376 | | ChangedFields: ["description"], |
| | 0 | 377 | | After: new Dictionary<string, object?> |
| | 0 | 378 | | { |
| | 0 | 379 | | ["description"] = resolvedCompany.Description |
| | 0 | 380 | | })); |
| | 0 | 381 | | await txCtx.AppendAuditEntryAsync(audit, ct); |
| | 110 | 382 | | } |
| | 110 | 383 | | else |
| | 110 | 384 | | { |
| | 0 | 385 | | context.Summary.RecordFieldTruncation("company_description"); |
| | 110 | 386 | | } |
| | 110 | 387 | | } |
| | 18 | 388 | | else if (!currentDesc.Contains(parentText, StringComparison.OrdinalIgnoreCase)) |
| | 110 | 389 | | { |
| | 10 | 390 | | var trimmed = currentDesc.TrimEnd(); |
| | 10 | 391 | | var candidate = trimmed.EndsWith(';') || trimmed.EndsWith('.') |
| | 10 | 392 | | ? $"{trimmed} {parentText}" |
| | 10 | 393 | | : $"{trimmed}; {parentText}"; |
| | 110 | 394 | | |
| | 10 | 395 | | if (candidate.Length <= Company.MaxDescriptionLength) |
| | 110 | 396 | | { |
| | 8 | 397 | | resolvedCompany.Update(description: candidate); |
| | 8 | 398 | | var updateRes = await txCtx.Companies.UpsertCompanyAsync(resolvedCompany, ct); |
| | 8 | 399 | | if (!updateRes.IsSuccess) |
| | 110 | 400 | | { |
| | 0 | 401 | | return Result<bool>.Failure(updateRes.Error ?? new ResultError(ErrorCode.Val |
| | 110 | 402 | | } |
| | 110 | 403 | | |
| | 8 | 404 | | var audit = AuditLogEntry.CreateForTracking( |
| | 8 | 405 | | ownerId: context.OwnerId, |
| | 8 | 406 | | actor: ImportActor, |
| | 8 | 407 | | operation: AuditOperation.ImportCompanyUpdate, |
| | 8 | 408 | | entityType: "company", |
| | 8 | 409 | | entityId: resolvedCompany.Id, |
| | 8 | 410 | | resultingVersionToken: resolvedCompany.VersionToken, |
| | 8 | 411 | | occurredAtUtc: DateTime.UtcNow, |
| | 8 | 412 | | details: new AuditDetails( |
| | 8 | 413 | | ChangedFields: ["description"], |
| | 8 | 414 | | After: new Dictionary<string, object?> |
| | 8 | 415 | | { |
| | 8 | 416 | | ["description"] = resolvedCompany.Description |
| | 8 | 417 | | })); |
| | 8 | 418 | | await txCtx.AppendAuditEntryAsync(audit, ct); |
| | 110 | 419 | | } |
| | 110 | 420 | | else |
| | 110 | 421 | | { |
| | 2 | 422 | | context.Summary.RecordFieldTruncation("company_description"); |
| | 110 | 423 | | } |
| | 110 | 424 | | } |
| | 110 | 425 | | } |
| | 110 | 426 | | } |
| | 110 | 427 | | |
| | 110 | 428 | | // Check existing posting |
| | 110 | 429 | | Posting? existingPosting = null; |
| | 110 | 430 | | if (!string.IsNullOrWhiteSpace(url)) |
| | 110 | 431 | | { |
| | 60 | 432 | | var normUrl = UrlNormalizer.Normalize(url); |
| | 60 | 433 | | if (normUrl is not null) |
| | 110 | 434 | | { |
| | 60 | 435 | | var byUrlRes = await txCtx.Postings.GetByDedupKeyBAsync(context.OwnerId, normUrl, ct); |
| | 60 | 436 | | if (byUrlRes.IsSuccess && byUrlRes.Value is not null) |
| | 110 | 437 | | { |
| | 8 | 438 | | existingPosting = byUrlRes.Value; |
| | 110 | 439 | | } |
| | 110 | 440 | | } |
| | 110 | 441 | | } |
| | 110 | 442 | | |
| | 110 | 443 | | if (existingPosting is null && !string.IsNullOrWhiteSpace(reqId) && resolvedCompany is not null) |
| | 110 | 444 | | { |
| | 2 | 445 | | if (context.PostingsByCompanyAndReq.TryGetValue($"{canonicalName}|{reqId}", out var cachedBy |
| | 110 | 446 | | { |
| | 0 | 447 | | existingPosting = cachedByReq; |
| | 110 | 448 | | } |
| | 110 | 449 | | else |
| | 110 | 450 | | { |
| | 2 | 451 | | var dedupC = $"{resolvedCompany.Id:D}|{reqId.Trim()}"; |
| | 2 | 452 | | var byCRes = await txCtx.Postings.GetByDedupKeyCAsync(context.OwnerId, dedupC, ct); |
| | 2 | 453 | | if (byCRes.IsSuccess && byCRes.Value is not null) |
| | 110 | 454 | | { |
| | 0 | 455 | | existingPosting = byCRes.Value; |
| | 110 | 456 | | } |
| | 110 | 457 | | } |
| | 110 | 458 | | } |
| | 110 | 459 | | |
| | 110 | 460 | | if (existingPosting is null && resolvedCompany is not null) |
| | 110 | 461 | | { |
| | 102 | 462 | | var normTitle = TitleNormalizer.Normalize(title); |
| | 102 | 463 | | if (context.PostingsByCompanyAndTitle.TryGetValue($"{canonicalName}|{normTitle}", out var ca |
| | 110 | 464 | | { |
| | 4 | 465 | | existingPosting = cached; |
| | 110 | 466 | | } |
| | 110 | 467 | | else |
| | 110 | 468 | | { |
| | 98 | 469 | | var candRes = await txCtx.Postings.FindCandidatesByCompanyAndTitleAsync(context.OwnerId, |
| | 98 | 470 | | if (candRes.IsSuccess && candRes.Value is { Count: > 0 } candidates) |
| | 110 | 471 | | { |
| | 16 | 472 | | var byIdRes = await txCtx.Postings.GetByIdAsync(context.OwnerId, candidates[0].Id, c |
| | 16 | 473 | | if (byIdRes.IsSuccess && byIdRes.Value is not null) |
| | 110 | 474 | | { |
| | 16 | 475 | | existingPosting = byIdRes.Value; |
| | 110 | 476 | | } |
| | 110 | 477 | | } |
| | 110 | 478 | | } |
| | 110 | 479 | | } |
| | 110 | 480 | | |
| | 110 | 481 | | if (existingPosting is not null) |
| | 110 | 482 | | { |
| | 28 | 483 | | newPosting = existingPosting; |
| | 28 | 484 | | isNewlyCreated = false; |
| | 110 | 485 | | } |
| | 110 | 486 | | else |
| | 110 | 487 | | { |
| | 82 | 488 | | Guid? screeningNoteId = null; |
| | 82 | 489 | | if (!string.IsNullOrWhiteSpace(rawNote) && resolvedCompany is not null) |
| | 110 | 490 | | { |
| | 24 | 491 | | var noteTitle = TrackerImportFieldLimiter.LimitNoteTitle($"Assessment: {canonicalName} - |
| | 24 | 492 | | ?? $"Assessment: {canonicalName} - {title}"; |
| | 24 | 493 | | var noteBody = TrackerImportFieldLimiter.LimitNoteBody(rawNote, context.Summary) ?? stri |
| | 110 | 494 | | |
| | 24 | 495 | | var existingNoteRes = await txCtx.GetNoteIdByTitleAndAreaAsync(context.OwnerId, noteTitl |
| | 24 | 496 | | if (existingNoteRes.IsSuccess && existingNoteRes.Value.HasValue) |
| | 110 | 497 | | { |
| | 0 | 498 | | screeningNoteId = existingNoteRes.Value.Value; |
| | 110 | 499 | | } |
| | 110 | 500 | | else |
| | 110 | 501 | | { |
| | 24 | 502 | | var noteDateStr = dateOutcome.ResolvedDate.ToString("yyyy-MM-dd", CultureInfo.Invari |
| | 24 | 503 | | var note = Note.Create( |
| | 24 | 504 | | ownerId: context.OwnerId, |
| | 24 | 505 | | title: noteTitle, |
| | 24 | 506 | | body: noteBody, |
| | 24 | 507 | | tags: ["imported"], |
| | 24 | 508 | | area: "job-search", |
| | 24 | 509 | | provenance: new ProvenanceMarker(RoleRadar.Domain.Notes.ProvenanceKind.Stated, n |
| | 24 | 510 | | createdAtUtc: dateOutcome.ResolvedDate.ToDateTime(TimeOnly.MinValue, DateTimeKin |
| | 110 | 511 | | |
| | 24 | 512 | | var saveNote = await txCtx.UpsertNoteAsync(note, ct); |
| | 24 | 513 | | if (!saveNote.IsSuccess) |
| | 110 | 514 | | { |
| | 0 | 515 | | return Result<bool>.Failure(saveNote.Error ?? new ResultError(ErrorCode.Validati |
| | 110 | 516 | | } |
| | 110 | 517 | | |
| | 24 | 518 | | var noteAudit = AuditLogEntry.CreateForImportCreate( |
| | 24 | 519 | | ownerId: context.OwnerId, |
| | 24 | 520 | | actor: ImportActor, |
| | 24 | 521 | | targetNoteId: note.Id, |
| | 24 | 522 | | resultingVersionToken: note.VersionToken, |
| | 24 | 523 | | resolvedDefaultDate: defaultDate.ToString("yyyy-MM-dd", CultureInfo.InvariantCul |
| | 24 | 524 | | occurredAtUtc: DateTime.UtcNow, |
| | 24 | 525 | | afterSummary: AuditContentSummary.FromNote(note)); |
| | 24 | 526 | | await txCtx.AppendAuditEntryAsync(noteAudit, ct); |
| | 110 | 527 | | |
| | 24 | 528 | | screeningNoteId = note.Id; |
| | 24 | 529 | | notesCreatedInRow++; |
| | 24 | 530 | | } |
| | 24 | 531 | | } |
| | 110 | 532 | | |
| | 82 | 533 | | var posting = Posting.Create( |
| | 82 | 534 | | ownerId: context.OwnerId, |
| | 82 | 535 | | companyId: resolvedCompany?.Id ?? Guid.NewGuid(), |
| | 82 | 536 | | title: title, |
| | 82 | 537 | | sourceKind: sourceKind, |
| | 82 | 538 | | originalUrl: url, |
| | 82 | 539 | | atsTenant: null, |
| | 82 | 540 | | requisitionId: reqId, |
| | 82 | 541 | | location: location, |
| | 82 | 542 | | remoteType: remoteType, |
| | 82 | 543 | | compensation: compText != null ? new Compensation(compMin, compMax, "USD", compText) : n |
| | 82 | 544 | | postedDate: rawPosted, |
| | 82 | 545 | | score: (decimal?)score, |
| | 82 | 546 | | cultureLevel: cultureLevel, |
| | 82 | 547 | | cultureSummary: cultureSummary, |
| | 82 | 548 | | disposition: PostingDisposition.Scored, |
| | 82 | 549 | | screeningNoteId: screeningNoteId, |
| | 82 | 550 | | now: dateOutcome.ResolvedDate.ToDateTime(TimeOnly.MinValue, DateTimeKind.Utc), |
| | 82 | 551 | | compHighPriority: compHigh); |
| | 110 | 552 | | |
| | 82 | 553 | | var savePosting = await txCtx.Postings.UpsertPostingAsync(posting, ct); |
| | 82 | 554 | | if (!savePosting.IsSuccess) |
| | 110 | 555 | | { |
| | 0 | 556 | | return Result<bool>.Failure(savePosting.Error ?? new ResultError(ErrorCode.ValidationErr |
| | 110 | 557 | | } |
| | 110 | 558 | | |
| | 82 | 559 | | var changedFields = new List<string> { "title", "company_id", "disposition" }; |
| | 82 | 560 | | var afterDetails = new Dictionary<string, object?> |
| | 82 | 561 | | { |
| | 82 | 562 | | ["title"] = posting.Title, |
| | 82 | 563 | | ["disposition"] = posting.Disposition.ToString() |
| | 82 | 564 | | }; |
| | 82 | 565 | | if (!string.IsNullOrWhiteSpace(slug)) |
| | 110 | 566 | | { |
| | 82 | 567 | | changedFields.Add("slug"); |
| | 82 | 568 | | afterDetails["slug"] = slug; |
| | 110 | 569 | | } |
| | 82 | 570 | | if (!string.IsNullOrWhiteSpace(rawNote)) |
| | 110 | 571 | | { |
| | 24 | 572 | | changedFields.Add("note"); |
| | 24 | 573 | | afterDetails["note"] = rawNote; |
| | 110 | 574 | | } |
| | 82 | 575 | | if (screeningNoteId.HasValue) |
| | 110 | 576 | | { |
| | 24 | 577 | | changedFields.Add("screening_note_id"); |
| | 24 | 578 | | afterDetails["screening_note_id"] = screeningNoteId.Value; |
| | 110 | 579 | | } |
| | 110 | 580 | | |
| | 82 | 581 | | var auditP = AuditLogEntry.CreateForTracking( |
| | 82 | 582 | | ownerId: context.OwnerId, |
| | 82 | 583 | | actor: ImportActor, |
| | 82 | 584 | | operation: AuditOperation.ImportPostingCreate, |
| | 82 | 585 | | entityType: "posting", |
| | 82 | 586 | | entityId: posting.Id, |
| | 82 | 587 | | resultingVersionToken: posting.VersionToken, |
| | 82 | 588 | | occurredAtUtc: DateTime.UtcNow, |
| | 82 | 589 | | details: new AuditDetails( |
| | 82 | 590 | | ChangedFields: changedFields, |
| | 82 | 591 | | After: afterDetails)); |
| | 82 | 592 | | await txCtx.AppendAuditEntryAsync(auditP, ct); |
| | 110 | 593 | | |
| | 82 | 594 | | newPosting = posting; |
| | 82 | 595 | | isNewlyCreated = true; |
| | 82 | 596 | | } |
| | 110 | 597 | | |
| | 110 | 598 | | if (candidateSignals.Count > 0 && newPosting is not null) |
| | 110 | 599 | | { |
| | 40 | 600 | | var signalsRes = await txCtx.Postings.GetSignalsAsync(context.OwnerId, newPosting.Id, ct); |
| | 40 | 601 | | var existingSignals = signalsRes.IsSuccess && signalsRes.Value is not null |
| | 40 | 602 | | ? signalsRes.Value |
| | 40 | 603 | | : Array.Empty<PostingSignal>(); |
| | 110 | 604 | | |
| | 200 | 605 | | foreach (var sig in candidateSignals) |
| | 110 | 606 | | { |
| | 60 | 607 | | var alreadyPresent = existingSignals.Any(e => |
| | 92 | 608 | | e.SignalType == sig.Type && |
| | 92 | 609 | | string.Equals(e.DeadlineDate, sig.DeadlineDate, StringComparison.Ordinal)); |
| | 110 | 610 | | |
| | 60 | 611 | | if (!alreadyPresent) |
| | 110 | 612 | | { |
| | 36 | 613 | | var signalEntity = new PostingSignal( |
| | 36 | 614 | | id: Guid.CreateVersion7(), |
| | 36 | 615 | | ownerId: context.OwnerId, |
| | 36 | 616 | | postingId: newPosting.Id, |
| | 36 | 617 | | signalType: sig.Type, |
| | 36 | 618 | | evidence: sig.Evidence, |
| | 36 | 619 | | observedAt: dateOutcome.ResolvedDate.ToDateTime(TimeOnly.MinValue, DateTimeKind. |
| | 36 | 620 | | deadlineDate: sig.DeadlineDate); |
| | 36 | 621 | | var appendRes = await txCtx.Postings.AppendSignalAsync(signalEntity, ct); |
| | 36 | 622 | | if (!appendRes.IsSuccess) |
| | 110 | 623 | | { |
| | 0 | 624 | | return Result<bool>.Failure(appendRes.Error ?? new ResultError(ErrorCode.Validat |
| | 110 | 625 | | } |
| | 110 | 626 | | |
| | 36 | 627 | | var changed = new List<string> { "signals" }; |
| | 36 | 628 | | var afterDetails = new Dictionary<string, object?> |
| | 36 | 629 | | { |
| | 36 | 630 | | ["signal_type"] = sig.Type.ToString() |
| | 36 | 631 | | }; |
| | 36 | 632 | | if (sig.DeadlineDate is not null) |
| | 110 | 633 | | { |
| | 6 | 634 | | changed.Add("deadline_date"); |
| | 6 | 635 | | afterDetails["deadline_date"] = sig.DeadlineDate; |
| | 110 | 636 | | } |
| | 110 | 637 | | |
| | 36 | 638 | | var signalAudit = AuditLogEntry.CreateForTracking( |
| | 36 | 639 | | ownerId: context.OwnerId, |
| | 36 | 640 | | actor: ImportActor, |
| | 36 | 641 | | operation: AuditOperation.ImportPostingSignalAppend, |
| | 36 | 642 | | entityType: "posting", |
| | 36 | 643 | | entityId: newPosting.Id, |
| | 36 | 644 | | resultingVersionToken: newPosting.VersionToken, |
| | 36 | 645 | | occurredAtUtc: DateTime.UtcNow, |
| | 36 | 646 | | details: new AuditDetails( |
| | 36 | 647 | | ChangedFields: changed, |
| | 36 | 648 | | After: afterDetails)); |
| | 36 | 649 | | await txCtx.AppendAuditEntryAsync(signalAudit, ct); |
| | 36 | 650 | | signalsCreatedInRow++; |
| | 110 | 651 | | } |
| | 60 | 652 | | } |
| | 40 | 653 | | } |
| | 110 | 654 | | |
| | 110 | 655 | | return Result<bool>.Success(true); |
| | 220 | 656 | | }, cancellationToken); |
| | | 657 | | |
| | 110 | 658 | | if (!rowResult.IsSuccess) |
| | | 659 | | { |
| | 0 | 660 | | context.Summary.Errors.Add(new TrackerImportRowError( |
| | 0 | 661 | | "postings.json", |
| | 0 | 662 | | entryOrdinal, |
| | 0 | 663 | | rowResult.Error?.Code.ToString() ?? ErrorCode.ValidationError.ToString(), |
| | 0 | 664 | | rowResult.Error?.Message ?? "Failed to save posting")); |
| | 0 | 665 | | recon.RecordErrored(); |
| | 0 | 666 | | continue; |
| | | 667 | | } |
| | | 668 | | |
| | 110 | 669 | | context.Summary.SignalsCreated += signalsCreatedInRow; |
| | 110 | 670 | | context.Summary.ScreeningNotesCreated += notesCreatedInRow; |
| | | 671 | | |
| | 110 | 672 | | if (autoCreatedCompany && newCompany is not null) |
| | | 673 | | { |
| | 42 | 674 | | context.CanonicalCompanies[canonicalName] = newCompany; |
| | 42 | 675 | | context.Summary.CompaniesCreated++; |
| | 42 | 676 | | context.Summary.AutoCreatedCompanies.Add(canonicalName); |
| | | 677 | | } |
| | 68 | 678 | | else if (updatedCompany is not null) |
| | | 679 | | { |
| | 68 | 680 | | context.CanonicalCompanies[canonicalName] = updatedCompany; |
| | | 681 | | } |
| | | 682 | | |
| | 110 | 683 | | if (newPosting is not null) |
| | | 684 | | { |
| | 110 | 685 | | context.IndexPosting(newPosting, canonicalName); |
| | | 686 | | |
| | 110 | 687 | | if (isNewlyCreated) |
| | | 688 | | { |
| | 82 | 689 | | context.Summary.PostingsCreated++; |
| | 82 | 690 | | recon.RecordCreated(); |
| | | 691 | | |
| | 82 | 692 | | if (originalWasApplied) |
| | | 693 | | { |
| | 34 | 694 | | context.Summary.UnclaimedAppliedPostingTitles.Add(newPosting.Title); |
| | 34 | 695 | | context.Summary.UnclaimedAppliedPostings++; |
| | | 696 | | } |
| | | 697 | | } |
| | | 698 | | else |
| | | 699 | | { |
| | 28 | 700 | | context.Summary.PostingsUnchanged++; |
| | 28 | 701 | | recon.RecordUnchanged(); |
| | | 702 | | } |
| | | 703 | | } |
| | 110 | 704 | | } |
| | 0 | 705 | | catch (Exception ex) when (ex is not OperationCanceledException) |
| | | 706 | | { |
| | 0 | 707 | | context.Summary.Errors.Add(new TrackerImportRowError( |
| | 0 | 708 | | "postings.json", |
| | 0 | 709 | | entryOrdinal, |
| | 0 | 710 | | ErrorCode.ValidationError.ToString(), |
| | 0 | 711 | | ex.Message)); |
| | 0 | 712 | | recon.RecordErrored(); |
| | 0 | 713 | | } |
| | 110 | 714 | | } |
| | 70 | 715 | | } |
| | | 716 | | |
| | 70 | 717 | | return Result<bool>.Success(true); |
| | 78 | 718 | | } |
| | | 719 | | |
| | | 720 | | public static (decimal? Min, decimal? Max) TryParseCompensationRange(string? text) |
| | | 721 | | { |
| | 248 | 722 | | if (string.IsNullOrWhiteSpace(text)) return (null, null); |
| | | 723 | | |
| | 72 | 724 | | var match = Regex.Match(text, @"(?:^|[^\d])(?:\$)?\s*(?<min>\d+(?:,\d{3})*(?:\.\d+)?)\s*(?<minUnit>k|m)?\s*(?:-| |
| | 72 | 725 | | if (match.Success) |
| | | 726 | | { |
| | 10 | 727 | | var minVal = ParseCompNumber(match.Groups["min"].Value, match.Groups["minUnit"].Value, match.Groups["maxUnit |
| | 10 | 728 | | var maxVal = ParseCompNumber(match.Groups["max"].Value, match.Groups["maxUnit"].Value, null); |
| | 10 | 729 | | if (minVal.HasValue && maxVal.HasValue) |
| | | 730 | | { |
| | 10 | 731 | | return (minVal.Value, maxVal.Value); |
| | | 732 | | } |
| | | 733 | | } |
| | | 734 | | |
| | 62 | 735 | | var singleMatch = Regex.Match(text, @"(?:^|[^\d])(?:\$)?\s*(?<val>\d+(?:,\d{3})*(?:\.\d+)?)\s*(?<unit>k|m)?", Re |
| | 62 | 736 | | if (singleMatch.Success) |
| | | 737 | | { |
| | 58 | 738 | | var val = ParseCompNumber(singleMatch.Groups["val"].Value, singleMatch.Groups["unit"].Value, null); |
| | 58 | 739 | | if (val.HasValue) |
| | | 740 | | { |
| | 58 | 741 | | return (val.Value, null); |
| | | 742 | | } |
| | | 743 | | } |
| | | 744 | | |
| | 4 | 745 | | return (null, null); |
| | | 746 | | } |
| | | 747 | | |
| | | 748 | | private static decimal? ParseCompNumber(string numStr, string unit, string? fallbackUnit) |
| | | 749 | | { |
| | 78 | 750 | | numStr = numStr.Replace(",", ""); |
| | 78 | 751 | | if (!decimal.TryParse(numStr, NumberStyles.Number, CultureInfo.InvariantCulture, out var num)) |
| | 0 | 752 | | return null; |
| | | 753 | | |
| | 78 | 754 | | var effectiveUnit = !string.IsNullOrEmpty(unit) ? unit : fallbackUnit; |
| | 78 | 755 | | if (string.Equals(effectiveUnit, "k", StringComparison.OrdinalIgnoreCase)) |
| | 22 | 756 | | num *= 1000m; |
| | 56 | 757 | | else if (string.Equals(effectiveUnit, "m", StringComparison.OrdinalIgnoreCase)) |
| | 0 | 758 | | num *= 1000000m; |
| | | 759 | | |
| | 78 | 760 | | return num; |
| | | 761 | | } |
| | | 762 | | |
| | 242 | 763 | | private readonly record struct ParsedGhostSignal(SignalType Type, string? DeadlineDate, string Evidence); |
| | | 764 | | |
| | | 765 | | private static List<ParsedGhostSignal> ParseGhostSignals(JsonElement element, TrackerImportContext context) |
| | | 766 | | { |
| | 110 | 767 | | var list = new List<ParsedGhostSignal>(); |
| | 110 | 768 | | if (!element.TryGetProperty("ghost", out var ghostProp)) |
| | | 769 | | { |
| | 56 | 770 | | return list; |
| | | 771 | | } |
| | | 772 | | |
| | 54 | 773 | | if (ghostProp.ValueKind == JsonValueKind.True) |
| | | 774 | | { |
| | 12 | 775 | | list.Add(new ParsedGhostSignal(SignalType.Phantom, null, "Imported ghost flag")); |
| | 12 | 776 | | return list; |
| | | 777 | | } |
| | | 778 | | |
| | 42 | 779 | | if (ghostProp.ValueKind == JsonValueKind.False) |
| | | 780 | | { |
| | 14 | 781 | | return list; |
| | | 782 | | } |
| | | 783 | | |
| | 28 | 784 | | if (ghostProp.ValueKind == JsonValueKind.String) |
| | | 785 | | { |
| | 28 | 786 | | var raw = TrackerImportTextSanitizer.SanitizePlainText(ghostProp.GetString()); |
| | 28 | 787 | | if (string.IsNullOrWhiteSpace(raw)) |
| | | 788 | | { |
| | 0 | 789 | | return list; |
| | | 790 | | } |
| | | 791 | | |
| | 28 | 792 | | var tokens = raw.Split((char[]?)null, StringSplitOptions.RemoveEmptyEntries); |
| | 28 | 793 | | var seen = new HashSet<(SignalType, string?)>(); |
| | | 794 | | |
| | 168 | 795 | | foreach (var rawToken in tokens) |
| | | 796 | | { |
| | 56 | 797 | | var token = rawToken.Trim(); |
| | 56 | 798 | | if (string.IsNullOrEmpty(token)) continue; |
| | | 799 | | |
| | 56 | 800 | | if (token.StartsWith("deadline:", StringComparison.OrdinalIgnoreCase)) |
| | | 801 | | { |
| | 14 | 802 | | var dateStr = token["deadline:".Length..].Trim(); |
| | 14 | 803 | | if (DateOnly.TryParseExact(dateStr, "yyyy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.None, |
| | | 804 | | { |
| | 10 | 805 | | if (seen.Add((SignalType.Deadline, dateStr))) |
| | | 806 | | { |
| | 10 | 807 | | list.Add(new ParsedGhostSignal(SignalType.Deadline, dateStr, $"Imported ghost token: {token} |
| | | 808 | | } |
| | | 809 | | } |
| | | 810 | | else |
| | | 811 | | { |
| | 4 | 812 | | context.Summary.RecordUnmappedValue("ghost", token); |
| | | 813 | | } |
| | 4 | 814 | | continue; |
| | | 815 | | } |
| | | 816 | | |
| | 42 | 817 | | var lower = token.ToLowerInvariant(); |
| | 42 | 818 | | SignalType? matchedType = lower switch |
| | 42 | 819 | | { |
| | 10 | 820 | | "repost" => SignalType.Repost, |
| | 10 | 821 | | "nosalary" => SignalType.NoSalary, |
| | 10 | 822 | | "parallel" => SignalType.ParallelPosting, |
| | 4 | 823 | | "phantom" => SignalType.Phantom, |
| | 4 | 824 | | "gone" => SignalType.Gone, |
| | 4 | 825 | | _ => null |
| | 42 | 826 | | }; |
| | | 827 | | |
| | 42 | 828 | | if (matchedType is { } st) |
| | | 829 | | { |
| | 38 | 830 | | if (seen.Add((st, null))) |
| | | 831 | | { |
| | 38 | 832 | | list.Add(new ParsedGhostSignal(st, null, $"Imported ghost token: {token}")); |
| | | 833 | | } |
| | | 834 | | } |
| | | 835 | | else |
| | | 836 | | { |
| | 4 | 837 | | context.Summary.RecordUnmappedValue("ghost", token); |
| | | 838 | | } |
| | | 839 | | } |
| | | 840 | | } |
| | | 841 | | |
| | 28 | 842 | | return list; |
| | | 843 | | } |
| | | 844 | | |
| | | 845 | | private static CultureLevel FallbackCultureLevel(TrackerImportContext context, string rawValue) |
| | | 846 | | { |
| | 2 | 847 | | context.Summary.RecordUnmappedValue("culture_level", rawValue); |
| | 2 | 848 | | return CultureLevel.Unknown; |
| | | 849 | | } |
| | | 850 | | |
| | | 851 | | private static RemoteType FallbackRemoteType(TrackerImportContext context, string rawValue) |
| | | 852 | | { |
| | 0 | 853 | | context.Summary.RecordUnmappedValue("remote_type", rawValue); |
| | 0 | 854 | | return RemoteType.Unknown; |
| | | 855 | | } |
| | | 856 | | } |