コード例 #1
0
        public virtual async Task KickUserFromToDoGroup(KickAnotherUserFromMyToDoGroupArge args, CancellationToken cancellationToken)
        {
            Guid userId = Guid.Parse(UserInformationProvider.GetCurrentUserId());

            ToDoGroup toDoGroupsToBeKickFrom = await ToDoGroupsRepository.GetAll()
                                               .Where(tdg => tdg.Id == args.toDoGroupId)
                                               .Select(tdg => new ToDoGroup
            {
                Id          = tdg.Id,
                CreatedById = tdg.CreatedById,
                Items       = tdg.Items.Select(tdi => new ToDoItem
                {
                    Id      = tdi.Id,
                    Options = tdi.Options.Where(tdio => tdio.UserId == args.userId).Select(tdio => new ToDoItemOptions
                    {
                        Id     = tdio.Id,
                        UserId = tdio.UserId
                    }).ToList()
                }).ToList()
            }).FirstOrDefaultAsync(cancellationToken);;

            if (toDoGroupsToBeKickFrom == null)
            {
                throw new ResourceNotFoundException("ToDoGroupCouldNotBeFound");
            }

            if (toDoGroupsToBeKickFrom.CreatedById != userId)
            {
                throw new DomainLogicException("OnlyOwnerCanKickOtherUsers");
            }

            User kickedUser = await UsersRepository.GetByIdAsync(cancellationToken, args.userId);

            if (kickedUser == null)
            {
                throw new ResourceNotFoundException("UserCouldNotBeFoundToBeKicked");
            }

            foreach (ToDoItemOptions toDoItemOptionsToBeDeleted in toDoGroupsToBeKickFrom.Items.SelectMany(tdi => tdi.Options) /* We've loaded options of to be kicked user only! */)
            {
                await ToDoItemOptionsListRepository.DeleteAsync(toDoItemOptionsToBeDeleted, cancellationToken);
            }

            ToDoGroupOptions toDoGroupOptionsToBeDeleted = await ToDoGroupOptionsListRepository.GetAll().FirstOrDefaultAsync(tdo => tdo.ToDoGroupId == args.toDoGroupId && tdo.UserId == args.userId);

            await ToDoGroupOptionsListRepository.DeleteAsync(toDoGroupOptionsToBeDeleted, cancellationToken);
        }
コード例 #2
0
        public virtual async Task <ToDoGroupDto> UpdateToDoGroup(Guid key, ToDoGroupDto toDoGroup, CancellationToken cancellationToken)
        {
            if (toDoGroup == null)
            {
                throw new BadRequestException("ToDoGroupMayNotBeNull");
            }

            Guid userId = Guid.Parse(UserInformationProvider.GetCurrentUserId());

            ToDoGroup toDoGroupToBeModified = await ToDoGroupsRepository.GetByIdAsync(cancellationToken, key);

            if (toDoGroupToBeModified == null)
            {
                throw new ResourceNotFoundException("ToDoGroupCouldNotBeFound");
            }

            ToDoGroupOptions toDoGroupOptionsToBeModified = await ToDoGroupOptionsListRepository.GetAll()
                                                            .FirstAsync(tdgo => tdgo.UserId == userId && tdgo.ToDoGroupId == key, cancellationToken);

            if (toDoGroupOptionsToBeModified == null)
            {
                throw new ResourceNotFoundException("ToDoGroupCouldNotBeFound");
            }

            toDoGroupToBeModified.Title      = toDoGroup.Title;
            toDoGroupToBeModified.ModifiedOn = DateTimeProvider.GetCurrentUtcDateTime();

            toDoGroupOptionsToBeModified.Theme = toDoGroup.Theme;
            toDoGroupOptionsToBeModified.HideCompletedToDoItems = toDoGroup.HideCompletedToDoItems;
            toDoGroupOptionsToBeModified.SortedBy = toDoGroup.SortedBy;

            await ToDoGroupsRepository.UpdateAsync(toDoGroupToBeModified, cancellationToken);

            await ToDoGroupOptionsListRepository.UpdateAsync(toDoGroupOptionsToBeModified, cancellationToken);

            return(await GetMyToDoGroups()
                   .FirstAsync(tdg => tdg.Id == key, cancellationToken));
        }