public async Task CreateScheduleFromFileAsync(string name, Stream fileStream, CancellationToken cancellationToken = default(CancellationToken))
{
var schedule = new Schedule();
schedule.ScheduleName = name;
schedule.OwningUser = _httpContextAccessor.HttpContext.User.Identity.Name;
schedule.ScheduleRules = new List <ScheduleRule>();
using var reader = new StreamReader(fileStream);
using var csv = new CsvReader(reader, CultureInfo.InvariantCulture);
var records = csv.GetRecords <ScheduleFileRow>();
foreach (var record in records)
{
var rule = new ScheduleRule
{
Name = record.Name,
StartTime = ScheduleRepresentationHelper.ConvertTimeStringToTimeSpan(record.StartTime),
EndTime = ScheduleRepresentationHelper.ConvertTimeStringToTimeSpan(record.EndTime),
StartDate = DateTime.Parse(record.StartDate).Date,
EndDate = DateTime.Parse(record.EndDate).Date,
ScheduleRuleType = record.ScheduleRuleType,
DaysOfWeek = ScheduleRepresentationHelper.ConvertStringToDaysOfWeekFlags(record.DaysOfWeek),
Url = record.Url
};
schedule.ScheduleRules.Add(rule);
}
_appDbContext.Schedules.Add(schedule);
await _appDbContext.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
}
public void ConvertTimeStringToStartEndTimes_WhenValidTimeString_ShouldReturnValidTimeSpans(string input, int expectedStartHour, int expectedStartMinute, int expectedEndHour, int expectedEndMinute)
{
var timeSpans = ScheduleRepresentationHelper.ConvertTimeStringToStartEndTimes(input);
Assert.Equal(expectedStartHour, timeSpans.Item1.Hours);
Assert.Equal(expectedStartMinute, timeSpans.Item1.Minutes);
Assert.Equal(expectedEndHour, timeSpans.Item2.Hours);
Assert.Equal(expectedEndMinute, timeSpans.Item2.Minutes);
}
public async Task <List <ScheduleModel> > GetSchedulesAsync(CancellationToken cancellationToken = default(CancellationToken))
{
var models = await _appDbContext.Schedules.Where(s => s.OwningUser == _httpContextAccessor.HttpContext.User.Identity.Name)
.Select(s => new ScheduleModel()
{
ScheduleId = s.ScheduleId,
ScheduleName = s.ScheduleName,
GoogleCalendarId = s.GoogleCalendarId,
ScheduleRules = s.ScheduleRules.Select(sr => new ScheduleRuleModel
{
Name = sr.Name,
ScheduleRuleType = sr.ScheduleRuleType,
DaysOfWeek = sr.DaysOfWeek,
StartDate = sr.StartDate,
EndDate = sr.EndDate,
StartTime = sr.StartTime,
EndTime = sr.EndTime
}).ToList()
})
.ToListAsync(cancellationToken).ConfigureAwait(false);
foreach (var model in models)
{
model.TodaysEvents = new List <ScheduleEventModel>();
foreach (var rule in model.ScheduleRules)
{
if (rule.EndDate > DateTime.Now && ScheduleRepresentationHelper.GetListOfDayOfWeekFromFlags(rule.DaysOfWeek).Any(dow => dow == DateTime.Now.DayOfWeek))
{
if (rule.ScheduleRuleType == ScheduleRuleType.ByDayOfWeek ||
(rule.ScheduleRuleType == ScheduleRuleType.ByDayOfWeekEveryOtherWeek && (DateTime.Now - rule.StartDate).TotalDays / 7 % 2 == 0))
{
model.TodaysEvents.Add(new ScheduleEventModel
{
EventTime = DateTime.Today + rule.StartTime,
EventType = "start",
Name = rule.Name
});
model.TodaysEvents.Add(new ScheduleEventModel
{
EventTime = DateTime.Today + rule.EndTime,
EventType = "end",
Name = rule.Name
});
}
}
}
}
return(models);
}
public void ConvertToRRULE_WhenRecurrenceTypeByDayOfWeekEveryOtherWeek_ProducesValidRRULE(DaysOfWeek daysOfWeek, string expectedResult)
{
// Arrange
var model = new ScheduleRuleModel()
{
ScheduleRuleType = ScheduleRuleType.ByDayOfWeekEveryOtherWeek,
DaysOfWeek = daysOfWeek
};
// Act
var rrule = ScheduleRepresentationHelper.ConvertToRRULE(model);
// Assert
Assert.Equal(expectedResult, rrule);
}
public async Task CreateCalendarForScheduleAsync(Guid scheduleId, CancellationToken cancellationToken = default(CancellationToken))
{
var schedule = await _appDbContext.Schedules
.Include(s => s.ScheduleRules)
.FirstOrDefaultAsync(s => s.ScheduleId == scheduleId, cancellationToken).ConfigureAwait(false);
if (schedule == null)
{
throw new Exception("Unable to find schedule with given ID");
}
var token = await flow.LoadTokenAsync(_httpContextAccessor.HttpContext.User.Identity.Name, cancellationToken).ConfigureAwait(false);
var userCredentials = new UserCredential(flow, _httpContextAccessor.HttpContext.User.Identity.Name, token);
var service = new CalendarService(new BaseClientService.Initializer
{
HttpClientInitializer = userCredentials
});
var calendars = await service.CalendarList.List().ExecuteAsync(cancellationToken).ConfigureAwait(false);
string userCalendarId;
if (calendars.Items.Count == 0 || !calendars.Items.Any(i => i.Description == schedule.ScheduleId.ToString()))
{
var cal = await service.Calendars.Insert(new Google.Apis.Calendar.v3.Data.Calendar
{
Summary = $"FWTBT - {schedule.ScheduleName}",
Description = schedule.ScheduleId.ToString()
}).ExecuteAsync().ConfigureAwait(false);
userCalendarId = cal.Id;
}
else
{
var userCalendar = calendars.Items.First(i => i.Description == schedule.ScheduleId.ToString());
userCalendarId = userCalendar.Id;
// Clear existing events
var result = await service.Calendars.Clear(userCalendarId).ExecuteAsync(cancellationToken).ConfigureAwait(false);
}
schedule.GoogleCalendarId = userCalendarId;
foreach (var rule in schedule.ScheduleRules)
{
var rrule = ScheduleRepresentationHelper.GenerateRrule(rule.ScheduleRuleType, rule.DaysOfWeek, rule.EndDate.Date + rule.EndTime);
await service.Events.Insert(new Event
{
Summary = rule.Name,
Location = rule.Url,
Start = new EventDateTime {
DateTime = rule.StartDate.Date + rule.StartTime,
TimeZone = TZConvert.WindowsToIana(TimeZoneInfo.Local.StandardName)
},
End = new EventDateTime
{
DateTime = rule.StartDate.Date + rule.EndTime,
TimeZone = TZConvert.WindowsToIana(TimeZoneInfo.Local.StandardName)
},
Recurrence = new List <string>
{
rrule
}
}, userCalendarId).ExecuteAsync(cancellationToken).ConfigureAwait(false);
}
await _appDbContext.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
}
