//todo: all these return statements are risky, they prevent the only chance for the user the make next step and don't give him another chance. e.g. if snooze feautre is disabled while ringing form is open, and than user clicks snooze
//todo: when component is disabled we skip all processing, not just going to next state, review this once more to bse sure that this is ok. Same for snooze, snooze elapsed,
//todo: hide snooze button if that feature is disabled(Ringer can call service via WCF webservice to check is snooze is enabled), we will probably need to handle closing the form as dismiss, not snooze. We also need to prevent accidental closing of form on escape button.
//todo: validation if reminders as paramters to dismiss and snooze, are indeed excepted (or we first expect some other), or just remove them (less safe)
public void DismissReminder(ReminderEntity reminderEntity)
{
DateTime now = DateTime.UtcNow;
if (UserState != UserInteractionState.WaitingUserResponse)
{
Log.Logger.Error($"Ignoring attempt to dismiss reminder [name = {reminderEntity.Name}] because current scheduler state is {UserState} instead od WaitingUserResponse");
return;
}
// Protection of some kind of double dismis request (maybe by multiple ringing windows or something else) that would cause next occurance of reminder to be skipped
if (!ValidateReminderShouldBeRinging(reminderEntity, now))
{
return;
}
if (reminderEntity.IsRepeatable())
{
//setting next ringing of the reminder on its first next occurence by its schedule
DateTime nextReminderRinging = new NextReminderOccurenceCalculator().GetNextReminderOccurence(reminderEntity, now).Value;
reminderEntity.ScheduledTime = nextReminderRinging;
}
else
{
reminderEntity.Dismissed = true;
}
ElapsedActiveReminders.RemoveAll(r => r.Name == reminderEntity.Name);
//TODO: test this - we are here potenitally calling ringer again before response for Dismissing is returned.
GoToRingingOrIdleState(now);
//indirectly also triggers UpdateReminderList on this object //TODO: what are effects of that, probably none?
//TODO: immediate notifying of this change to NextReminderNOtifier is not needed. Should it be prevented or it produces no harm, as it only gives us duplicate reminders here?
FilePersistenceAdapters.RemiderFilePersistence.OnEntitesChanged();
}
//DEAD CODE FOR NOW
/// <summary>
/// We are not introducing new reminders through this method, we are just filtering out timers that are possibly not for ringing any more (and that are deleted) or modifying the existing ones
/// </summary>
public virtual void UpdateReminderList(IList <ReminderEntity> upToDateReminders)
{
Log.Logger.Information("Updating list of reminders in UserInteractionManger");
DateTime now = DateTime.UtcNow; //good to be constant in a variable during this analysis in method so that it doesn't change during analysis. It could make some kind of timer deadlock where timer would never ring.
//pause timer util we decide when should it ring again
if (UserState != UserInteractionState.Disabled)
{
Log.Logger.Information("Pausing UserInteractionManger timer (if it is running at all)");
SnoozeTimer.Stop();
}
List <ReminderEntity> remindersToBeRemoved = new List <ReminderEntity>();
//finding elapsed reminders that don't exist anymore
foreach (ReminderEntity elapsedReminder in ElapsedActiveReminders)
{
ReminderEntity upToDateVersionOfElapsedReminder = upToDateReminders.FirstOrDefault(rem => rem.Name == elapsedReminder.Name);
bool elapsedReminderStillExists = upToDateVersionOfElapsedReminder == null;
if (elapsedReminderStillExists)
{
//TODO: elapsed reminder still exists but it could be changed. Maybe it is not for ringing anymore or some other its parameter was modified? Should we event prevent this kind of changes during snooze period?
}
else
{
remindersToBeRemoved.Add(elapsedReminder);
}
}
bool willFirstReminderBeRemoved = WillFirstReminderBeRemoved(remindersToBeRemoved);
if (willFirstReminderBeRemoved)
{
//handle state change
}
foreach (ReminderEntity reminderToBeRemoved in remindersToBeRemoved)
{
ElapsedActiveReminders.RemoveAll(r => r.Name == reminderToBeRemoved.Name);
}
//foreach (ReminderEntity upToDateReminder in upToDateReminders)
//{
// ReminderEntity elapsedVersionOfUpToDateReminder = ElapsedActiveReminders.FirstOrDefault(rem => rem.Name == upToDateReminder.Name);
// if (elapsedVersionOfUpToDateReminder == null)
// {
// //new reminder is detected, but we can ignore this because it will first be processed by NextReminderNotifier, and if it is elapsed it will fire an event for that reminder
// }
//}
//if scheduler is enabled continue timer (if there is need for this at all after change of reminders)
if (UserState != UserInteractionState.Disabled)
{
//TryToScheduleNextReminder(now);
}
Log.Logger.Information("Updating list of reminders in ReminderScheduler done");
}