public async Task <Response <UserResponse> > Handle(AtualizarRequest <UserRequest, UserResponse> request, CancellationToken cancellationToken)
        {
            var error = new Response <UserResponse>();

            try
            {
                if (request.User.Id == request.Id && request.Id == request.Entidade.Id)
                {
                    var user = _mapper.Map <UserRequest, User>(request.Entidade);

                    user.Password = request.User.Password;

                    user.Created = request.User.Created;

                    _context.Entry(request.User).State = Microsoft.EntityFrameworkCore.EntityState.Detached;

                    var resultado = await _repository.AtualizarEntidadeAsync(user);

                    var response = _mapper.Map <User, UserResponse>(resultado);

                    return(await Task.FromResult(new Response <UserResponse>(response)));
                }
                else
                {
                    throw new ActionNotPermittedException();
                }
            }
            catch (Exception e)
            {
                error.AddError(e.Source, e.Message);
            }

            return(await Task.FromResult(error));
        }
Beispiel #2
0
        public async Task <Response <CommentResponse> > Handle(AtualizarRequest <CommentRequest, CommentResponse> request, CancellationToken cancellationToken)
        {
            var error = new Response <CommentResponse>();

            try
            {
                var temAutorizacao = await _repository.ObterQueryEntidade()
                                     .AnyAsync(p => p.Id == request.Id && p.User.Username == request.User.Username);

                if (!temAutorizacao)
                {
                    throw new ActionNotPermittedException();
                }

                var comment = _mapper.Map <CommentRequest, Comment>(request.Entidade);

                comment.User = request.User;

                var commentAtualizado = await _repository.AtualizarEntidadeAsync(comment);

                var response = _mapper.Map <Comment, CommentResponse>(commentAtualizado);

                return(await Task.FromResult(new Response <CommentResponse>(response)));
            }
            catch (Exception e)
            {
                error.AddError(e.Source, e.Message);
            }

            return(await Task.FromResult(error));
        }
Beispiel #3
0
        public async Task <Response <FriendshipResponse> > Handle(AcceptFriendCommand request, CancellationToken cancellationToken)
        {
            var error = new Response <FriendshipResponse>();

            try
            {
                var userWhoDoTheRequest = _repositoryU.ObterQueryEntidade()
                                          .FirstOrDefault(u => u.Username == request.Username);

                var friendship = _repositoryF.ObterQueryEntidade()
                                 .FirstOrDefault(f => f.To == request.User && f.From == userWhoDoTheRequest);

                friendship.ConfirmationDate ??= DateTime.Now;

                var friendshipUpdated = await _repositoryF.AtualizarEntidadeAsync(friendship);

                var response = _mapper.Map <Friendship, FriendshipResponse>(friendshipUpdated);

                return(await Task.FromResult(new Response <FriendshipResponse>(response)));
            }
            catch (Exception e)
            {
                error.AddError(e.Source, e.Message);
            }

            return(await Task.FromResult(error));
        }