feat: import leftover student fields into notes and show them on the roster

Store leftover CSV columns on hidden student notes, move catalog import to /events/import, and persist Students index columns from Chapter Settings.

Co-authored-by: Cursor <cursoragent@cursor.com>

Core/Parsers/FuzzyStudentMatcher.cs

@@ -0,0 +1,29 @@
+using Core.Entities;
+using FuzzySharp;
+
+namespace Core.Parsers;
+
+/// <summary>
+/// Fuzzy-matches a CSV or pasted name to existing students.
+/// </summary>
+public static class FuzzyStudentMatcher
+{
+    public const int MatchThreshold = 90;
+
+    public static (Student Student, int Score)? Find(ICollection<Student> students, string name)
+    {
+        var ranked = students
+            .Select(s => (Student: s, Score: Score(s, name)))
+            .Where(x => x.Score >= MatchThreshold)
+            .OrderByDescending(x => x.Score)
+            .ToList();
+
+        return ranked.Count == 0 ? null : ranked[0];
+    }
+
+    public static int Score(Student student, string name)
+    {
+        var candidates = new[] { student.Name, student.FirstNameLastName, student.LastNameFirstName };
+        return candidates.Max(candidate => Math.Max(Fuzz.Ratio(candidate, name), Fuzz.TokenSetRatio(candidate, name)));
+    }
+}

Core/Parsers/StudentEventRankingParser.cs

@@ -6,7 +6,6 @@ namespace Core.Parsers;
 
 public class StudentEventRankingParser : CsvParserBase
 {
-    public const int StudentMatchThreshold = 90;
     public const int EventMatchThreshold = 70;
     public const int EventAmbiguityGap = 8;
 
@@ -60,7 +59,7 @@ public class StudentEventRankingParser : CsvParserBase
             if (string.IsNullOrEmpty(name))
                 continue;
 
-            var studentMatch = FindStudent(students, name);
+            var studentMatch = FuzzyStudentMatcher.Find(students, name);
             if (studentMatch is null)
             {
                 result.Issues.Add(new StudentEventRankingIssue
@@ -172,23 +171,6 @@ public class StudentEventRankingParser : CsvParserBase
         return result;
     }
 
-    private static (Student Student, int Score)? FindStudent(ICollection<Student> students, string name)
-    {
-        var ranked = students
-            .Select(s => (Student: s, Score: ScoreStudent(s, name)))
-            .Where(x => x.Score >= StudentMatchThreshold)
-            .OrderByDescending(x => x.Score)
-            .ToList();
-
-        return ranked.Count == 0 ? null : ranked[0];
-    }
-
-    private static int ScoreStudent(Student student, string name)
-    {
-        var candidates = new[] { student.Name, student.FirstNameLastName, student.LastNameFirstName };
-        return candidates.Max(candidate => Math.Max(Fuzz.Ratio(candidate, name), Fuzz.TokenSetRatio(candidate, name)));
-    }
-
     private static EventResolution ResolveEvent(ICollection<EventDefinition> events, string eventName)
     {
         var scored = events

Core/Parsers/StudentImportCsvTemplate.cs

@@ -0,0 +1,63 @@
+using Core.Notes;
+
+namespace Core.Parsers;
+
+/// <summary>
+/// Builds a starter CSV for <c>/students/import</c> with roster columns plus leftover note fields.
+/// </summary>
+public static class StudentImportCsvTemplate
+{
+    public static readonly string[] RosterHeaders =
+    [
+        "Student Name",
+        "Grade",
+        "TSA year",
+        "State ID",
+        "Regional ID",
+        "National ID"
+    ];
+
+    /// <summary>
+    /// Returns a CSV with a header row and one example data row.
+    /// </summary>
+    public static string Build(IEnumerable<string>? leftoverFieldNames = null)
+    {
+        List<string> leftovers = leftoverFieldNames?
+            .Where(name => !string.IsNullOrWhiteSpace(name))
+            .Select(name => name.Trim())
+            .Where(name => !StudentNotesFieldParser.IsReservedHeader(name))
+            .Distinct(StringComparer.OrdinalIgnoreCase)
+            .ToList() ?? [];
+
+        if (leftovers.Count == 0)
+            leftovers = [.. StudentNoteFieldDefaults.IndexColumns];
+
+        var headers = RosterHeaders.Concat(leftovers).ToArray();
+        var values = headers.Select(ExampleValue).ToArray();
+        return $"{ToCsvRow(headers)}{Environment.NewLine}{ToCsvRow(values)}{Environment.NewLine}";
+    }
+
+    private static string ExampleValue(string header) => header switch
+    {
+        "Student Name" => "Last, First",
+        "Grade" => "9",
+        "TSA year" => "1st",
+        "Interview Time" => "3:20-3:35",
+        _ when ContainsIgnoreCase(header, "Application")
+               || ContainsIgnoreCase(header, "Permission") => "x",
+        _ => string.Empty
+    };
+
+    private static bool ContainsIgnoreCase(string value, string part) =>
+        value.Contains(part, StringComparison.OrdinalIgnoreCase);
+
+    private static string ToCsvRow(IEnumerable<string> cells) =>
+        string.Join(",", cells.Select(EscapeCsv));
+
+    private static string EscapeCsv(string value)
+    {
+        if (value.Contains(',') || value.Contains('"') || value.Contains('\n'))
+            return $"\"{value.Replace("\"", "\"\"")}\"";
+        return value;
+    }
+}

Core/Parsers/StudentNotesFieldParser.cs

@@ -0,0 +1,164 @@
+using Core.Entities;
+using Core.Models;
+using Core.Notes;
+
+namespace Core.Parsers;
+
+/// <summary>
+/// Parses leftover CSV columns (not roster or ranking) into student note field merges.
+/// </summary>
+public class StudentNotesFieldParser : CsvParserBase
+{
+    private static readonly HashSet<string> ReservedHeaders = new(StringComparer.OrdinalIgnoreCase)
+    {
+        "Student Name",
+        "Grade",
+        "TSA year",
+        "State ID",
+        "Regional ID",
+        "National ID",
+        "Officer",
+        "TOTAL # OF EVENTS"
+    };
+
+    public StudentNotesFieldParser(FileSystemInfo csvFile, bool ignoreBlankLines = true) : base(csvFile, ignoreBlankLines)
+    {
+    }
+
+    public StudentNotesFieldParser(StreamReader reader, bool ignoreBlankLines = true) : base(reader, ignoreBlankLines)
+    {
+    }
+
+    /// <summary>
+    /// Roster and ranking columns that must not become imported note fields.
+    /// </summary>
+    public static bool IsReservedHeader(string? header)
+    {
+        if (string.IsNullOrWhiteSpace(header))
+            return true;
+
+        var trimmed = header.Trim();
+        if (ReservedHeaders.Contains(trimmed))
+            return true;
+
+        return int.TryParse(trimmed, out var rank)
+               && rank >= 1
+               && rank <= StudentEventRanking.MaxRank;
+    }
+
+    /// <summary>
+    /// Leftover field names from a header row after reserved columns are removed.
+    /// </summary>
+    public static List<string> GetLeftoverFieldNames(IEnumerable<string?> headers) =>
+        headers
+            .Where(h => !IsReservedHeader(h))
+            .Select(h => h!.Trim())
+            .ToList();
+
+    /// <summary>
+    /// Reads the header row and returns leftover field names without processing data rows.
+    /// </summary>
+    public List<string> PeekLeftoverFieldNames()
+    {
+        CsvReader.Read();
+        CsvReader.ReadHeader();
+        return GetLeftoverFieldNames(CsvReader.HeaderRecord ?? []);
+    }
+
+    public StudentNotesImportResult Parse(
+        ICollection<Student> students,
+        IReadOnlyDictionary<int, string?> existingNotesByStudentId)
+    {
+        var result = new StudentNotesImportResult();
+
+        CsvReader.Read();
+        CsvReader.ReadHeader();
+
+        if (CsvReader.HeaderRecord is null ||
+            !CsvReader.HeaderRecord.Contains("Student Name", StringComparer.OrdinalIgnoreCase))
+        {
+            result.Errors.Add("CSV must include a 'Student Name' column.");
+            return result;
+        }
+
+        var fieldNames = GetLeftoverFieldNames(CsvReader.HeaderRecord);
+        result.FieldNames = fieldNames;
+
+        if (fieldNames.Count == 0)
+            result.Warnings.Add("No leftover field columns were found besides roster and ranking columns.");
+
+        Dictionary<int, PendingStudentFields> pendingByStudentId = [];
+
+        while (CsvReader.Read())
+        {
+            var rowNumber = CsvReader.Context.Parser?.Row ?? 0;
+            var name = CsvReader.GetField("Student Name")?.Trim();
+            if (string.IsNullOrEmpty(name))
+                continue;
+
+            var studentMatch = FuzzyStudentMatcher.Find(students, name);
+            if (studentMatch is null)
+            {
+                result.Issues.Add(new StudentNotesImportIssue
+                {
+                    RowNumber = rowNumber,
+                    RawStudentName = name,
+                    Message = $"No student matched '{name}'."
+                });
+                continue;
+            }
+
+            var (student, score) = studentMatch.Value;
+            if (!pendingByStudentId.TryGetValue(student.Id, out var pending))
+            {
+                pending = new PendingStudentFields(student);
+                pendingByStudentId[student.Id] = pending;
+            }
+
+            pending.RawStudentName = name;
+            pending.RowNumber = rowNumber;
+            pending.StudentScore = score;
+
+            foreach (var fieldName in fieldNames)
+            {
+                var raw = CsvReader.GetField(fieldName);
+                pending.Fields[fieldName.Trim()] = raw ?? string.Empty;
+            }
+        }
+
+        foreach (var pending in pendingByStudentId.Values)
+        {
+            List<ImportedField> incoming = [.. pending.Fields.Select(pair => new ImportedField(pair.Key, pair.Value))];
+            existingNotesByStudentId.TryGetValue(pending.Student.Id, out var existingMarkdown);
+            var merge = ImportedFieldsTable.Merge(existingMarkdown, incoming);
+
+            result.Matches.Add(new StudentNotesImportMatch
+            {
+                Student = pending.Student,
+                RawStudentName = pending.RawStudentName,
+                RowNumber = pending.RowNumber,
+                StudentScore = pending.StudentScore,
+                IncomingFields = incoming,
+                Merge = merge
+            });
+        }
+
+        if (result.Matches.Count == 0 && result.Errors.Count == 0)
+            result.Warnings.Add("No students were matched from the CSV.");
+
+        return result;
+    }
+
+    private sealed class PendingStudentFields(Student student)
+    {
+        public Student Student { get; } = student;
+
+        public string RawStudentName { get; set; } = string.Empty;
+
+        public int RowNumber { get; set; }
+
+        public int StudentScore { get; set; }
+
+        public Dictionary<string, string> Fields { get; } = new(StringComparer.OrdinalIgnoreCase);
+    }
+}