public async Task <ActionResult> Put(int id, [FromBody] UpdateUsuarioCommand command)
{
command.Id = id;
var response = await _mediator.Send(command);
return(Ok(response));
}
public IActionResult Put(UpdateUsuarioCommand command)
{
try
{
usuarioApplicationService.Update(command);
return(Ok(new { message = "Usuário alterado com sucesso!" }));
}
catch (ValidationException e)
{
return(BadRequest(ValidationAdapter.Parse(e.Errors)));
}
catch (UsuarioInvalidoException e)
{
return(StatusCode(418, e.Message));
}
catch (EmailJaCadastradoExcpetion e)
{
return(StatusCode(418, e.Message));
}
catch (SenhaInvalidaException e)
{
return(StatusCode(418, e.Message));
}
catch (Exception e)
{
return(StatusCode(500, e.Message));
}
}
public Task <long> UpdateUsuario(UpdateUsuarioCommand command)
{
var requestUrl = CreateRequestUri(string.Format(System.Globalization.CultureInfo.InvariantCulture,
$"{ResourceUsuario}/UpdateUsuario"));
return(Post(requestUrl, command));
}
public void Update(UpdateUsuarioCommand command)
{
var userSenha = usuarioDomainService.GetId(command.Id);
if (userSenha == null)
{
throw new UsuarioInvalidoException();
}
if (usuarioDomainService.Get(userSenha.EMail, command.Senha) == null)
{
throw new SenhaInvalidaException();
}
var userEmail = usuarioDomainService.Get(command.EMail);
if (userEmail != null && userEmail.Id != command.Id && userEmail.EMail == command.EMail)
{
throw new EmailJaCadastradoExcpetion(command.EMail);
}
var usuario = mapper.Map <Usuario>(command);
var validation = new UsuarioValidation().Validate(usuario);
if (!validation.IsValid)
{
throw new ValidationException(validation.Errors);
}
usuarioDomainService.Update(usuario);
}
public Task <HttpResponseMessage> Put([FromBody] dynamic body) // Atualiza usuário
{
var usuariosUpdate = _service.GetByEmail((string)body.emailOld);
var response = new HttpResponseMessage();
try
{
var command = new UpdateUsuarioCommand(
id: usuariosUpdate.UsuarioId,
email: (string)body.email,
senha: (string)body.senha,
nome: (string)body.nome,
perfil: (string)body.perfil
);
var usuarios = _service.Update(command);
response = Request.CreateResponse(HttpStatusCode.OK, "Atualizado com sucesso!");
}
catch
{
response = Request.CreateResponse(HttpStatusCode.BadRequest, "Não foi Atualizado o usuário!");
}
var tsc = new TaskCompletionSource <HttpResponseMessage>();
tsc.SetResult(response);
return(tsc.Task);
}
public void Handle(UpdateUsuarioCommand Message)
{
if (Message != null)
{
var usuario = _mapper.Map <Usuario>(Message);
_repository.Update(usuario);
}
}
public void Test_UpdateUsuarioValidator(string nombre, bool valid)
{
var command = new UpdateUsuarioCommand {
Id = Guid.NewGuid(), Nombre = nombre
};
var validator = new UpdateUsuarioValidator();
var result = validator.Validate(command);
Assert.Equal(valid, result.IsValid);
}
public async Task <ActionResult <Guid> > Put(Guid id, UpdateUsuarioCommand command)
{
if (id != command.Id)
{
return(BadRequest());
}
await Mediator.Send(command);
return(NoContent());
}
public async Task <IActionResult> Update([FromBody] UpdateUsuarioCommand command)
{
if (await _mediator.Send(command))
{
return(Ok("Atualização realizada com sucesso."));
}
else
{
return(this.StatusCode((int)HttpStatusCode.Forbidden, new ApplicationException("O usuário referente a chave informada não existe na base de dados.")));
}
}
public async Task <ActionResult <bool> > DeletePerfil(DeletePerfilCommand command)
{
try
{
var obj = _db.Roles.Where(x => x.Id == command.CodPerfil).FirstOrDefault();
var usersInRole =
_db.UserRoles.Where(u => u.RoleId == command.CodPerfil).Select(s => s.UserId);
foreach (var id in usersInRole)
{
var user = await _userManager.FindByIdAsync(id);
if (user != null)
{
var userRoles = await _userManager.GetRolesAsync(new WebProfileUser { Id = user.Id });
var rsRemove = await _userManager.RemoveFromRoleAsync(user, userRoles.FirstOrDefault());
if (!rsRemove.Succeeded)
{
return(null);
}
var userRole = _db.Roles.FirstOrDefault(x => x.Name.ToUpper() == command.NomPerfilUsuarioPublico.ToUpper());
await _userManager.AddToRoleAsync(user, userRole.Name);
var usuario = await Mediator.Send(new GetUsuarioByIdQuery { Id = user.Id });
var commandUsu = new UpdateUsuarioCommand
{
NomUsuario = user.Nome,
NumTelefone = user.Telefone,
CodEmpresa = usuario.CodEmpresa,
CodUnidadeInfraestrutura = usuario.CodUnidadeInfraestrutura,
CodPerfil = userRole.Id,
NomPerfil = userRole.Name,
};
var resultUsu = await Mediator.Send(commandUsu);
}
}
var result = await _roleManager.DeleteAsync(obj);
return(result.Succeeded);
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public Usuario Update(UpdateUsuarioCommand command)
{
var usuario = _repository.GetOne(command.Id);
usuario.UpdateUsuario(command.Nome, command.Email, command.Senha);
_repository.Update(usuario);
if (Commit())
{
return(usuario);
}
return(null);
}
public async Task <ActionResult <Unit> > updateUsuario([FromBody] UpdateUsuarioCommand value)
{
var authHeader = AuthenticationHeaderValue.Parse(Request.Headers["Authorization"]);
var handler = new JwtSecurityTokenHandler();
var jwtToken = handler.ReadToken(authHeader.Parameter) as JwtSecurityToken;
var rol = jwtToken.Claims.FirstOrDefault(claim => claim.Type == "role").Value;
if (rol.Equals("1"))
{
return(await Mediator.Send(value));
}
else
{
return(BadRequest());
}
// return await Mediator.Send(value);
}
public async Task <ActionResult> Edit(string id, IFormCollection collection)
{
try
{
var command = new UpdateUsuarioCommand
{
UserName = collection["EndEmail"].ToString(),
Email = collection["EndEmail"].ToString(),
NomUsuario = collection["NomUsuario"].ToString(),
NumCpf = collection["NumCpf"].ToString(),
NumTelefone = collection["NumTelefone"].ToString(),
CodUnidadeInfraestrutura = int.Parse(collection["ddlUnidadeInfraestrutura"].ToString()),
CodEmpresa = int.Parse(collection["ddlEmpresa"].ToString()),
CodPerfil = collection["ddlPerfil"].ToString(),
AlteradoPor = User.Identity.Name
};
var result = await ApiClientFactory.Instance.GetUsuarioByCpf(command.NumCpf);
if (result)
{
return(RedirectToAction(nameof(Create), new { notify = (int)EnumNotify.Error, message = "Já existe um usuário cadastrado com esse cpf." }));
}
ApiClientFactory.Instance.UpdateUsuario(command);
//var user = await _userManager.FindByEmailAsync(command.Email);
//if (user == null)
//{
// ModelState.AddModelError(string.Empty, "Usuário não cadastrado.");
// return View();
//}
//SendNewUserEmail(user, command.Email);
return(RedirectToAction(nameof(Index), new { crud = (int)EnumCrud.Updated }));
}
catch
{
return(View());
}
}
public async Task <ActionResult <bool> > UpdateUsuario(UpdateUsuarioCommand command)
{
try
{
var resultUsu = false;
var user = await _userManager.FindByEmailAsync(command.Email);
if (user != null)
{
user.Nome = command.NomUsuario;
user.PhoneNumber = command.NumTelefone;
var result = await _userManager.UpdateAsync(user);
if (result.Succeeded)
{
var userRoles = await _userManager.GetRolesAsync(new WebProfileUser { Id = user.Id });
var rsRemove = await _userManager.RemoveFromRoleAsync(user, userRoles.FirstOrDefault());
if (!rsRemove.Succeeded)
{
return(resultUsu);
}
var userRole = _db.Roles.FirstOrDefault(x => x.Id == command.CodPerfil).Name;
await _userManager.AddToRoleAsync(user, userRole);
command.Id = user.Id;
command.NomPerfil = userRole;
resultUsu = await Mediator.Send(command);
}
}
return(resultUsu);
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public async Task <IActionResult> PutUsuario([FromRoute] Guid validationId, UpdateUsuarioCommand updateUsuario) => StatusCode(await Mediator.Send(updateUsuario.SetValidationId(validationId)).ConfigureAwait(false));
