poprhythm
5fdd5fadba
This commit updates the LocationParsingConfiguration to include additional location patterns such as "Exhibit Hall *", "Mtg. Room *", and "Online". The EventOccurrenceParser has been enhanced to better handle parsing issues, including skipping comment and continuation lines, and cleaning up location text. New methods for analyzing location parsing failures and categorizing issues have been added to improve reporting. Additionally, the UI has been updated to support larger input sizes for event occurrence text, ensuring a smoother user experience during data import.
519 lines
19 KiB
C#
519 lines
19 KiB
C#
using System.Text.RegularExpressions;
|
||
using Core.Entities;
|
||
using Core.Models;
|
||
using FuzzySharp;
|
||
|
||
namespace Core.Parsers;
|
||
|
||
/// <summary>
|
||
/// Result of parsing event occurrence file, containing both occurrences and parsing issues.
|
||
/// </summary>
|
||
public class EventOccurrenceParserResult
|
||
{
|
||
public IDictionary<EventDefinition, List<EventOccurrence>> Occurrences { get; set; } = new Dictionary<EventDefinition, List<EventOccurrence>>();
|
||
public List<ParsingIssue> Issues { get; set; } = new();
|
||
}
|
||
|
||
public class EventOccurrenceParser
|
||
{
|
||
private FileSystemInfo _txtFile;
|
||
private ICollection<EventDefinition> _events;
|
||
private LocationParsingConfiguration? _locationConfig;
|
||
|
||
public EventOccurrenceParser(FileSystemInfo txtFile, ICollection<EventDefinition> events, LocationParsingConfiguration? locationConfig = null)
|
||
{
|
||
_events = events;
|
||
_txtFile = txtFile;
|
||
_locationConfig = locationConfig;
|
||
}
|
||
|
||
private Regex _re =
|
||
new (
|
||
@"" + //
|
||
@"(?<Name>^[^#].*)\s" +
|
||
@"(?<Month>February|March|April|May|June|July)\s" +
|
||
@"(?<DayOfMonth>\d{1,2});?\s" +
|
||
@"(?<TimeAndLocation>.*)"
|
||
);
|
||
|
||
private readonly Regex _timeRe = new(@"(?<Hour>\d{1,2}):?(?<Minute>\d{2})?\s?(?<APM>(?:a|p)\.?m\.?)");
|
||
|
||
// Regex to match time ranges like "10:30 a.m. - 12:00 p.m." or "10:30 a.m. - NOON"
|
||
// Matches: time1 (optional dash time2/NOON), then location
|
||
// The time group captures the full time range (including " - NOON" if present)
|
||
// Pattern breakdown:
|
||
// - First time: (?:NOON|\d{1,2}:?\d{0,2}\s*(?:[AaPp]\.?[Mm]\.?)) - matches NOON or time with AM/PM (more flexible whitespace)
|
||
// - Optional range: (?:\s*[–-]\s*(?:NOON|\d{1,2}:?\d{0,2}\s*(?:[AaPp]\.?[Mm]\.?))) - matches dash followed by NOON or time
|
||
// - Location: (?:\s+(?<Location>.+))? - optional whitespace followed by location (capture group with explicit name)
|
||
private readonly Regex _timeLocationRegex = new(@"(?<Time>(?:NOON|\d{1,2}:?\d{0,2}\s*(?:[AaPp]\.?[Mm]\.?))(?:\s*[–-]\s*(?:NOON|\d{1,2}:?\d{0,2}\s*(?:[AaPp]\.?[Mm]\.?)))?)(?:\s+(?<Location>.+))?");
|
||
|
||
public EventOccurrenceParserResult Parse()
|
||
{
|
||
var result = new EventOccurrenceParserResult();
|
||
var occurrences = result.Occurrences;
|
||
var issues = result.Issues;
|
||
EventDefinition? currentEventDefinition = null;
|
||
|
||
var lines = File.ReadLines(_txtFile.FullName);
|
||
foreach (var (line, index) in lines.Select((line, index) => (line, index + 1)))
|
||
{
|
||
var trimmedLine = line.Trim();
|
||
|
||
// Skip empty lines
|
||
if (string.IsNullOrWhiteSpace(trimmedLine))
|
||
continue;
|
||
|
||
// Skip comment lines (starting with "#")
|
||
if (trimmedLine.StartsWith("#", StringComparison.Ordinal))
|
||
continue;
|
||
|
||
var match = _re.Match(trimmedLine);
|
||
if (!match.Success)
|
||
{
|
||
if (trimmedLine.Contains("MS"))
|
||
{
|
||
var evt =
|
||
(from e in _events
|
||
let rat = Fuzz.Ratio(e.Name, trimmedLine)
|
||
where rat > 50
|
||
orderby rat descending
|
||
select e).FirstOrDefault();
|
||
if (evt == null)
|
||
{
|
||
issues.Add(new ParsingIssue
|
||
{
|
||
LineNumber = index,
|
||
LineContent = trimmedLine,
|
||
IssueType = ParsingIssueType.UnmatchedLine,
|
||
Message = $"Section header with 'MS' found but no matching event definition (best match ratio: {Fuzz.Ratio(trimmedLine, _events.FirstOrDefault()?.Name ?? "")})"
|
||
});
|
||
continue;
|
||
}
|
||
currentEventDefinition = evt;
|
||
continue;
|
||
}
|
||
if (trimmedLine == "General Schedule" || trimmedLine == "General Session")
|
||
{
|
||
currentEventDefinition = EventDefinition.GeneralSchedule;
|
||
continue;
|
||
}
|
||
|
||
// Skip continuation lines (lines that look like they're continuing from previous line)
|
||
// These are typically lines that:
|
||
// - Start with lowercase or special characters (not event names)
|
||
// - Are parenthetical notes like "(Semifinalists only)"
|
||
// - Are informational text like "Schedule Posted on..."
|
||
if (IsContinuationLine(trimmedLine))
|
||
{
|
||
continue;
|
||
}
|
||
|
||
// "Voting Delegates" section header is no longer used - occurrences are categorized by name pattern
|
||
// Track as unmatched line if it's not empty
|
||
if (!string.IsNullOrWhiteSpace(trimmedLine))
|
||
{
|
||
issues.Add(new ParsingIssue
|
||
{
|
||
LineNumber = index,
|
||
LineContent = trimmedLine,
|
||
IssueType = ParsingIssueType.UnmatchedLine,
|
||
Message = "Line does not match expected format (Name Month Day Time/Location)"
|
||
});
|
||
}
|
||
continue;
|
||
}
|
||
|
||
var occurrenceName = match.Groups["Name"].Captures[0].Value;
|
||
var month = match.Groups["Month"].Captures[0].Value;
|
||
var dayOfMonth = match.Groups["DayOfMonth"].Captures[0].Value;
|
||
var timeAndLocation = match.Groups["TimeAndLocation"].Captures[0].Value;
|
||
|
||
occurrenceName = Regex.Replace(occurrenceName,
|
||
@"(?<Weekday>Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday),\s?$", "").Trim();
|
||
|
||
// Determine event definition based on occurrence name pattern or current section
|
||
EventDefinition? eventDefinition = DetermineEventDefinition(occurrenceName, currentEventDefinition);
|
||
|
||
// Track issue if we can't determine the event definition
|
||
if (eventDefinition == null)
|
||
{
|
||
issues.Add(new ParsingIssue
|
||
{
|
||
LineNumber = index,
|
||
LineContent = trimmedLine,
|
||
IssueType = ParsingIssueType.MissingEventDefinition,
|
||
Message = $"Cannot determine event definition for occurrence: {occurrenceName}"
|
||
});
|
||
continue;
|
||
}
|
||
|
||
timeAndLocation = SanitizeInput(timeAndLocation);
|
||
|
||
// Parse time and location using configurable patterns
|
||
var (time, location, locationParseSuccess) = ParseTimeAndLocation(timeAndLocation, index, trimmedLine, issues);
|
||
|
||
// Parse date
|
||
DateOnly? startDate = null;
|
||
try
|
||
{
|
||
startDate = ParseDate(month, dayOfMonth, DateTime.Now.Year);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
issues.Add(new ParsingIssue
|
||
{
|
||
LineNumber = index,
|
||
LineContent = trimmedLine,
|
||
IssueType = ParsingIssueType.DateParseFailure,
|
||
Message = $"Failed to parse date: {ex.Message}"
|
||
});
|
||
continue;
|
||
}
|
||
|
||
// Parse time
|
||
TimeOnly? startTime = null;
|
||
try
|
||
{
|
||
startTime = ParseStartTime(time);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
issues.Add(new ParsingIssue
|
||
{
|
||
LineNumber = index,
|
||
LineContent = trimmedLine,
|
||
IssueType = ParsingIssueType.TimeParseFailure,
|
||
Message = $"Failed to parse time '{time}': {ex.Message}"
|
||
});
|
||
continue;
|
||
}
|
||
|
||
if (startDate == null || startTime == null)
|
||
continue;
|
||
|
||
var t = new DateTime(startDate.Value, startTime.Value);
|
||
|
||
var eventOccurrence = new EventOccurrence
|
||
{
|
||
Name = occurrenceName,
|
||
StartTime = t,
|
||
Time = $"{time}",
|
||
Date = $"{month} {dayOfMonth}",
|
||
Location = location
|
||
};
|
||
|
||
if (!occurrences.ContainsKey(eventDefinition))
|
||
occurrences.Add(eventDefinition, []);
|
||
occurrences[eventDefinition].Add(eventOccurrence);
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Determines the EventDefinition for an occurrence based on its name pattern or current section context.
|
||
/// </summary>
|
||
private EventDefinition? DetermineEventDefinition(string occurrenceName, EventDefinition? currentEventDefinition)
|
||
{
|
||
// Check for special event name patterns first (regardless of current section)
|
||
if (occurrenceName.Contains("Meet the Candidates Session", StringComparison.OrdinalIgnoreCase))
|
||
return EventDefinition.MeetTheCandidates;
|
||
|
||
if (occurrenceName.Contains("Chapter Officer Meeting", StringComparison.OrdinalIgnoreCase))
|
||
return EventDefinition.ChapterOfficerMeeting;
|
||
|
||
if (occurrenceName.Contains("Voting Delegate Meeting", StringComparison.OrdinalIgnoreCase))
|
||
return EventDefinition.VotingDelegateMeeting;
|
||
|
||
// If we're in a General Schedule/Session section and no pattern matched, use GeneralSchedule
|
||
if (currentEventDefinition == EventDefinition.GeneralSchedule)
|
||
return EventDefinition.GeneralSchedule;
|
||
|
||
// If we have a current event definition from section header (e.g., regular events), use it
|
||
if (currentEventDefinition != null)
|
||
return currentEventDefinition;
|
||
|
||
// Cannot determine event definition
|
||
return null;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Determines if a line is a continuation/wrapped line that should be skipped.
|
||
/// </summary>
|
||
private bool IsContinuationLine(string line)
|
||
{
|
||
var trimmed = line.Trim();
|
||
|
||
// Skip parenthetical notes
|
||
if (trimmed.StartsWith("(", StringComparison.Ordinal) && trimmed.EndsWith(")", StringComparison.Ordinal))
|
||
return true;
|
||
|
||
// Skip lines that are clearly continuation text (start with lowercase, common continuation words)
|
||
if (trimmed.Length > 0 && char.IsLower(trimmed[0]))
|
||
{
|
||
// Check if it starts with common continuation words
|
||
var continuationPrefixes = new[] { "be ", "the ", "and ", "or ", "to ", "a ", "an ", "will ", "may ", "can " };
|
||
foreach (var prefix in continuationPrefixes)
|
||
{
|
||
if (trimmed.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))
|
||
return true;
|
||
}
|
||
}
|
||
|
||
// Skip informational lines that don't contain dates/times
|
||
if (trimmed.Contains("Schedule Posted", StringComparison.OrdinalIgnoreCase) ||
|
||
trimmed.Contains("Note:", StringComparison.OrdinalIgnoreCase) ||
|
||
trimmed.Contains("*Note:", StringComparison.OrdinalIgnoreCase))
|
||
return true;
|
||
|
||
return false;
|
||
}
|
||
|
||
private string SanitizeInput(string input)
|
||
{
|
||
|
||
input = input.Replace("–", "-");
|
||
input = input.Replace("—", "-");
|
||
|
||
return input;
|
||
}
|
||
|
||
private DateOnly ParseDate(string month, string dayOfMonth, int year)
|
||
{
|
||
int monthNum = 1;
|
||
switch (month)
|
||
{
|
||
case "February":
|
||
monthNum = 2;
|
||
break;
|
||
case "March":
|
||
monthNum = 3;
|
||
break;
|
||
case "April":
|
||
monthNum = 4;
|
||
break;
|
||
case "May":
|
||
monthNum = 5;
|
||
break;
|
||
case "June":
|
||
monthNum = 6;
|
||
break;
|
||
case "July":
|
||
monthNum = 7;
|
||
break;
|
||
}
|
||
|
||
var day = int.Parse(dayOfMonth);
|
||
return new DateOnly(year, monthNum, day); ;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Parses time and location from the timeAndLocation string using configurable location patterns.
|
||
/// </summary>
|
||
private (string time, string location, bool locationParseSuccess) ParseTimeAndLocation(
|
||
string timeAndLocation,
|
||
int lineNumber,
|
||
string lineContent,
|
||
List<ParsingIssue> issues)
|
||
{
|
||
var time = timeAndLocation;
|
||
var location = string.Empty;
|
||
var locationParseSuccess = false;
|
||
|
||
// First, try to separate time from location using the time regex
|
||
var timeLocationMatch = _timeLocationRegex.Match(timeAndLocation);
|
||
|
||
if (timeLocationMatch.Success)
|
||
{
|
||
time = timeLocationMatch.Groups["Time"].Captures[0].Value.Trim();
|
||
var locationPart = timeLocationMatch.Groups["Location"].Success
|
||
? timeLocationMatch.Groups["Location"].Captures[0].Value.Trim()
|
||
: string.Empty;
|
||
|
||
if (!string.IsNullOrWhiteSpace(locationPart))
|
||
{
|
||
// Clean up location part - remove any remaining time components (e.g., "– 12:15 p.m. Exhibit Hall C" -> "Exhibit Hall C")
|
||
locationPart = CleanLocationText(locationPart);
|
||
|
||
if (!string.IsNullOrWhiteSpace(locationPart))
|
||
{
|
||
// Try to match location using configurable patterns
|
||
if (_locationConfig != null && _locationConfig.LocationPatterns.Any())
|
||
{
|
||
location = MatchLocationPattern(locationPart, _locationConfig.LocationPatterns);
|
||
locationParseSuccess = !string.IsNullOrEmpty(location);
|
||
|
||
// If pattern matching failed but location part looks valid, try matching against cleaned version
|
||
if (!locationParseSuccess && !string.IsNullOrWhiteSpace(locationPart))
|
||
{
|
||
// Some locations might not match because of extra whitespace or formatting
|
||
// Try matching the location even if initial match failed
|
||
var cleanedForMatching = locationPart.Trim();
|
||
location = MatchLocationPattern(cleanedForMatching, _locationConfig.LocationPatterns);
|
||
locationParseSuccess = !string.IsNullOrEmpty(location);
|
||
if (locationParseSuccess)
|
||
{
|
||
location = cleanedForMatching; // Use the cleaned version
|
||
}
|
||
}
|
||
}
|
||
|
||
// If no pattern matched but we have a location, use it anyway but mark as not matching pattern
|
||
// This allows parsing to continue while still tracking that the location didn't match a pattern
|
||
if (!locationParseSuccess && !string.IsNullOrWhiteSpace(locationPart))
|
||
{
|
||
location = locationPart;
|
||
// Only add issue if we have patterns configured but none matched
|
||
// This helps identify locations that might need new patterns added
|
||
if (_locationConfig != null && _locationConfig.LocationPatterns.Any())
|
||
{
|
||
issues.Add(new ParsingIssue
|
||
{
|
||
LineNumber = lineNumber,
|
||
LineContent = lineContent,
|
||
IssueType = ParsingIssueType.LocationParseFailure,
|
||
Message = $"Location '{locationPart}' does not match any configured pattern"
|
||
});
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// No location part found, which is valid (some events might not have locations)
|
||
locationParseSuccess = true; // Consider it a success since no location is needed
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// If time regex doesn't match, use the whole string as time
|
||
time = timeAndLocation.Trim();
|
||
}
|
||
|
||
return (time, location, locationParseSuccess || string.IsNullOrWhiteSpace(location));
|
||
}
|
||
|
||
/// <summary>
|
||
/// Cleans location text by removing any remaining time components.
|
||
/// Handles cases like "– 12:15 p.m. Exhibit Hall C" -> "Exhibit Hall C"
|
||
/// </summary>
|
||
private string CleanLocationText(string locationText)
|
||
{
|
||
if (string.IsNullOrWhiteSpace(locationText))
|
||
return string.Empty;
|
||
|
||
// Remove leading dashes and whitespace
|
||
locationText = locationText.TrimStart('–', '-', ' ', '\t');
|
||
|
||
// Try to match and remove time patterns at the start
|
||
// Pattern 1: Dash, whitespace, time (e.g., "– 12:15 p.m. " or "– NOON ")
|
||
var dashTimePattern = new Regex(@"^[–-]\s+(?:NOON|\d{1,2}:?\d{0,2}\s*[AaPp]\.?[Mm]\.?)\s+", RegexOptions.IgnoreCase);
|
||
locationText = dashTimePattern.Replace(locationText, "").Trim();
|
||
|
||
// Pattern 2: Time without dash at start (e.g., "12:15 p.m. " or "NOON ")
|
||
var timePatternAtStart = new Regex(@"^(?:NOON|\d{1,2}:?\d{0,2}\s*[AaPp]\.?[Mm]\.?)\s+", RegexOptions.IgnoreCase);
|
||
locationText = timePatternAtStart.Replace(locationText, "").Trim();
|
||
|
||
// Pattern 3: Any remaining dash-time combinations (more flexible)
|
||
var remainingDashTime = new Regex(@"^[–-]\s*(?:NOON|\d{1,2}:?\d{0,2}\s*[AaPp]\.?[Mm]\.?)\s*", RegexOptions.IgnoreCase);
|
||
locationText = remainingDashTime.Replace(locationText, "").Trim();
|
||
|
||
// Pattern 4: Remove any standalone time at the start (handles cases where dash was already removed)
|
||
var standaloneTime = new Regex(@"^(?:NOON|\d{1,2}:?\d{0,2}\s*[AaPp]\.?[Mm]\.?)$", RegexOptions.IgnoreCase);
|
||
if (standaloneTime.IsMatch(locationText))
|
||
return string.Empty; // If only time remains, there's no location
|
||
|
||
return locationText.Trim();
|
||
}
|
||
|
||
/// <summary>
|
||
/// Matches location text against configured patterns and returns the matched location.
|
||
/// </summary>
|
||
private string MatchLocationPattern(string locationText, List<string> patterns)
|
||
{
|
||
// Normalize location text for matching (trim and handle variations)
|
||
var normalizedLocation = locationText.Trim();
|
||
|
||
// If location is empty after normalization, return empty
|
||
if (string.IsNullOrWhiteSpace(normalizedLocation))
|
||
return string.Empty;
|
||
|
||
foreach (var pattern in patterns)
|
||
{
|
||
var normalizedPattern = pattern.Trim();
|
||
|
||
// Skip empty patterns
|
||
if (string.IsNullOrWhiteSpace(normalizedPattern))
|
||
continue;
|
||
|
||
// Handle exact matches (patterns without wildcards like "Online", "Virtual", "TBD")
|
||
if (!normalizedPattern.Contains('*'))
|
||
{
|
||
if (string.Equals(normalizedPattern, normalizedLocation, StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
return normalizedLocation;
|
||
}
|
||
continue;
|
||
}
|
||
|
||
// Convert pattern to regex: escape special chars, replace * with .*
|
||
// This handles patterns like "Exhibit Hall *", "Room *", "Mtg. Room *", etc.
|
||
var escapedPattern = Regex.Escape(normalizedPattern);
|
||
escapedPattern = escapedPattern.Replace(@"\*", ".*?");
|
||
|
||
// Use case-insensitive matching
|
||
var regex = new Regex($"^{escapedPattern}$", RegexOptions.IgnoreCase);
|
||
if (regex.IsMatch(normalizedLocation))
|
||
{
|
||
return normalizedLocation; // Return the full matched location
|
||
}
|
||
}
|
||
|
||
return string.Empty;
|
||
}
|
||
|
||
private TimeOnly ParseStartTime(string time)
|
||
{
|
||
int hour = 0;
|
||
int minute = 0;
|
||
|
||
// Handle TBD (To Be Determined) times gracefully
|
||
if (string.Equals(time.Trim(), "TBD", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
// Use a placeholder time (midnight) for TBD - the occurrence will still be created
|
||
// but with a time that indicates it's TBD
|
||
return new TimeOnly(0, 0, 0);
|
||
}
|
||
|
||
// get the part of the time before a timespan
|
||
if (time.Contains(" - "))
|
||
{
|
||
time = time[..time.IndexOf(" - ", StringComparison.Ordinal)];
|
||
|
||
}
|
||
|
||
if (time == "NOON")
|
||
hour = 12;
|
||
else
|
||
{
|
||
var timeMatch = _timeRe.Match(time.ToLower());
|
||
if (timeMatch.Success)
|
||
{
|
||
hour = int.Parse(timeMatch.Groups["Hour"].Captures[0].Value);
|
||
if (timeMatch.Groups["Minute"].Success)
|
||
{
|
||
minute = int.Parse(timeMatch.Groups["Minute"].Captures[0].Value);
|
||
}
|
||
|
||
if (timeMatch.Groups["APM"].Captures[0].Value is "p.m." or "pm" && hour < 12)
|
||
hour += 12;
|
||
}
|
||
else
|
||
{
|
||
throw new FormatException($"Time format not recognized: {time}");
|
||
}
|
||
}
|
||
|
||
return new TimeOnly(hour, minute, 0);
|
||
}
|
||
} |