private async Task <bool> HandleAsync(UserAccount user, UserAction userAction, UpdateItemAction updateItemAction, Serialization.UserItemDataModel userItem, bool shouldItemBeActive, Func <Serialization.SortOrders, int> itemSortOrder)
{
var item = await _userItemRepository.GetItemAsync(user, userItem.UserItemId, !shouldItemBeActive);
if (item == null)
{
_logger.LogWarning($"Cannot find item that was updated: {userItem.UserItemId}");
return(false);
}
item.LastUpdateDateTime = DateTime.UtcNow;
item.UserListId = userItem.UserListId;
item.Description = userItem.Description;
item.Notes = userItem.Notes;
item.NextDueDate = userItem.NextDueDate;
item.PostponedUntilDate = userItem.PostponedUntilDate;
item.Repeat = userItem.Repeat;
item.SortOrder = userItem.SortOrder;
item.CompletedDateTime = userItem.CompletedDateTime;
item.DeletedDateTime = userItem.DeletedDateTime;
_logger.LogInformation($"Undo previous item update: {item.UserItemId}");
return(await UpdateSortOrdersAsync(user, userAction, updateItemAction, userItem, itemSortOrder));
}
public async Task <bool> Handle(SnoozeRequest request, CancellationToken cancellationToken)
{
var user = await _userAccountRepository.GetUserAccountAsync(request.User);
var item = await _userItemRepository.GetItemAsync(user, request.UserItemId);
if (item == null)
{
_logger.LogInformation($"Could not find item {request.UserItemId}");
return(false);
}
if (item.NextDueDate == null)
{
_logger.LogInformation($"Cannot set a 'postponed until date' on an item without a due date. UserItemId={request.UserItemId}");
return(false);
}
var list = item.UserListId != null ? await _userListRepository.GetListAsync(user, item.UserListId.Value) : null;
item.PostponedUntilDate = (item.PostponedUntilDate ?? item.NextDueDate.Value).AddDays(1);
await _userItemRepository.SaveAsync(item, list, _userActionsService);
return(true);
}
public async Task <bool> Handle(MarkItemAsDoneRequest request, CancellationToken cancellationToken)
{
var user = await _userAccountRepository.GetUserAccountAsync(request.User);
var item = await _userItemRepository.GetItemAsync(user, request.UserItemId);
if (item == null)
{
_logger.LogInformation($"Could not find item {request.UserItemId}");
return(false);
}
var list = item.UserListId != null ? await _userListRepository.GetListAsync(user, item.UserListId.Value) : null;
if (item.NextDueDate == null || item.Repeat == null)
{
item.CompletedDateTime = DateTime.UtcNow;
}
else
{
item.NextDueDate = CalculateNextDueDate(item.NextDueDate.Value, item.Repeat.Value);
}
item.PostponedUntilDate = null;
await _userItemRepository.SaveAsync(item, list, _userActionsService);
return(true);
}
private async Task <bool> HandleUndoAsync(UserAccount user, UserAction userAction, AddItemAction addItemAction)
{
var userItemAdded = addItemAction.GetUserItemAdded();
var item = await _userItemRepository.GetItemAsync(user, userItemAdded.UserItemId);
if (item == null)
{
_logger.LogWarning($"Cannot find item that was added: {userItemAdded.UserItemId}");
return(false);
}
item.DeletedDateTime = item.LastUpdateDateTime = DateTime.UtcNow;
_logger.LogInformation($"Undo previous add - deleted item {item.UserItemId}");
return(await UpdateSortOrdersAsync(user, userAction, addItemAction, userItemAdded, s => s.OriginalSortOrder));
}
public async Task <GetItemForEditResponse> Handle(GetItemForEditRequest request, CancellationToken cancellationToken)
{
var user = await _userAccountRepository.GetUserAccountAsync(request.User);
var item = await _userItemRepository.GetItemAsync(user, request.UserItemId);
if (item == null)
{
_logger.LogInformation($"Could not item {request.UserItemId}");
return(GetItemForEditResponse.InvalidResponse);
}
var userLists = await _userListRepository.GetListsAsync(user);
var lists = userLists
.Select(l => new UserListModel(l.UserListId.ToString(), l.Name, true))
.Prepend(new UserListModel(IndexViewModel.AllList, "All", true));
var selectedList = lists.FirstOrDefault(l => l.UserListId == item.UserListId?.ToString());
if (selectedList == null)
{
selectedList = lists.Single(l => l.UserListId == IndexViewModel.AllList);
}
return(new GetItemForEditResponse(new UserItemModel(item), lists, selectedList));
}
public async Task <bool> Handle(ReorderItemRequest request, CancellationToken cancellationToken)
{
var user = await _userAccountRepository.GetUserAccountAsync(request.User);
var item = await _userItemRepository.GetItemAsync(user, request.UserItemId);
if (item == null)
{
_logger.LogInformation($"Could not find item {request.UserItemId}");
return(false);
}
if (item.UserListId == null)
{
_logger.LogInformation($"Item {request.UserItemId} has no list - can only order items on a specific list not the implicit 'all' list");
return(false);
}
UserItem precedingItem = null;
if (request.Model.SortOrderPreviousListItemId != null)
{
precedingItem = await _userItemRepository.GetItemAsync(user, request.Model.SortOrderPreviousListItemId.Value);
if (precedingItem == null)
{
_logger.LogInformation($"Could not find preceding item {request.Model.SortOrderPreviousListItemId}");
return(false);
}
if (item.UserListId != precedingItem.UserListId)
{
_logger.LogInformation($"The list {precedingItem.UserListId} of the preceding item {precedingItem.UserItemId} is different that than list {item.UserListId} of the item to move {item.UserItemId}");
return(false);
}
}
_logger.LogInformation($"Updating order of item {item.UserItemId} [{item.Description}] to come after item {precedingItem?.UserItemId} [{precedingItem?.Description}]");
await _userItemRepository.UpdateOrderAsync(user, item, precedingItem, _userActionsService);
return(true);
}
public async Task <bool> HandleAsync(UserAccount user, UserAction userAction, bool forUndo)
{
var reorderItemsAction = GetUserAction(userAction);
foreach (var sortOrder in reorderItemsAction.GetSortOrders())
{
var item = await _userItemRepository.GetItemAsync(user, sortOrder.UserItemId);
if (item == null)
{
_logger.LogWarning($"Cannot find item that was moved [{sortOrder.UserItemId}] as part of undo/redo action: {userAction.UserActionId}");
return(false);
}
var newSortOrder = forUndo ? sortOrder.OriginalSortOrder : sortOrder.UpdatedSortOrder;
if (item.SortOrder != newSortOrder)
{
item.LastUpdateDateTime = DateTime.UtcNow;
item.SortOrder = newSortOrder;
}
_logger.LogInformation($"Undo/Redo move - re-applied sort order of item {item.UserItemId}");
}
var listSortOrder = reorderItemsAction.GetListSortOrder();
if (listSortOrder.UserListId != null)
{
var list = await _userListRepository.GetListAsync(user, listSortOrder.UserListId.Value);
if (list == null)
{
_logger.LogWarning($"Cannot find list that was updated [{listSortOrder.UserListId}] as part of item move undo/redo action: {userAction.UserActionId}");
return(false);
}
var newItemSortOrder = forUndo ? listSortOrder.OriginalSortOrder : listSortOrder.UpdatedSortOrder;
if (list.ItemSortOrder != newItemSortOrder)
{
list.LastUpdateDateTime = DateTime.UtcNow;
list.ItemSortOrder = newItemSortOrder;
}
}
return(true);
}
public async Task <bool> Handle(EditItemRequest request, CancellationToken cancellationToken)
{
var user = await _userAccountRepository.GetUserAccountAsync(request.User);
var item = await _userItemRepository.GetItemAsync(user, request.UserItemId);
if (item == null)
{
_logger.LogInformation($"Could not find item {request.UserItemId}");
return(false);
}
_logger.LogInformation($"Updating item {item.UserItemId}:" +
$" Description[{item.Description}=>{request.Model.Description}]" +
$" List[{item.UserListId}=>{request.Model.List}]" +
$" Repeat[{item.Repeat}=>{request.Model.Repeat}]" +
$" Notes[{item.Notes}=>{request.Model.Notes}]" +
$" NextDueDate[{item.NextDueDate}=>{request.Model.Due}]");
UserList list = null;
if (request.Model.Delete ?? false)
{
item.DeletedDateTime = DateTime.UtcNow;
}
else
{
item.UserAccount = user;
item.Description = request.Model.Description;
item.Notes = request.Model.Notes;
item.Repeat = request.Model.Repeat;
if (!string.IsNullOrEmpty(request.Model.List) && int.TryParse(request.Model.List, out var listId))
{
list = await _userListRepository.GetListAsync(user, listId);
if (list == null)
{
_logger.LogInformation($"Could not find list {request.Model.List}");
return(false);
}
}
if (!AddItemRequestHandler.TryGetDueDate(request.Model.Due, out var dueDate))
{
_logger.LogInformation($"Could not parse due date {request.Model.Due}");
return(false);
}
if ((request.Model.Snooze ?? false) && item.NextDueDate.HasValue)
{
item.PostponedUntilDate = (item.PostponedUntilDate ?? item.NextDueDate)?.Date.AddDays(1);
}
else
{
if (item.NextDueDate != dueDate)
{
item.PostponedUntilDate = null;
}
item.NextDueDate = dueDate;
}
}
await _userItemRepository.SaveAsync(item, list, _userActionsService);
return(true);
}
