public void WhenFindBy_IfItemExists_ShouldReturnsMatchedResults()
{
// Arrange
var datetime = DateTimeOffset.UtcNow.AddDays(-2);
var status = ReminderItemStatus.Ready;
var storage = Create
.Storage(ConnectionString)
.WithItems(
Create.Item(status: status, datetime: datetime),
Create.Item(status: status, datetime: datetime),
Create.Item(status: status, datetime: datetime),
Create.Item(status: status, datetime: datetime),
Create.Item(status: ReminderItemStatus.Sent, datetime: datetime),
Create.Item(status: ReminderItemStatus.Ready, datetime: datetime.AddDays(1))
)
.Build();
var filter = new ReminderItemFilter(new PageInfo(2, 2), datetime.AddMinutes(1), status);
// Act
var result = storage.FindBy(filter);
// Assert
Assert.AreEqual(4, result.Total);
Assert.AreEqual(2, result.Page.Number);
Assert.AreEqual(2, result.Items.Count);
}
private void OnTimerTick(object state)
{
_logger.LogDebug("Ticked timer");
var datetime = DateTimeOffset.UtcNow;
var reminders = _storage.FindBy(ReminderItemFilter.CreatedAt(datetime));
foreach (var reminder in reminders)
{
_logger.LogInformation($"Mark reminder {reminder.Id:N} as ready");
reminder.MarkReady();
try
{
_logger.LogInformation($"Sending reminder {reminder.Id:N}");
_sender.Send(
new ReminderNotification(
reminder.ContactId,
reminder.Message,
reminder.DateTime
)
);
OnReminderSent(reminder);
}
catch (ReminderSenderException exception)
{
_logger.LogError(exception, "Exception occured while sending notification");
OnReminderFailed(reminder);
}
}
}
public void WhenReminderFilterByStatusReady()
{
var filter = ReminderItemFilter.ByStatus(ReminderItemStatus.Ready);
Assert.NotNull(filter);
Assert.IsTrue(filter.IsByStatus);
}
public PagedResult FindBy(ReminderItemFilter filter)
{
using var context = CreateContext();
var result = context.Reminders
.Include(_ => _.Contact)
.AsQueryable();
if (filter.ByStatus)
{
result = result.Where(_ => _.Status == filter.Status);
}
if (filter.ByDatetime)
{
result = result.Where(_ => _.DatetimeUtc < filter.DatetimeUtc);
}
var items = result
.OrderBy(_ => _.DatetimeUtc)
.Skip(filter.Page.Offset)
.Take(filter.Page.Limit);
return(new PagedResult(
result.Count(),
filter.Page,
items.Select(_ =>
new ReminderItem(_.Id, _.Contact.Login, _.Message, _.DatetimeUtc, _.Status)
)
));
}
private void OnReadyItemTimerTick(object state)
{
var filter = new ReminderItemFilter()
.Ready();
var items = _storage.FindBy(filter);
}
private async Task SendScheduledRemindersAsync()
{
var reminders = await _storage.FindAsync(ReminderItemFilter.CreatedAtNow());
foreach (var reminder in reminders)
{
reminder.MarkReady();
await _storage.UpdateAsync(reminder);
try
{
await _sender.SendAsync(new ReminderNotification(
reminder.DateTime,
reminder.Message,
reminder.ChatId
)
);
await OnReminderSentAsync(reminder);
}
catch (ReminderSenderException)
{
await OnReminderFailedAsync(reminder);
}
}
}
public PagedResult FindBy(ReminderItemFilter filter)
{
if (filter == null)
{
throw new ArgumentNullException(nameof(filter));
}
var result = _dictionary.Values.AsEnumerable();
if (filter.ByStatus)
{
result = result.Where(_ => _.Status == filter.Status);
}
if (filter.ByDatetime)
{
result = result.Where(_ => _.DatetimeUtc < filter.DatetimeUtc);
}
var items = result
.OrderBy(_ => _.DatetimeUtc)
.Skip(filter.Page.Offset)
.Take(filter.Page.Limit);
return(new PagedResult(
result.Count(),
filter.Page,
items
));
}
public PagedResult FindBy(ReminderItemFilter filter)
{
using var connection = _connectionString.ToSqlConnection();
var predicates = QueryBuilder.From(filter);
using var queryCount = connection.CreateQuery(Sql
.FindReminderItemsCount
.Replace("{filter}", predicates));
var count = ReadCount(queryCount);
if (count == 0)
{
return(new PagedResult(count, filter.Page, Enumerable.Empty <ReminderItem>()));
}
using var queryItems = connection.CreateQuery(Sql
.FindReminderItems
.Replace("{filter}", predicates)
.Replace("{offset}", filter.Page.Offset.ToString())
.Replace("{limit}", filter.Page.Limit.ToString()));
return(new PagedResult(count, filter.Page, ReadItems(queryItems)));
}
public void WhenReminderFilterByDateTime()
{
var filter = ReminderItemFilter.ByDateTime(DateTimeOffset.UtcNow);
Assert.NotNull(filter);
Assert.IsTrue(filter.IsByDateTime);
}
public IActionResult GetList([FromQuery()] ReminderFilterViewModel model)
{
var filter = new ReminderItemFilter(model?.DateTime, model?.Status);
var items = _storage.FindBy(filter);
return(Ok(items));
}
private async Task OnTickAsync()
{
_logger.LogDebug("Ticked timer");
foreach (var reminder in await _storage.FindByAsync(ReminderItemFilter.CreatedAtNow()))
{
_logger.LogInformation($"Mark reminder {reminder.Id:N} as ready");
reminder.MarkReady();
await _storage.UpdateAsync(reminder);
try
{
_logger.LogInformation($"Sending reminder {reminder.Id:N}");
await _sender.SendAsync(
new ReminderNotification(
reminder.ContactId,
reminder.Message,
reminder.DateTime
)
);
await OnReminderSentAsync(reminder);
}
catch (ReminderSenderException exception)
{
_logger.LogError(exception, "Exception occured while sending notification");
await OnReminderFailedAsync(reminder);
}
}
}
public void GivenDateTimeAndStatus_IsByDatetimeAndStatus_ShouldBeTrue()
{
var filter = ReminderItemFilter.FromNow();
Assert.True(filter.IsByStatus);
Assert.True(filter.IsByDateTime);
}
// GET /api/remidners?status=
public List <ReminderItem> FindBy(ReminderItemFilter filter)
{
var response = Execute($"/api/reminders?status={filter.Status}&datetime={filter.DatetimeUtc}", HttpMethod.Get);
response.EnsureSuccessStatusCode();
return(response.Content.ToObject <List <ReminderItem> >());
}
public void WhenReminderFilterFromNow()
{
var filter = ReminderItemFilter.FromNow();
Assert.NotNull(filter);
Assert.IsTrue(filter.IsByStatus);
Assert.IsTrue(filter.IsByDateTime);
}
public void WhenConstruct_IfDatetimeSpecified_FilterByDatetimeShouldBeTrue()
{
// Arrange-Act
var filter = new ReminderItemFilter(datetimeUtc: DateTimeOffset.UtcNow);
// Assert
Assert.IsTrue(filter.ByDatetime);
}
public void FindAsync_WithIncorrectDate_ShouldRiseException()
{
var storage = new ReminderStorage(Factory.CreateClient());
Assert.CatchAsync(
() => storage.FindAsync(ReminderItemFilter.CreatedAt(DateTimeOffset.MinValue))
);
}
public void WhenConstruct_IfStatus_FilterByStatusShouldBeTrue()
{
// Arrange-Act
var filter = new ReminderItemFilter(status: ReminderItemStatus.Created);
// Assert
Assert.IsTrue(filter.ByStatus);
}
public PagedResult FindBy(ReminderItemFilter filter)
{
using var connection = Sql.CreateConnection(_connectionString);
var items = GetReminderItems(connection, filter);
var count = GetReminderItemsCount(connection, filter);
return(new PagedResult(count, filter.Page, items));
}
private void OnReadyTimerTick(object state) //selects suitable objects
{
var items = _storage.FindBy(ReminderItemFilter.FromNow());
foreach (var item in items)
{
item.Status = ReminderItemStatus.Ready;
_storage.Update(item);
}
}
public async Task FindAsync_WithCorrectDate_ShouldReturnReminders()
{
var storage = new ReminderStorage(Factory.CreateClient());
await storage.AddAsync(Create.Reminder.InPast());
var foundReminders = await storage.FindAsync(ReminderItemFilter.CreatedAtNow());
CollectionAssert.IsNotEmpty(foundReminders);
}
public void WhenCreatedItemsFindByReadyStatus_ShouldReturnEmpty()
{
storage.Add(
new ReminderItem(Guid.NewGuid(), "header", "message one", DateTimeOffset.Now.AddSeconds(-1), "User"));
var result = storage.FindBy(
ReminderItemFilter.ByStatus(ReminderItemStatus.Ready));
Assert.IsEmpty(result);
}
private void OnCreatedTimerTick(object _)
{
var filter = new ReminderItemFilter(DateTimeOffset.UtcNow, ReminderItemStatus.Created);
var items = _storage.FindBy(filter);
foreach (var item in items)
{
_storage.Update(item.ReadyToSend());
}
}
private void OnReadyTimerTick(object state)
{
var items = _storage.FindBy(ReminderItemFilter.FromNow());
_logger.LogInformation("Found {0} matching items", items.Length);
foreach (var item in items)
{
UpdateStatus(item, ReminderItemStatus.Ready);
}
}
private void OnSenderTimerTick(object state) //sends matching objects
{
var items = _storage.FindBy(ReminderItemFilter.ByStatus(ReminderItemStatus.Ready));
foreach (var item in items)
{
item.Status = ReminderItemStatus.Sent;
_storage.Update(item);
ReminderSent?.Invoke(this, new ReminderSentEventArgs(item));
}
}
public void GivenReadyItems_WhenFindByReadyStatus_ShouldReturnElements()
{
var storage = new ReminderItemStorage(
CreateReminderItem(datetime: DateTimeOffset.UtcNow.AddMinutes(-1), status: ReminderItemStatus.Ready));
var result = storage.FindBy(
ReminderItemFilter.ByStatus(ReminderItemStatus.Ready)
);
Assert.IsNotEmpty(result);
}
public void WhenCreatedItemsFindFromNow_ShouldReturnMatchingElements()
{
storage.Add(
new ReminderItem(Guid.NewGuid(), "header", "message two", DateTimeOffset.Now.AddMinutes(-1), "User"));
var result = storage.FindBy(ReminderItemFilter.FromNow());
Assert.IsNotEmpty(result);
Assert.AreEqual(1, result.Length);
Assert.AreEqual("message two", result[0].Message);
}
public async Task Find_GivenRemindersWithStatus_ShouldReturnNotEmptyCollection()
{
var status = ReminderItemStatus.Created;
var storage = new ReminderStorage(
Create.Reminder.WithStatus(status)
);
var result = await storage.FindByAsync(ReminderItemFilter.ByStatus(status));
CollectionAssert.IsNotEmpty(result);
}
private void OnSenderTimerTick(object state)
{
var items = _storage.FindBy(ReminderItemFilter.ByStatus(ReminderItemStatus.Ready));
foreach (var item in items)
{
item.Status = ReminderItemStatus.Sent;
_storage.Update(item);
_sender.send(new ReminderNotification(item.Title, item.Message, item.UserId));
}
}
public async Task Find_GivenRemindersInPastOrEqual_ShouldReturnNotEmptyCollection()
{
var datetime = DateTimeOffset.UtcNow;
var storage = new ReminderStorage(
Create.Reminder.AtDatetime(datetime.AddMinutes(-1)),
Create.Reminder.AtDatetime(datetime)
);
var result = await storage.FindByAsync(ReminderItemFilter.CreatedAt(datetime));
CollectionAssert.IsNotEmpty(result);
}
private void OnCreatedItemTimerTick(object _)
{
var filter = ReminderItemFilter
.ByStatus(ReminderItemStatus.Created)
.At(DateTimeOffset.Now);
var items = _storage.FindBy(filter);
foreach (var item in items)
{
_storage.Update(item.ReadyToSend());
}
}
