public async Task Deve_Verificar_Metodo_E_Retornar_Verdadeiro_Quando_Remover_Usuario()
{
// Arrange
var command = new UserDeleteCommand()
{
ID = Guid.NewGuid()
};
var user = new User()
{
ID = command.ID,
};
_moqUserRepository
.Setup(p => p.RetrieveByIDAsync(command.ID, default))
.ReturnsAsync(user);
_moqUserRepository
.Setup(p => p.Delete(user));
_moqUnitOfWork
.Setup(p => p.CommitAsync())
.ReturnsAsync(1);
// Act
var result = await GetHandler().Handle(command, default);
// Assert
result.Value.Should().BeTrue();
}
public async Task TruckHandler_delete_invalid_notsave()
{
var mockContextRepository = new Mock <IContextRepository>();
var mockUserRepository = new Mock <IUserRepository>();
UserDeleteCommand userDeleteCommand = new UserDeleteCommand("b627435c-45ed-43e0-8969-e20ae10b4f21");
User _user = new User()
{
Email = "*****@*****.**",
Id = "b627435c-45ed-43e0-8969-e20ae10b4f21",
Login = "******",
Name = "name",
Password = "******",
Role = "Administrator"
};
mockUserRepository.Setup(x => x.GetById(It.IsAny <string>())).ReturnsAsync(_user);
mockContextRepository.Setup(x => x.Delete(It.IsAny <User>())).ReturnsAsync(false);
UserHandler _handler = new UserHandler(mockContextRepository.Object, mockUserRepository.Object);
var _return = await _handler.Handle(userDeleteCommand);
Assert.False(_return.Success);
Assert.False((bool)_return.Data);
Assert.Equal(HttpStatusCode.BadRequest, _return.Code);
}
public async Task <ICommandResult> Handle(UserDeleteCommand command)
{
//FFV
command.Validate();
if (command.Invalid)
{
return(new GenericCommandResult(false, HttpStatusCode.BadRequest, command.Notifications));
}
var _verify = await _userRepository.GetById(command.Id);
if (_verify == null)
{
return(new GenericCommandResult(false, HttpStatusCode.NotFound, _verify));
}
User _entity = new User();
_entity.Id = command.Id;
var _result = await _contextRepository.Delete(_entity);
//retorna o resultado
if (!_result)
{
return(new GenericCommandResult(false, HttpStatusCode.BadRequest, _result));
}
return(new GenericCommandResult(true, HttpStatusCode.OK, _result));
}
public async Task <bool> DeleteAsync(UserDeleteCommand command)
{
var user = _mapper.Map <User>(command);
await _repository.DeleteAsync(user.ID);
return(await CommitAsync() > 0);
}
public async Task <ResponseViewModel> DeleteAsync(string guidUser, string guidProfile)
{
// Obs: Fiz pensando em ser um para um entre usuário e perfil, poderia ser um para muitos e ai neste caso não excluiria o perfil quando o usuário fosse excluido
using (_unitOfWork)
{
// Inicia a transação
_unitOfWork.BeginTransaction();
// Remove o Usuário
UserDeleteCommand userDeleteCommand = new UserDeleteCommand(guidUser);
ResponseCommand userAddResponse = await _mediator.Send(userDeleteCommand, CancellationToken.None).ConfigureAwait(true);
if (!userAddResponse.Success)
{
return(new ResponseViewModel(false, userAddResponse.Object));
}
// Deleta o Perfil
ProfileDeleteCommand profileDeleteCommand = new ProfileDeleteCommand(guidProfile);
ResponseCommand profileDeleteResponse = await _mediator.Send(profileDeleteCommand, CancellationToken.None).ConfigureAwait(true);
if (!profileDeleteResponse.Success)
{
return(new ResponseViewModel(false, profileDeleteResponse.Object));
}
// Comita e Retorna
_unitOfWork.CommitTransaction();
return(new ResponseViewModel(true, "User deleted"));
}
}
public void Delete(UserDeleteCommand request)
{
const string sql = "" +
" DELETE FgjCqrsUser " +
" WHERE Guid = @Guid";
_unitOfWork.Connection.Execute(sql, request, _unitOfWork?.Transaction);
}
public async Task <IActionResult> Delete(int userId)
{
var userDeleteCommand = new UserDeleteCommand(userId);
await _commandDispather.Execute(userDeleteCommand);
return(NoContent());
}
public void TranslateExternalDeleteCommandToAkkaMessage(HTTPSourcedCommand cmdExternal)
{
JObject jo = cmdExternal.Data as JObject;
string id = jo.Value <string>("Id") ?? jo.Value <string>("id");
UserDeleteCommand deleteCmd = new UserDeleteCommand(id, cmdExternal.User, cmdExternal.ConnectionId);
SendTo.Tell(deleteCmd, ReplyTo);
}
public async Task <IActionResult> DeleteUser(int id)
{
var command = new UserDeleteCommand(id);
var result = await _mediator.Send(command);
return(result != null
? (IActionResult)Ok(result)
: BadRequest(string.Format(ModelConstants.PropertyNotFoundFromController, "იუზერი")));
}
public void UserDeleteCommand_valid()
{
UserDeleteCommand _command = new UserDeleteCommand(id);
_command.Validate();
Assert.True(_command.Valid);
Assert.False(_command.Invalid);
}
public void UserDeleteCommand_invalid(string param)
{
UserDeleteCommand _command = new UserDeleteCommand(param);
_command.Validate();
Assert.False(_command.Valid);
Assert.True(_command.Invalid);
}
public async Task <GenericCommandResult> DeleteUser(
//[FromBody] CategoryDeleteCommand command,
[FromQuery] string id,
[FromServices] IHandler <UserDeleteCommand> handler)
{
UserDeleteCommand command = new UserDeleteCommand(id);
return((GenericCommandResult)await handler.Handle(command));
}
public Task DeleteUser(Guid id, CancellationToken cancellationToken)
{
var command = new UserDeleteCommand
{
Id = id
};
return(mediator.Send(command, cancellationToken));
}
public async Task <IActionResult> Delete(string id, int version)
{
var cmd = new UserDeleteCommand {
Id = id, Version = version, UpdateTime = DateTime.Now
};
await _bus.SendAsync(cmd);
return(Json(Respond.Succeed));
}
public IActionResult Delete(UserDeleteCommand command)
{
var delete = _userService.Delete(command);
if (delete.IsError)
{
return(BadRequest(delete));
}
return(Ok(delete));
}
public IHttpActionResult Delete(UserDeleteCommand user)
{
var validator = user.Validation();
if (!validator.IsValid)
{
return(HandleValidationFailure(validator.Errors));
}
return(HandleCallback(() => UserAppService.Delete(user)));
}
public async Task <IActionResult> RemoveUser(Guid id)
{
var command = new UserDeleteCommand()
{
Id = id,
};
await this._mediator.Send(command);
return(this.Ok(new { }));
}
public void Handle(UserDeleteCommand command)
{
var userId = new UserId(command.Id);
var user = userRepository.Find(userId);
if (user == null)
{
throw new UserNotFoundException(userId);
}
userRepository.Delete(user);
}
public void Delete(UserDeleteCommand command)
{
var id = new UserId(command.Id);
var user = userRepository.Find(id);
if (user == null)
{
return;
}
userRepository.Delete(user);
}
public void Delete(UserDeleteCommand command)
{
var targetId = new UserId(command.Id);
var user = userRepository.Find(targetId);
if (user == null)
{
// 対象が見つからなかったため退会成功とする
return;
}
userRepository.Delete(user);
}
public void Delete(UserDeleteCommand command)
{
var targetId = new UserId(command.Id);
var user = userRepository.Find(targetId);
if (user == null)
{
// 탈퇴 대상 사용자가 발견되지 않았다면 탈퇴 처리 성공으로 간주한다
return;
}
userRepository.Delete(user);
}
private void PostDeleteHandler(UserDeleteCommand c)
{
// Deleting a User is not permanently removing them from the datastore but rather a simple state change to inactive.
_ActorState.isActive = false;
// Once a User has been marked as inactive we want to save the state so that future incarnations of the actor will
// be in a inactive state.
AutoSaveSnapshot(true);
_logger.Debug($"User:{c.User} delete command recorded for User id:{_ActorState.Id}.");
NotifyCommandEventSubscribers(new UserDeleteRecordedEvent(Sender, c, c.User, c.ConnectionId));
}
public ICommandResult Handle(UserDeleteCommand command)
{
var user = _userRepository.GetById(command.Id);
if (user == null)
{
return(new GenericCommandResult(false, "Usuário não localizado", null));
}
_userRepository.Delete(user);
return(new GenericCommandResult(true, "Usuário excluído com sucesso", null));
}
public ICommandResult Delete(UserDeleteCommand command)
{
try
{
var user = _userRepository.Read(command.Id);
_userRepository.Delete(user);
var commandResult = new CommandResult("Usuário deletado com sucesso!", user, false);
return(commandResult);
}
catch (Exception ex)
{
var commandResult = new CommandResult($"{ex.InnerException.Message}", null, true);
return(commandResult);
}
}
public void Handle(UserDeleteCommand command)
{
var targetId = new UserId(command.Id);
var user = _userRepository.Find(targetId);
if (user == null)
{
// TODO: 削除対象が既にいないので例外を送出しないという判断もあり
// return;
// throw new UserNotFoundException(targetId);
throw new Exception();
}
_userRepository.Delete(user);
}
public void Delete(UserDeleteCommand command)
{
using (var transaction = new TransactionScope())
{
var id = new UserId(command.Id);
var user = userRepository.Find(id);
if (user == null)
{
return;
}
userRepository.Delete(user);
transaction.Complete();
}
}
public async Task Deve_Verificar_Metodo_E_Retornar_Falha_De_Usuario_Nao_Encontrado()
{
// Arrange
var command = new UserDeleteCommand()
{
ID = Guid.NewGuid()
};
User user = null;
_moqUserRepository
.Setup(p => p.RetrieveByIDAsync(command.ID, default))
.ReturnsAsync(user);
// Act
var result = await GetHandler().Handle(command, default);
// Assert
result.Error.Should().Be(ErrorType.NotFound.ToString());
}
public async Task TruckHandler_delete_invalid_notfound()
{
var mockContextRepository = new Mock <IContextRepository>();
var mockUserRepository = new Mock <IUserRepository>();
UserDeleteCommand userDeleteCommand = new UserDeleteCommand("b627435c-45ed-43e0-8969-e20ae10b4f21");
User _user = new User();
_user = null;
mockUserRepository.Setup(x => x.GetById(It.IsAny <string>())).ReturnsAsync(_user);
mockContextRepository.Setup(x => x.Delete(It.IsAny <User>())).ReturnsAsync(true);
UserHandler _handler = new UserHandler(mockContextRepository.Object, mockUserRepository.Object);
var _return = await _handler.Handle(userDeleteCommand);
Assert.False(_return.Success);
Assert.Null(_return.Data);
Assert.Equal(HttpStatusCode.NotFound, _return.Code);
}
public async Task DeleteAsync(UserDeleteCommand cmd)
{
await ExecuteAsyncNoReturn <UserDeleteCommand, UserDeleteCommandValidator>(cmd, async() =>
{
// get the user by unique id
var user = Get <User>(a => a.Id.Equals(cmd.Id));
// if the user does not exist then there is nothing for us to do. The intent is satisfied
if (null == user)
{
return;
}
// delete the user
user.Delete(deletedByUserId: MessageContext.UserId);
// save the deleted user (soft delete)
await Database.SaveAsync(user).ConfigureAwait(false);
// publish the domain event
Publish(new UserDeletedEvent(UserFactory.ConvertToModel(user), MessageContext));
}).ConfigureAwait(false);
}
public async Task Deve_Verificar_Metodo_Com_Retorno_BadRequest_Quando_Resultado_For_Falha()
{
// Arrange
var command = new UserDeleteCommand
{
ID = Guid.NewGuid()
};
var expectedResult = "BadRequest";
_moqMediator
.Setup(p => p.Send(command, default))
.ReturnsAsync(Result.Failure <bool>(expectedResult));
// Act
var result = await GetController().DeleteAsync(command);
// Assert
var badRequest = result as BadRequestObjectResult;
badRequest.StatusCode.Should().Be(400);
badRequest.Value.Should().Be(expectedResult);
}
