Scheduler refinements

Core/Calculation/TeamSchedulerSolution.cs

@@ -41,4 +41,11 @@ public class TeamSchedulerSolution(
             ).ToArray();
 
     }
+
+    public Team[] StudentUnassignedTeams(Student student)
+    {
+        var meetingTeams = TimeSlots.SelectMany(t => t);
+        return
+            student.Teams.Where(e => !meetingTeams.Contains(e)).ToArray();
+    }
 }

Core/Calculation/UnassignedStudentScheduler.cs

@@ -12,7 +12,7 @@ public class UnassignedStudentScheduler
 	{
 		_teams = teams;
 		_students = teams.SelectMany(t => t.Students).Distinct().ToArray();
-		_timeSlots = timeslots.Select(ts => ts.Select(t => t.Clone()).ToList()).ToArray();
+		_timeSlots = timeslots.Select(ts => ts.Select(t => t.Clone()).ToList()).ToArray<IList<Team>>();
 	}
 	public static IEnumerable<Student> UnassignedStudents(IList<Student> students, IList<Team> timeSlot) 
 		=> students.Where(s => !timeSlot.SelectMany(t => t.Students).Contains(s));
@@ -20,9 +20,9 @@ public class UnassignedStudentScheduler
 	public static IEnumerable<Student>[] UnassignedStudents(IList<Student> students, IList<Team>[] schedule) 
 		=> schedule.Select(ts => UnassignedStudents(students, ts)).ToArray();
 
-	public TeamSchedulerSolution ScheduleStrategy(UnassignedScheduleStrategy scheduleStrategy)
+	public Team[] ScheduleStrategy(UnassignedScheduleStrategy scheduleStrategy)
     {
-        var ss = scheduleStrategy switch
+        var assignments = scheduleStrategy switch
         {
             UnassignedScheduleStrategy.BiggestGroup => ScheduleStrategy(GetAvailableTeams_BiggestGroup),
             UnassignedScheduleStrategy.IndividualEvents => ScheduleStrategy(GetAvailableTeams_Individual),
@@ -32,14 +32,15 @@ public class UnassignedStudentScheduler
             _ => throw new ArgumentOutOfRangeException(nameof(scheduleStrategy), scheduleStrategy, null)
         };
 
-        return new TeamSchedulerSolution(ss, "Success?");
+        return assignments;
     }
 
-	public Team[][] ScheduleStrategy(Func<IEnumerable<Team>, IEnumerable<Student>, IEnumerable<Team>> availableTeamSelector)
+	public Team[] ScheduleStrategy(Func<IEnumerable<Team>, IEnumerable<Student>, IEnumerable<Team>> availableTeamSelector)
 	{
 		// Find stuff for unassigned students in each timeslot
 		var scheduledTeams = _timeSlots.SelectMany(list => list).Distinct().ToList();
-		foreach (var slot in _timeSlots)
+        var additions = new List<Team>();
+        foreach (var slot in _timeSlots)
 		{
 			var unassigned = UnassignedStudents(_students, slot).ToList();
 			while (unassigned.Count > 0)
@@ -54,14 +55,15 @@ public class UnassignedStudentScheduler
 				
 				slot.Add(teamToAdd);
 				scheduledTeams.Add(teamToAdd);
+                additions.Add(teamToAdd);
 
-				foreach (var student in teamToAdd.Students)
+                foreach (var student in teamToAdd.Students)
 					unassigned.Remove(student);
 			}
 		}
 
-		return _timeSlots.Select(e => e.ToArray()).ToArray();
-	}
+        return additions.ToArray();
+    }
 
 	// find teams where several unassigned students can work together
 	private IEnumerable<Team> GetAvailableTeams_BiggestGroup(

Core/Entities/Team.cs

@@ -4,7 +4,8 @@ namespace Core.Entities;
 public class Team
 {
     public int Id { get; set; }
-    
+
+	[Required]
     public EventDefinition Event { get; set; }
 
     public List<Student> Students { get; set; } = [];
@@ -47,7 +48,7 @@ public class Team
 	{
 		var studentsToOmitList = studentsToOmit.ToList();
 		var omittedStudents = Students.Where(studentsToOmitList.Contains).ToList();
-		if (!omittedStudents.Any())
+		if (omittedStudents.Count == 0)
 			return new Team{Captain = Captain, Event = Event, Students = Students.ToList(), Identifier = Identifier};
 
 		var remainingStudents = Students.Where(s => !studentsToOmitList.Contains(s)).ToList();