public async Task <TodoListItem> Handle(CreateItem request, CancellationToken cancellationToken)
{
var accountPlan = await _accountPlanRepository.FindAccountPlanByAccountIdAsync(request.AccountId);
var plan = await _planRepository.FindPlanByIdAsync(accountPlan.PlanId);
var accountPlanAuthorization = new AccountPlanAuthorizationValidator(accountPlan, plan);
var list = await _todoListRepository.FindTodoListIdByIdAsync(request.ListId);
var todoListAuthorization = new TodoListAuthorizationValidator(list.Contributors, request.Email);
if (todoListAuthorization.IsUserAuthorized())
{
if (list == null)
{
return(null);
}
var dueDate = accountPlanAuthorization.CanAddDueDate() ? request.DueDate : null;
var id = _todoListItemRepository.NextId();
var todoItem = list.CreateListItem(id, request.Name, request.Notes, dueDate, request.Important);
await _todoListItemRepository.AddTodoListItemAsync(todoItem);
await _todoListItemRepository.SaveChangesAsync();
return(todoItem);
}
return(null);
}
protected override async Task Handle(EditItem request, CancellationToken cancellationToken)
{
var accountPlan = await _accountPlanRepository.FindAccountPlanByAccountIdAsync(request.AccountId);
var plan = await _planRepository.FindPlanByIdAsync(accountPlan.PlanId);
var accountPlanAuthorization = new AccountPlanAuthorizationValidator(accountPlan, plan);
var list = await _todoListRepository.FindTodoListIdByIdAsync(request.ListId);
var item = await _todoListItemRepository.FindToDoListItemByIdAsync(request.ItemId);
var todoListAuthorizationValidator = new TodoListAuthorizationValidator(list.Contributors, request.Email);
if (todoListAuthorizationValidator.IsUserAuthorized())
{
var dueDate = accountPlanAuthorization.CanAddDueDate() ? request.DueDate : null;
item.Name = request.Name;
item.Notes = request.Notes;
item.DueDate = dueDate;
item.EditItem(item);
await _todoListItemRepository.SaveChangesAsync();
}
}
public async Task Handle(PlanDowngraded notification, CancellationToken cancellationToken)
{
var accountPlan = await _accountPlanRepository.FindAccountPlanByAccountIdAsync(notification.Downgrade.AccountId);
var plan = await _planRepository.FindPlanByIdAsync(notification.Downgrade.PlanId);
var account = await _accountsRepository.FindAccountByIdAsync(notification.Downgrade.AccountId);
var numListsToDelete = (accountPlan.ListCount - plan.MaxLists) < 0 ? 0 : accountPlan.ListCount - plan.MaxLists;
var listsToDelete = await _listRepository.GetNumberOfTodoListsByAccountIdAsync(notification.Downgrade.AccountId, numListsToDelete);
foreach (var list in listsToDelete)
{
var accountListOwner = await _accountsListsRepository.FindAccountsListsOwnerByAccountIdAndListIdAsync(notification.Downgrade.AccountId, list.Id);
var accountListContributor = await _accountsListsRepository.FindAccountsListsContributorByAccountIdAndListIdAsync(notification.Downgrade.AccountId, list.Id);
if (accountListOwner != null)
{
var contributors = list.Contributors;
foreach (var contributor in contributors)
{
var contributorAccount = await _accountsRepository.FindAccountByEmailAsync(contributor);
var contributorPlan = await _accountPlanRepository.FindAccountPlanByAccountIdAsync(contributorAccount.Id);
var accountsListsContributor = await _accountsListsRepository.FindAccountsListsContributorByAccountIdAndListIdAsync(contributorAccount.Id, list.Id);
if (accountsListsContributor != null)
{
accountsListsContributor.MakeLeft();
contributorPlan.DecrementListCount();
list.Contributors.Remove(contributorAccount.Email);
_listRepository.UpdateListAsync(list);
}
}
accountListOwner.MoveListToTrash();
}
else if (accountListContributor != null)
{
accountListContributor.MakeLeft();
accountPlan.DecrementListCount();
list.Contributors.Remove(account.Email);
_listRepository.UpdateListAsync(list);
}
await _listRepository.SaveChangesAsync();
}
}
public async Task <IActionResult> CreateList(CreateList createTodoList)
{
var accountPlan = await _accountPlanRepository.FindAccountPlanByAccountIdAsync(User.ReadClaimAsGuidValue("urn:codefliptodo:accountid"));
var plan = await _planRepository.FindPlanByIdAsync(accountPlan.PlanId);
var accountPlanAuthorization = new AccountPlanAuthorizationValidator(accountPlan, plan);
if (!accountPlanAuthorization.CanCreateList())
{
return(BadRequest("Reached maximum number of lists allowed on your plan."));
}
createTodoList.AccountId = User.ReadClaimAsGuidValue("urn:codefliptodo:accountid");
var todoList = await _mediator.Send(createTodoList);
if (todoList == null)
{
return(BadRequest("Unable to create list :("));
}
return(Ok());
}
protected override async Task Handle(AcceptInvitaion request, CancellationToken cancellationToken)
{
var accountPlan = await _accountPlan.FindAccountPlanByAccountIdAsync(request.AccountId);
var plan = await _planRepository.FindPlanByIdAsync(accountPlan.PlanId);
var account = await _accountRepository.FindAccountByIdAsync(request.AccountId);
var list = await _listRepository.FindTodoListIdByIdAsync(request.ListId);
var accountPlanAuthorization = new AccountPlanAuthorizationValidator(accountPlan, plan);
if (accountPlanAuthorization.CanCreateList())
{
var accountsLists = await _accountsListsRepository.FindAccountsListsInvitedByAccountIdAsync(request.AccountId, request.ListId);
accountsLists.MakeContributor();
accountPlan.IncrementListCount();
list.StoreContributor(account.Email, request.AccountId);
await _listRepository.SaveChangesAsync();
}
}
public async Task Handle(PlanDowngraded notification, CancellationToken cancellationToken)
{
var accountPlan = await _accountPlanRepository.FindAccountPlanByAccountIdAsync(notification.Downgrade.AccountId);
var plan = await _planRepository.FindPlanByIdAsync(accountPlan.PlanId);
var myAccount = await _accountRepository.FindAccountByIdAsync(notification.Downgrade.AccountId);
var unownedLists = await _todoListRepository.GetUnOwnedListsAsync(notification.Downgrade.AccountId);
var ownedLists = await _todoListRepository.GetOwnedListsAsync(notification.Downgrade.AccountId);
if (plan.MaxContributors == 0)
{
foreach (var ownedList in ownedLists)
{
var contributors = RemoveSelfFromContributorSignalRHelper.RemoveContributor(ownedList, myAccount.Email);
var contributorsCount = contributors.Count;
for (var i = 0; i < contributorsCount; i++)
{
var contributor = contributors[i];
var account = await _accountRepository.FindAccountByEmailAsync(contributor);
var contributorAccountList = await _accountsListsRepository.FindAccountsListsContributorByAccountIdAndListIdAsync(account.Id, ownedList.Id);
var contributorAccountPlan = await _accountPlanRepository.FindAccountPlanByAccountIdAsync(account.Id);
contributorAccountList.MakeLeft();
contributorAccountPlan.DecrementListCount();
ownedList.Contributors.Remove(contributor);
_todoListRepository.UpdateListAsync(ownedList);
await _todoListRepository.SaveChangesAsync();
}
}
foreach (var unownedList in unownedLists)
{
var accountList = await _accountsListsRepository.FindAccountsListsContributorByAccountIdAndListIdAsync(notification.Downgrade.AccountId, unownedList.Id);
accountList.MakeLeft();
accountPlan.DecrementListCount();
unownedList.Contributors.Remove(myAccount.Email);
_todoListRepository.UpdateListAsync(unownedList);
await _todoListRepository.SaveChangesAsync();
}
}
else
{
var contributorCount = ownedLists.Count;
if (plan.MaxContributors < contributorCount)
{
foreach (var ownedList in ownedLists)
{
var contributors = RemoveSelfFromContributorSignalRHelper.RemoveContributor(ownedList, myAccount.Email);
foreach (var contributor in contributors)
{
var accountContributor = await _accountRepository.FindAccountByEmailAsync(contributor);
var contributorAccountList = await _accountsListsRepository.FindAccountsListsContributorByAccountIdAndListIdAsync(notification.Downgrade.AccountId, ownedList.Id);
var contributorAccountPlan = await _accountPlanRepository.FindAccountPlanByAccountIdAsync(notification.Downgrade.AccountId);
contributorAccountList.MakeLeft();
contributorAccountPlan.DecrementListCount();
ownedList.Contributors.Remove(accountContributor.Email);
_todoListRepository.UpdateListAsync(ownedList);
await _accountsListsRepository.SaveChangesAsync();
}
}
}
}
}
public async Task <bool> Handle(SendInvitation request, CancellationToken cancellationToken)
{
var accountPlan = await _accountPlanRepository.FindAccountPlanByAccountIdAsync(request.SenderAccountId);
var plan = await _planRepository.FindPlanByIdAsync(accountPlan.PlanId);
var list = await _todoListRepository.FindTodoListIdByIdAsync(request.ListId);
var accountsLists = await _accountsListsRepository.FindAccountsListsByAccountIdAndListIdAsync(request.SenderAccountId, request.ListId);
var accountPlanAuthorization = new AccountPlanAuthorizationValidator(accountPlan, plan);
if (accountsLists.UserIsOwner(request.SenderAccountId))
{
if (accountPlanAuthorization.CanAddContributor(list))
{
var invitee = await _accountRepository.FindAccountByEmailAsync(request.InviteeEmail);
var inviteeAccountsListsLeft = await _accountsListsRepository.FindAccountsListsLeftByAccountIdAsync(invitee.Id, request.ListId);
var inviteeAccountsListsDeclined = await _accountsListsRepository.FindAccountsListsDeclinedByAccountIdAsync(invitee.Id, request.ListId);
var inviteeAccountsLists = await _accountsListsRepository.FindAccountsListsByAccountIdAndListIdAsync(invitee.Id, request.ListId);
var inviteeAccountPlan = await _accountPlanRepository.FindAccountPlanByAccountIdAsync(invitee.Id);
if (inviteeAccountPlan.PlanId == PlanTiers.Free)
{
return(false);
}
if (inviteeAccountsLists != null && inviteeAccountsLists.UserIsAlreadyInvited(invitee.Id))
{
return(false);
}
if (list.DoesContributorExist(invitee.Email))
{
return(false);
}
if (inviteeAccountsListsDeclined != null)
{
inviteeAccountsListsDeclined.MakeInvited();
}
else if (inviteeAccountsListsLeft != null)
{
inviteeAccountsListsLeft.MakeInvited();
}
else
{
await _accountsListsRepository.AddAccountsListsInvitedAsync(invitee.Id, request.ListId);
}
await _todoListRepository.SaveChangesAsync();
return(true);
}
}
return(false);
}
