public async Task <bool> RemoveRow(GrainReference grainRef, string reminderName, string eTag)
{
try
{
var response = await ExecuteWithRetries(() =>
{
var pk = new PartitionKey(ReminderEntity.ConstructPartitionKey(this._serviceId, grainRef));
return(this._container.DeleteItemAsync <ReminderEntity>(
ReminderEntity.ConstructId(grainRef, reminderName),
pk,
new ItemRequestOptions {
IfMatchEtag = eTag
}
));
}).ConfigureAwait(false);
return(true);
}
catch (CosmosException dce) when(dce.StatusCode == HttpStatusCode.PreconditionFailed)
{
return(false);
}
catch (Exception exc)
{
this._logger.LogError(exc, $"Failure removing reminders for Service {this._serviceId} with grainId {grainRef.ToKeyString()} and name {reminderName}.");
throw;
}
}
private void NextReminderTimer_Elapsed(object sender, ElapsedEventArgs e)
{
if (!isEnabled)
{
//not expected to happen, but may be the result of some unexpected edge case
Log.Logger.Error("Timer fired event while NextReminderNotifier was not enabled. Ignoring event.");
return;
}
ReminderEntity elapsedReminder = ActiveSortedReminders?.FirstOrDefault();
DateTime now = DateTime.UtcNow;
if (!ValidateReminderElapsed(elapsedReminder, now))
{
//not expected to happen, but may be the result of some unexpected edge case
Log.Logger.Error("Elapsed reminder is in invalid state in NextReminderNotifier (it is null, or scheduled in the future, or already dismissed). Attemting Recovery mechanism.");
Recovery(now);
return;
}
//UserInteraction manager already logs receival of this event
//Log.Logger.Information($"Firing OnReminderElapsed event for [name = {elapsedReminder.Name}] so that it can be added to elapsed reimnders list");
//Add reminder to list of elapsed reminders
OnReminderElapsed(elapsedReminder, now);
ActiveSortedReminders.Remove(elapsedReminder);
TryToScheduleNextReminder(now);
//Dismissing operation will put repeatable reminder in list again (with new ScheduledTime) by triggering UpdateReminderList via persistence adapter.
//TODO: should snooze somehow put it in this list or UI manager should handle that itself? Reminder schedule change for snooze purposes would its information regarding real scheduled time. Also adding reminder for snoozing to this list would trigger adding all other reminders to the list.
}
public async Task <string> UpsertRow(ReminderEntry entry)
{
try
{
ReminderEntity entity = this.ToEntity(entry);
var response = await ExecuteWithRetries(() =>
{
var pk = new PartitionKey(ReminderEntity.ConstructPartitionKey(this._serviceId, entry.GrainRef));
return(this._container.UpsertItemAsync(
entity,
pk,
new ItemRequestOptions {
IfMatchEtag = entry.ETag
}
));
}).ConfigureAwait(false);
return(response.Resource.ETag);
}
catch (Exception exc)
{
this._logger.LogError(exc, $"Failure to upsert reminder for Service {this._serviceId}.");
throw;
}
}
protected virtual void EditAction()
{
ReminderEntity reminderToUpdate = SelectedReminder;
if (reminderToUpdate == null)
{
ErrorDialogUtility.ErrorDialog(TranslationProvider.Tr("warningReminderNotSelectedToEdit"));
return;
}
CreateAndUpdateReminderForm createReminderForm = new CreateAndUpdateReminderForm(PersistenceAdapter, reminderToUpdate);
createReminderForm.ShowDialog();
if (createReminderForm.DialogResult != DialogResult.OK)
{
Log.Logger.Information($"UpdateReminderForm closed with result NotOk.");
return;
}
var updatedReminder = createReminderForm.CreateOrUpdatedReminder;
bool result = PersistenceAdapter.Update(reminderToUpdate.Name, updatedReminder);
if (result == true)
{
//using the element in the listbox
remindersListBox.Items[remindersListBox.SelectedIndex] = updatedReminder;
}
else
{
ErrorDialogUtility.ErrorDialog(TranslationProvider.Tr("warningSnoozedReminderCannotModify"));
}
}
public void Save(ReminderEntity createdReminder)
{
Log.Logger.Information($"Executing webservice operation \"{MethodBase.GetCurrentMethod().Name}\" [Name = {createdReminder?.Name}]");
FilePersistenceAdapters.RemiderFilePersistence.Entities.Add(createdReminder);
FilePersistenceAdapters.RemiderFilePersistence.OnEntitesChanged();
}
protected virtual ReminderEntity CreateReminderEntity()
{
DateTime scheduledDateTime = GetDateTimeFromUI();
DateTime scheduledDateTimeUtc = ConvertFromLocalToUtc(scheduledDateTime);
//create bool array from the checkbox list
bool[] repeatWeeklyDays = new bool[7];
foreach (int checkedIndex in repeatWeeklyCheckedListBox.CheckedIndices)
{
repeatWeeklyDays[checkedIndex] = true;
}
//disable weekly flag if 0 days are selected
bool repeatWeekly = AnyChecked(repeatWeeklyDays);
RepeatPeriod repeatPeriod = GetRepeatPeriod(repeatWeekly);
var reminderEntity = new ReminderEntity()
{
Name = SanitizeReminderName(reminderNameStringBox.Text),
ScheduledTime = scheduledDateTimeUtc,
RepeatPeriod = repeatPeriod,
RepeatWeeklyDays = repeatWeeklyDays
};
return(reminderEntity);
}
public bool EventItem_AsyncPush(List <UserEventItemEntity> items, int userid)
{
foreach (UserEventItemEntity item in items)
{
item.UserID = userid;
if (item.Reminders != null)
{
foreach (var re in item.Reminders)
{
re.UserID = userid;
re.EventItemGUID = item.EventItemGUID;
}
}
else
{
item.Reminders = new List <ReminderEntity>();
var re = new ReminderEntity();
re.EventItemGUID = item.EventItemGUID;
item.Reminders.Add(re);
}
if (item.Tags == null)
{
item.Tags = new List <string>();
}
if (item.Pics == null)
{
item.Pics = new List <int>();
}
}
return(eventitemobj.EventItem_AsyncPush(items));
}
public async Task <ReminderEntry> ReadRow(GrainReference grainRef, string reminderName)
{
try
{
var response = await ExecuteWithRetries(async() =>
{
var pk = new PartitionKey(ReminderEntity.ConstructPartitionKey(this._serviceId, grainRef));
ItemResponse <ReminderEntity> response = null;
try
{
response = await this._container.ReadItemAsync <ReminderEntity>(
ReminderEntity.ConstructId(grainRef, reminderName), pk);
}
catch (CosmosException ce) when(ce.StatusCode == HttpStatusCode.NotFound)
{
return(null);
}
return(response.Resource);
}).ConfigureAwait(false);
return(response != null?this.FromEntity(response) : null);
}
catch (Exception exc)
{
this._logger.LogError(exc, $"Failure reading reminder {reminderName} for service {this._serviceId} and grain {grainRef.ToKeyString()}.");
throw;
}
}
public async Task <bool> UpdateReminderAsync(string userId, ReminderEntity reminder)
{
using (MySqlConnection conn = new MySqlConnection(connectionStringFactory.GetConnectionString()))
{
var updated = await conn.ExecuteAsync(@"
UPDATE reminders SET
Title = @title,
Description = @description,
ForDate = @fordate,
Recurrence = @recurrence,
Importance = @importance
WHERE ID = @id AND UserID = @userId;" ,
new
{
title = reminder.Title,
description = reminder.Description,
fordate = reminder.ForDate,
recurrence = reminder.Recurrence,
importance = reminder.Importance,
id = reminder.Id,
userId
});
return(updated > 0);
}
}
protected virtual void DeleteAction()
{
ReminderEntity reminderToDelete = SelectedReminder;
if (reminderToDelete == null)
{
ErrorDialogUtility.ErrorDialog(TranslationProvider.Tr("warningReminderNotSelectedToDelete"));
return;
}
string confirmationText = TranslationProvider.Tr("confirmDeletingDialog") + " " + reminderToDelete.Name + ".";
DialogResult confirmationResult = MessageBox.Show(confirmationText, "", MessageBoxButtons.OKCancel, MessageBoxIcon.Information);
if (confirmationResult != DialogResult.OK)
{
Log.Logger.Information($"Confirmation not given for deleting {reminderToDelete.Name}");
return;
}
bool result = PersistenceAdapter.Delete(reminderToDelete.Name);
if (result == true)
{
HandleRemovingFromListBox(reminderToDelete);
}
else
{
ErrorDialogUtility.ErrorDialog(TranslationProvider.Tr("warningSnoozedReminderCannotDelete"));
}
}
public ReminderEntity Load(string reminderName)
{
Log.Logger.Information($"Executing webservice operation \"{MethodBase.GetCurrentMethod().Name}\" [reminderName = {reminderName}]");
ReminderEntity reminderWithThisName = FilePersistenceAdapters.RemiderFilePersistence.Entities.FirstOrDefault(r => r.Name == reminderName);
return(reminderWithThisName);
}
public void SnoozeReminder(ReminderEntity reminder)
{
Log.Logger.Information("Snoozing reminder in TimerScheduler");
ReminderScheduler.SnoozeReminder(reminder);
Log.Logger.Information("Snoozing reminder in TimerScheduler done");
}
public void DismissReminder(ReminderEntity reminder)
{
Log.Logger.Information("Dismissing reminder in TimerScheduler");
ReminderScheduler.DismissReminder(reminder);
Log.Logger.Information("Dismissing reminder in TimerScheduler done");
}
public void DismissReminder(string reminderName)
{
Log.Logger.Information($"Executing webservice operation \"{MethodBase.GetCurrentMethod().Name}\" [reminderName = {reminderName}]");
ReminderEntity reminderWithThisName = FilePersistenceAdapters.RemiderFilePersistence.Entities.FirstOrDefault(r => r.Name == reminderName);
AudioReminderService.scheduler.DismissReminder(reminderWithThisName);
}
public CreateAndUpdateReminderForm(PersistenceAdapter nameChecker, ReminderEntity reminderToUpdate)
{
InitializeComponent();
this.nameChecker = nameChecker;
Icon = AudioReminderCore.Properties.Resources.AudioReminderIcon;
Text = "Audio Reminder - Update reminder";
DisplayReminderToUpdate(reminderToUpdate);
oldValueOfReminderToBeUpdated = reminderToUpdate;
}
public void Test_WorkdayReminder_1hourAfterRing_NextShouldbeTomorrow()
{
ReminderEntity weekly8am = CreateWeekly8amReminder();
var calc = new NextReminderOccurenceCalculator();
DateTime now2 = new DateTime(2020, 4, 13, 9, 0, 0);
DateTime expectedNextOccurence2 = new DateTime(2020, 4, 14, 8, 0, 0);
TestNextReminderOccurenceCalculation(weekly8am, calc, now2, expectedNextOccurence2);
}
public void Test_WorkdayReminder_1hourBeforeRing_NextShouldbeToday()
{
ReminderEntity weekly8am = CreateWeekly8amReminder();
var calc = new NextReminderOccurenceCalculator();
DateTime now3 = new DateTime(2020, 4, 13, 7, 0, 0);
DateTime expectedNextOccurence3 = new DateTime(2020, 4, 13, 8, 0, 0);
TestNextReminderOccurenceCalculation(weekly8am, calc, now3, expectedNextOccurence3);
}
protected virtual bool ValidateReminderNotNull(ReminderEntity reminderEntity)
{
if (reminderEntity == null)
{
Log.Logger.Error("Reminder that was expected to be elapsed is null.");
return(false);
}
return(true);
}
protected virtual bool ValidateReminderNotAlreadyDismissed(ReminderEntity reminderEntity)
{
if (reminderEntity.Dismissed)
{
Log.Logger.Error($"Reminder [reminderName = {reminderEntity.Name}] that was expected to be elapsed is already dissmissed [scheduled time = {reminderEntity.ScheduledTime}].");
return(false);
}
return(true);
}
public void Test_WorkdayReminder_OnSunday_NextShouldbeMonday()
{
ReminderEntity weekly8am = CreateWeekly8amReminder();
var calc = new NextReminderOccurenceCalculator();
DateTime now1 = new DateTime(2020, 4, 13, 7, 0, 0);
DateTime expectedNextOccurence1 = new DateTime(2020, 4, 13, 8, 0, 0);
TestNextReminderOccurenceCalculation(weekly8am, calc, now1, expectedNextOccurence1);
}
/// <summary>
/// Starts timer for the next reminder whici is assumed to exist
/// </summary>
protected virtual void ScheduleNextReminder(DateTime now)
{
ReminderEntity nextReminder = ActiveSortedReminders.First();
int intervalMs = GetTimeInMsUntilNextRinging(nextReminder, now);
Log.Logger.Information($"Starting NextReminderNotifier timer [Reminder name = {nextReminder.Name}, Interval = {intervalMs} ms, Scheduled at {nextReminder.ScheduledTime} UTC] ");
NextReminderTimer.Interval = intervalMs;
NextReminderTimer.Start();
}
/// <summary>
/// Finds the moment of the first occurence of a reminder in the future.
/// Null only for non-repeating reminders from the past.
/// </summary>
public virtual DateTime?GetNextReminderOccurence(ReminderEntity reminder, DateTime now)
{
if (!reminder.IsRepeatable())
{
return(GetNextOccurenceOfNonRepeatingReminder(reminder, now));
}
else
{
return(GetNextOccurenceOfRepeatingReminder(reminder, now));
}
}
private ReminderEntry FromEntity(ReminderEntity entity)
{
return(new ReminderEntry
{
GrainRef = this._grainReferenceConverter.GetGrainFromKeyString(entity.GrainId),
ReminderName = entity.Name,
Period = entity.Period,
StartAt = entity.StartAt.UtcDateTime,
ETag = entity.ETag
});
}
/// <summary>
/// Validates that reminder is in the past (current moment is also considered as the past)
/// </summary>
protected virtual bool ValidateReminderIsInThePast(ReminderEntity reminderEntity, DateTime now)
{
bool reminderNotYetReady = reminderEntity.ScheduledTime > now;
if (reminderNotYetReady)
{
Log.Logger.Error($"Reminder [reminderName = {reminderEntity.Name}] that was expected to be elapsed is scheduled in the future [UtcNow = {now}, scheduled time = {reminderEntity.ScheduledTime}].");
return(false);
}
return(true);
}
private void okButton_Click(object sender, EventArgs e)
{
if (!ValidateInput())
{
return;
}
CreateOrUpdatedReminder = CreateReminderEntity();
DialogResult = DialogResult.OK;
Log.Logger.Information($"Closing CreateReminderForm with result OK.");
}
//DEAD CODE FOR NOW
protected virtual bool WillFirstReminderBeRemoved(List <ReminderEntity> remindersToBeRemoved)
{
if (!ElapsedActiveReminders.Any())
{
//it will not be removed because it doesn't exist
return(false);
}
ReminderEntity firstReminder = ElapsedActiveReminders.First();
bool firstReminderWillBeRemoved = remindersToBeRemoved.Any(rem => rem.Name == firstReminder.Name);
return(firstReminderWillBeRemoved);
}
public async Task UpdateReminderAsync_Maps_To_An_Equivalent_Entity_And_Sends_It_To_The_Repository()
{
var mockReminder = GetMockReminder(456);
ReminderEntity mappedReminder = null;
repositoryMock.Setup(m => m.UpdateReminderAsync(It.IsAny <string>(), It.IsAny <ReminderEntity>()))
.ReturnsAsync(true)
.Callback((string uid, ReminderEntity re) => mappedReminder = re);
var result = await uut.UpdateReminderAsync("1", mockReminder);
Assert.True(AreEquivalentReminderObjects(mappedReminder, mockReminder));
}
private ReminderEntity ToEntity(ReminderEntry entry)
{
return(new ReminderEntity
{
Id = ReminderEntity.ConstructId(entry.GrainRef, entry.ReminderName),
PartitionKey = ReminderEntity.ConstructPartitionKey(this._serviceId, entry.GrainRef),
ServiceId = this._serviceId,
GrainHash = entry.GrainRef.GetUniformHashCode(),
GrainId = entry.GrainRef.ToKeyString(),
Name = entry.ReminderName,
StartAt = entry.StartAt,
Period = entry.Period
});
}
/// <summary>
/// Validates that this reminder can be considered as elapsed
/// </summary>
public virtual bool ValidateReminderElapsed(ReminderEntity reminderEntity, DateTime now)
{
if (!ValidateReminderNotNull(reminderEntity))
{
return(false);
}
if (!ValidateReminderIsInThePast(reminderEntity, now))
{
return(false);
}
return(true);
}
//If scheduled time would be EXACTLY NOW we treat that as past also, and find the next occurence
protected virtual DateTime GetNextOccurenceOfRepeatingReminderFromThePast(ReminderEntity reminder, DateTime now)
{
switch (reminder.RepeatPeriod)
{
case RepeatPeriod.Yearly:
return(GetNextOccurenceOfYearlyRepeatingReminder(reminder.ScheduledTime, now));
case RepeatPeriod.Monthly:
return(GetNextOccurenceOfMonthlyRepeatingReminder(reminder.ScheduledTime, now));
default: //weekly recuring reminder
return(GetNextOccurenceOfWeeklyRepeatingReminder(reminder.ScheduledTime, now, reminder.RepeatWeeklyDays));
}
}
