public static string Name(this RoutineTaskTimeValue value)
{
switch (value)
{
default:
case RoutineTaskTimeValue.Morning:
return("Manhã");
case RoutineTaskTimeValue.Afternoon:
return("Tarde");
case RoutineTaskTimeValue.Evening:
return("Noite");
}
}
private async Task ConfigureScheduleAsync(Identity owner, RoutineTaskTimeValue time, CancellationToken cancellationToken)
{
Trace.WriteLine($"Start scheduling reminder for {owner} at {time}!");
try
{
var routine = await _routineRepository.GetRoutineAsync(owner, false, cancellationToken);
// Will send a message to itself, the next day only, reminding it to send a message with the routine for the given days and time for each client
var currentTime = GetCurrentTime();
var isBeforeMorning = currentTime.Hour < 6;
var isBeforeAfternoon = currentTime.Hour < 12;
var isBeforeEvening = currentTime.Hour < 18;
var today = new DateTime(currentTime.Year, currentTime.Month, currentTime.Day, 0, 0, 0);
var nextMorningSchedule = isBeforeMorning ? today.AddHours(6) : today.AddHours(6).AddDays(1);
var nextAfternoonSchedule = isBeforeAfternoon ? today.AddHours(12) : today.AddHours(12).AddDays(1);
var nextEveningSchedule = isBeforeEvening ? today.AddHours(18) : today.AddHours(18).AddDays(1);
var shouldScheduleAtMorning = time == RoutineTaskTimeValue.Morning &&
routine.LastMorningReminder < nextMorningSchedule;
var shouldScheduleAtAfternoon = time == RoutineTaskTimeValue.Afternoon &&
routine.LastAfternoonReminder < nextAfternoonSchedule;
var shouldScheduleAtEvening = time == RoutineTaskTimeValue.Evening &&
routine.LastEveningReminder < nextEveningSchedule;
if (shouldScheduleAtMorning || shouldScheduleAtAfternoon || shouldScheduleAtEvening)
{
await
_delegation.DelegateAsync(Identity.Parse("*****@*****.**"),
new[] { EnvelopeType.Message }, cancellationToken);
var identity = new Node(_application.Identifier, _application.Domain, null);
var schedule = new Message
{
Id = Guid.NewGuid().ToString(),
To = identity,
Content = new IdentityDocument(routine.Owner.ToString())
};
if (shouldScheduleAtMorning)
{
routine.LastMorningReminder = nextMorningSchedule;
}
if (shouldScheduleAtAfternoon)
{
routine.LastAfternoonReminder = nextAfternoonSchedule;
}
if (shouldScheduleAtEvening)
{
routine.LastEveningReminder = nextEveningSchedule;
}
switch (time)
{
case RoutineTaskTimeValue.Morning:
await _scheduler.ScheduleMessageAsync(schedule, nextMorningSchedule, cancellationToken);
break;
case RoutineTaskTimeValue.Afternoon:
await _scheduler.ScheduleMessageAsync(schedule, nextAfternoonSchedule, cancellationToken);
break;
case RoutineTaskTimeValue.Evening:
await _scheduler.ScheduleMessageAsync(schedule, nextEveningSchedule, cancellationToken);
break;
}
await _routineRepository.SetRoutineAsync(routine, cancellationToken);
}
Trace.WriteLine($"Finished scheduling reminder for {owner} at {time}!");
}
catch (Exception e)
{
Trace.WriteLine($"Failed scheduling reminder for {owner} at {time}: {e}");
throw;
}
}
private void PrintTasksForDaysAndTime(StringBuilder text, RoutineTaskDaysValue days, RoutineTaskTimeValue time,
IEnumerable <RoutineTask> tasks)
{
tasks = tasks.Where(
task => (task.Days.GetValueOrDefault() == days || task.Days.GetValueOrDefault() == RoutineTaskDaysValue.EveryDay) &&
task.Time.GetValueOrDefault() == time
).ToArray();
if (!tasks.Any())
{
return;
}
text.AppendLine();
text.AppendLine($"{days.Name()} {Settings.Phraseology.During} {time.Name().ToLower()}:");
tasks.ForEach(task => text.AppendLine($"- {task.Name}"));
}
protected async Task CreateANewTaskFromTaskNameAsync(
string taskName,
RoutineTaskDaysValue days = RoutineTaskDaysValue.EveryDay,
RoutineTaskTimeValue time = RoutineTaskTimeValue.Morning,
bool cancel = false)
{
// Inform task name
await Tester.SendMessageAsync(taskName);
var response = await Tester.ReceiveMessageAsync();
response.ShouldNotBeNull();
var select = response.Content as Select;
var actual = select?.Text;
var expected = Settings.Phraseology.WhichDaysShallThisTaskBePerformed;
expected.ShouldNotBeNull();
actual.ShouldBe(expected);
// Inform task day
await Tester.SendMessageAsync(new PlainText { Text = ((int)days).ToString() });
response = await Tester.ReceiveMessageAsync();
response.ShouldNotBeNull();
select = response.Content as Select;
actual = select?.Text;
expected = Settings.Phraseology.WhichTimeShallThisTaskBePerformed;
expected.ShouldNotBeNull();
actual.ShouldBe(expected);
// Inform task time
await Tester.SendMessageAsync(new PlainText { Text = ((int)time).ToString() });
response = await Tester.ReceiveMessageAsync();
response.ShouldNotBeNull();
select = response.Content as Select;
actual = select?.Text;
actual.ShouldStartWith(taskName);
// Confirm the new task
await Tester.SendMessageAsync(cancel?Settings.Commands.Cancel : Settings.Commands.Confirm);
response = await Tester.ReceiveMessageAsync();
response.ShouldNotBeNull();
var document = response.Content as PlainText;
actual = document?.Text;
expected = cancel ? Settings.Phraseology.WheneverYouNeed : Settings.Phraseology.TheTaskWasRegistered;
expected.ShouldNotBeNull();
actual.ShouldBe(expected);
}
