public Event(TeacherPreference preferences, DateTime availabilityStart, DateTime availabilityEnd, int travelDuration = 0)
{
this.sortId = Guid.NewGuid();
this.preferences = preferences;
this.backgroundColor = "#dbd4d3";
this.textColor = "#000000";
this.title = "Available";
this.groupId = "Availability";
this.start = availabilityStart;
this.end = availabilityEnd;
this.officialStart = availabilityStart + SchedService.ConvertIntToTimeSpan(travelDuration);
this.officialEnd = availabilityEnd - SchedService.ConvertIntToTimeSpan(travelDuration);
this.price = SchedService.CreatePrice(preferences.PerHourRate, this.start, this.end);
}
private async Task <bool> KeepAlive()
{
try {
foreach (var(_, sched) in SchedFactory.schedulers)
{
if (!sched.IsMaster)
{
continue;
}
var discover_name = GetDiscoverName(sched.GetNameKey());
await _redis.HashSetAsync(discover_name, (await SchedService.FromScheduler(sched))?.GetServiceInfo());
await _redis.KeyExpireAsync(discover_name, TimeSpan.FromSeconds(7));
}
foreach (var actor in ActorFactory.Actors)
{
switch (actor.RunningThread.ThreadState)
{
case ThreadState.Running:
case ThreadState.WaitSleepJoin: break;
default: continue;
}
var discover_name = GetDiscoverName(actor.GetNameKey(actor.ActorID.ToString()));
await _redis.HashSetAsync(discover_name, ActorService.FromActor(actor)?.GetServiceInfo());
await _redis.KeyExpireAsync(discover_name, TimeSpan.FromSeconds(7));
}
return(true);
} catch (Exception ex) {
_logger.LogError(ex.Message);
Console.WriteLine(ex.Message);
}
return(false);
}
private async Task <List <Event> > GenerateTeacherCalendarView(int teacherIdInt, int travelDuration = 0)
{
// arrange
List <Event> eventList = new List <Event>();
TeacherPreference preferences = await Task.Run(() => context.Preferences
.Where(p => p.teacherId == teacherIdInt)
.SingleOrDefault()
);
List <Lesson> lessons = await Task.Run(() => context.Lessons
.Include("Student")
.Include("Location")
// todo: add in other lesson filter constraints
.Where(lesson => lesson.teacherId == teacherIdInt && lesson.teacherApproval)
.ToList()
);
eventList = SchedService.GenerateEventsFromLessons(preferences, lessons);
List <Event> lessonEventList = SchedService.GenerateEventsFromLessons(preferences, lessons);
List <TeacherAvail> availabilities = await Task.Run(() => context.TeacherAvailabilities
.Where(a => a.PersonId == teacherIdInt)
.ToList()
);
// todo: make calendar views dynamic by changing this per the view
availabilities = SchedService.AddDatesToAvailabilities(availabilities, DateTime.Today.AddDays(-15), DateTime.Today.AddDays(15));
double convertedLessonLength = Convert.ToDouble(preferences.defaultLessonLength);
TimeSpan timeSpanOfLesson = TimeSpan.FromMinutes(convertedLessonLength);
// act on Available Timespans
foreach (var availableTimeSpan in availabilities)
{
// find the lesson events that are inclusive to that time span
List <Event> filteredLessonList = lessonEventList
.Where(lessn => lessn.start >= availableTimeSpan.start && lessn.end <= availableTimeSpan.end)
.ToList();
if (filteredLessonList.Count == 0)
{
List <Event> listOfAfterEvents = SchedService.CreateNextAvailabilities(preferences, availableTimeSpan.end, availableTimeSpan.start, false, travelDuration);
eventList.AddRange(listOfAfterEvents);
continue;
}
// sort those lesson events
filteredLessonList.Sort();
// take the first one and create the new available events before it, checking if it fits in the available slot
List <Event> listOfPreEvents = SchedService.CreatePriorAvailabilities(preferences, availableTimeSpan.start, filteredLessonList[0].start, travelDuration);
eventList.AddRange(listOfPreEvents);
int currentLessonNumber = 0;
int nextLessonNumber = 1;
// fill in the times between the lesson events, evenly
while (nextLessonNumber < filteredLessonList.Count)
{
TimeSpan timeSpan = filteredLessonList[nextLessonNumber].start - filteredLessonList[currentLessonNumber].end;
if (timeSpan.TotalMinutes > Convert.ToDouble(2 * preferences.defaultLessonLength))
{
// find the mid point between the lessons
TimeSpan timeBetweenLessons = filteredLessonList[nextLessonNumber].start - filteredLessonList[currentLessonNumber].end;
Double timeBetweenLessonsInMinutes = timeBetweenLessons.TotalMinutes;
Double midpointBetweenLessons = timeBetweenLessonsInMinutes / 2;
TimeSpan timeSpanOfMidpointFromEndOfCurrentLesson = TimeSpan.FromMinutes(midpointBetweenLessons);
DateTime midpoint = filteredLessonList[currentLessonNumber].end + timeSpanOfMidpointFromEndOfCurrentLesson;
List <Event> listOfAfterEvents = SchedService.CreateNextAvailabilities(preferences, midpoint, filteredLessonList[currentLessonNumber].end, true, travelDuration);
eventList.AddRange(listOfAfterEvents);
List <Event> listOfBeforeEvents = SchedService.CreatePriorAvailabilities(preferences, midpoint, filteredLessonList[nextLessonNumber].start, travelDuration);
eventList.AddRange(listOfBeforeEvents);
}
else
{
List <Event> listOfAfterEvents = SchedService.CreateNextAvailabilities(preferences, filteredLessonList[nextLessonNumber].start, filteredLessonList[currentLessonNumber].end, true, travelDuration);
eventList.AddRange(listOfAfterEvents);
}
currentLessonNumber += 1;
nextLessonNumber += 1;
}
// take the last lesson and fill in afterwards
List <Event> listOfPostEvents = SchedService.CreateNextAvailabilities(preferences, availableTimeSpan.end, filteredLessonList[filteredLessonList.Count - 1].end, true, travelDuration);
eventList.AddRange(listOfPostEvents);
}
return(eventList);
}
