public UsuarioVW Atualizar(UsuarioVW usuarioVM)
{
var usuario = Mapper.Map <Usuario>(usuarioVM);
_usuarioRepositorio.Atualizar(usuario);
return(usuarioVM);
}
public async Task <Resposta <Usuario> > Handle(AtualizarUsuarioComando request, CancellationToken cancellationToken)
{
var erros = _validador.Validar(request);
if (!string.IsNullOrEmpty(erros))
{
return(new Resposta <Usuario>(erros));
}
var usuario = new Usuario
{
Codigo = request.Codigo ?? 0,
Ativo = request.Ativo,
Email = request.Email,
Foto = request.Foto,
Login = request.Login,
Nome = request.Nome,
PerfilCodigo = request.PerfilCodigo,
Senha = request.Senha,
Telefone = request.Telefone,
CursoCodigo = request.CursoCodigo
};
var resultado = await _repositorio.Atualizar(usuario);
return(new Resposta <Usuario>(resultado));
}
//sobreescrevendo o atualizar
public override void Atualizar(Usuario u)
{
try
{
uRep.BeginTrasaction();
//Excluindo todos os projetos participados
paRep.ExcluirParticipacoes(u);
//Gravando selecionados
foreach (Participacao pa in u.Participacoes)
{
paRep.Inserir(pa);
}
//Encriptografando a senha
u.Senha = criptografia.EncriptarSenha(u.Senha);
//Atualizando o cadastro
uRep.Atualizar(u);
uRep.Commit();
}
catch (Exception ex)
{
uRep.Rollback();
throw new Exception(ex.Message);
}
}
public ICommandResult <Notificacao> Handler(AtualizarUsuarioCommand command)
{
try
{
Usuario usuario = UsuarioHelper.GerarEntidade(command);
AddNotificacao(usuario.Login.Notificacoes);
AddNotificacao(usuario.Senha.Notificacoes);
if (!_repository.CheckId(usuario.Id))
{
AddNotificacao("Id", "Id inválido. Este id não está cadastrado!");
}
if (_repository.CheckLogin(usuario.Login.ToString()))
{
AddNotificacao("Login", "Esse login não está disponível pois já está sendo usado por outro usuário");
}
if (Invalido)
{
return(new CommandResult <Notificacao>("Inconsistência(s) no(s) dado(s)", Notificacoes));
}
_repository.Atualizar(usuario);
AtualizarUsuarioCommandOutput dadosRetorno = UsuarioHelper.GerarDadosRetornoUpdate(usuario);
return(new CommandResult <Notificacao>("Usuário atualizado com sucesso!", dadosRetorno));
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
public ActionResult Post([FromBody] Usuario usuario)
{
try
{
var usuarioCadastrado = _usuarioRepositorio.Obter(usuario.Login);
if (usuarioCadastrado != null)
{
return(BadRequest("Usuário já cadastrado no sistema"));
}
if (usuario.Id > 0)
{
_usuarioRepositorio.Atualizar(usuario);
}
else
{
usuario.Administrador = true;
_usuarioRepositorio.Adicionar(usuario);
}
return(Ok());
}
catch (Exception ex)
{
return(BadRequest(ex.ToString()));
}
}
public async Task Atualizar(Usuario usuario)
{
if (!ExecutarValidacao(new UsuarioValidacao(), usuario))
{
return;
}
await _usuarioRepository.Atualizar(usuario);
await _mediator.Publish(new NotificacaoTeste("UsuarioService - Usuário atualizado com sucesso."));
}
public override void Atualizar(Usuario usuario)
{
var usuarioDoBanco = _usuarioRepositorio.ObterPorEmail(usuario.Email);
ValidadorRegra.Novo().Quando(usuarioDoBanco == null, "Não existe esse usuário no sitesma").DispararExcecaoSeExistir();
usuarioDoBanco.AlterarNascimento(usuario.Nascimento);
usuarioDoBanco.AlterarSenha(usuario.Senha);
_usuarioRepositorio.Atualizar(usuarioDoBanco);
}
public IActionResult AtualizarUsuario([FromBody] Usuario usuario)
{
try
{
_usuarioRepositorio.Atualizar(usuario);
return(Created("api/v1/Usuario", usuario));
}
catch (Exception ex)
{
return(BadRequest(ex.ToString()));
}
}
public List <string> Atualizar(Usuario usuario)
{
var erros = usuario.ValidarAlteracao();
if (erros.Count == 0)
{
repositorio.Atualizar(usuario);
Commit();
}
return(erros);
}
public Usuario Atualizar(Usuario usuario)
{
if (!usuario.EstaConsistente())
{
return(usuario);
}
var retorno = _usuarioRepositorio.Atualizar(usuario);
retorno.ValidationResult = usuario.ValidationResult;
return(retorno);
}
public virtual void AlterarUsuario(Usuario usuario)
{
try
{
usuario.alteracao = DateTime.Now;
_usuarioRepositorio.Atualizar(usuario);
_usuarioRepositorio.Commit();
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <UsuarioResponse> AtualizarAsync(UsuarioRequest usuarioRequest)
{
var ExisteUsuario = _usuarioRepositorio.Existe(usuarioRequest.Id);
if (!ExisteUsuario)
{
throw new ArgumentException("Usuário Não Encontrado!");
}
var usuario = _mapper.Map <Usuario>(usuarioRequest);
ValidarUsuario(usuario);
return(await Task.FromResult(_mapper.Map <UsuarioResponse>(_usuarioRepositorio.Atualizar(usuario))));
}
public async Task <Result> Atualizar(Usuario usuario)
{
if (usuario == null)
{
return(new Result(false, new[] { "Dados invalidos." }));
}
if (usuario.UsuarioInvalido())
{
return(new Result(false, usuario.Erros.ToArray()));
}
await _usuarioRepositorio.Atualizar(usuario);
return(new Result(true, string.Empty));
}
public ICommandResult Handle(AtualizarUsuarioCommand command)
{
int id = command.Id;
NomenclaturaPadrao nome = new NomenclaturaPadrao(command.Nome);
CPF cpf = new CPF(command.CPF);
Email email = new Email(command.Email);
DateTime dataNascimento = command.DataNascimento;
UF estado = new UF(command.Estado);
CEP cep = new CEP(command.CEP);
string cidade = command.Cidade;
Usuario usuario = new Usuario(id, nome, cpf, email, dataNascimento, cep, estado, cidade);
//Valida Entidade e Vo's
AddNotifications(usuario.Notifications);
//Validar Dependências
if (usuario.Id == 0)
{
AddNotification("Id", "Id não está vinculada à operação solicitada");
}
if (Invalid)
{
return(new UsuarioCommandResult(false, "Por favor, corrija as inconsistências abaixo", Notifications));
}
//Persiste os dados
string ret = _repository.Atualizar(usuario, usuario.Id);
//Notifica
if (ret == "Sucesso")
{
// Retornar o resultado para tela
return(new UsuarioCommandResult(true, "Usuário atualizado com sucesso!", new
{
Id = usuario.Id,
CPF = usuario.CPF.ToString(),
Nome = usuario.Nome.ToString()
}));
}
else
{
// Retornar o resultado para tela
return(new UsuarioCommandResult(false, "Por favor, corrija as inconsistências abaixo", ret));
}
}
public async Task <IActionResult> RedefinirSenha(LoginViewModel model)
{
if (ModelState.IsValid)
{
var usuario = await UsuarioRepositorio.PegarUsuarioPeloEmail(model.Email);
model.Senha = UsuarioRepositorio.CodificarSenha(usuario, model.Senha);
usuario.PasswordHash = model.Senha;
usuario.PrimeiroAcesso = false;
await UsuarioRepositorio.Atualizar(usuario);
await UsuarioRepositorio.LogarUsuario(usuario, false);
return(RedirectToAction(nameof(MinhasInformacoes)));
}
return(View(model));
}
public async Task <Resposta <string> > Handle(AtualizarSenhaComando request, CancellationToken cancellationToken)
{
var erros = _validador.Validar(request);
if (!string.IsNullOrEmpty(erros))
{
return(new Resposta <string>("", erros));
}
var codigoUsuarioLogado = _usuarioResolverService.RetornarCodigoUsuario();
var usuario = await _repositorio.Consultar(lnq => lnq.Codigo == codigoUsuarioLogado);
usuario.Senha = request.NovaSenha.ToMD5();
await _repositorio.Atualizar(usuario);
return(new Resposta <string>("A senha foi atualizada!", ""));
}
public ActionResult Post([FromBody] Usuario usuario)
{
try
{
usuario.Validate();
if (!usuario.EhValido)
{
return(BadRequest(usuario.ObterMensagensValidação()));
}
if (usuario.Id > 0)
{
_usuarioRepositorio.Atualizar(usuario);
}
_usuarioRepositorio.Adicionar(usuario);
var mensagemSucesso = "Operação realizada com Sucesso!";
return(Ok(mensagemSucesso));
}
catch (Exception ex)
{
return(BadRequest(ex.ToString()));
}
}
public async Task <IActionResult> Atualizar(AtualizarViewModel atualizarViewModel)
{
if (ModelState.IsValid)
{
var usuario = await _usuarioRepositorio.PegarPeloId(atualizarViewModel.UsuarioId);
if (usuario != null)
{
usuario.Nome = atualizarViewModel.Nome;
usuario.CPF = atualizarViewModel.CPF;
usuario.Email = atualizarViewModel.Email;
usuario.UserName = atualizarViewModel.NomeUsuario;
usuario.Telefone = atualizarViewModel.Telefone;
_logger.LogInformation("Atualizando ususarios");
await _usuarioRepositorio.Atualizar(usuario);
return(RedirectToAction("Index", "Usuarios"));
}
}
_logger.LogError("Informçoes invalidas");
return(View(atualizarViewModel));
}
public async Task<Resposta<string>> Handle(RedefinirSenhaComando request, CancellationToken cancellationToken)
{
var erros = _validador.Validar(request);
if (!string.IsNullOrEmpty(erros))
return new Resposta<string>(null, erros);
var email = request.Email;
var usuario = await _repositorio.Consultar(lnq => lnq.Email.Equals(email));
string senha = SenhaHelper.Gerar();
usuario.Senha = senha.ToMD5();
await _repositorio.Atualizar(usuario);
string mensagem = mensagem = $@"Sua senha no SGH foi redefinida com sucesso! <br>
Usuário: {usuario.Login}<br>
Senha: {senha}<br>
click <a>aqui</a> para acessar o sistema.";
await _emailService.Enviar(usuario.Email, "Redefinição de senha no SGH", mensagem);
return new Resposta<string>("Senha redefinida com sucesso! Foi enviado um e-mail com seus dados de acesso.", "");
}
public Usuario Alterar(Usuario usuario)
{
return(_usuarioRepositorio.Atualizar(usuario));
}
public ActionResult Atualizar([Bind(Include = "Id, Login, LoginExterno, Senha, LoginWorkflow, Nome, Email, CPF, CargoId, Administrador, Externo, Remoto, Ativo, CargoId, ValidarIP")] UsuarioViewModel viewModel, int?id)
{
if (id == null)
{
return(RedirectToAction(nameof(Index)));
}
var usuarioBusca = _usuarioRepositorio.ObterUsuarioPorId(id.Value);
if (usuarioBusca == null)
{
RegistroNaoEncontrado();
}
if (ModelState.IsValid)
{
var usuario = new Usuario(
viewModel.Login,
viewModel.LoginExterno,
viewModel.Senha,
viewModel.LoginWorkflow,
viewModel.Nome,
viewModel.Email,
viewModel.CPF,
viewModel.CargoId,
viewModel.Administrador,
viewModel.Externo,
viewModel.Remoto,
viewModel.Ativo,
viewModel.ValidarIP)
{
Id = usuarioBusca.Id
};
if (viewModel.Externo)
{
if (!string.IsNullOrEmpty(usuarioBusca.Senha) && string.IsNullOrEmpty(viewModel.Senha))
{
usuario.Senha = usuarioBusca.Senha;
}
}
if (Validar(usuario))
{
var usuarioExistente = _usuarioRepositorio.ObterUsuarioPorLogin(viewModel.Externo
? viewModel.LoginExterno
: viewModel.Login);
if (usuarioExistente != null && usuarioExistente.Id != usuarioBusca.Id)
{
ModelState.AddModelError(string.Empty, "Já existe um usuário cadastrado utilizando este login.");
}
if (viewModel.Externo && !string.IsNullOrEmpty(viewModel.Senha))
{
if (Criptografia.Encriptar(viewModel.Senha) != usuarioBusca.Senha)
{
using (var ws = new WsControleSenha.Criptografia())
{
var resultado = ws.alterarSenha(viewModel.Senha, "CRM.TB_CRM_USUARIOS", viewModel.LoginExterno);
if (resultado != "OK")
{
ModelState.AddModelError(string.Empty, resultado);
PopularContas(viewModel);
PopularCargos(viewModel);
return(View(viewModel));
}
usuario.Senha = Criptografia.Encriptar(viewModel.Senha);
_usuarioRepositorio.AlterarSenha(usuario);
}
}
}
_usuarioRepositorio.Atualizar(usuario);
TempData["Sucesso"] = true;
GravarLogAuditoria(TipoLogAuditoria.UPDATE, usuario);
}
}
PopularContas(viewModel);
PopularCargos(viewModel);
return(View(viewModel));
}
public Usuario Atualizar(Usuario cliente)
{
return(_usuarioRepositorio.Atualizar(cliente));
}
public async Task <IActionResult> Edit(string Id, Usuario usuario)
{
if (Id != usuario.Id)
{
_logger.LogError("Id enviado diferente do modelo enviado");
return(NotFound());
}
_logger.LogInformation("Validando se o modelo é valido");
if (ModelState.IsValid)
{
_logger.LogInformation("Atualizando Usuário");
_logger.LogInformation("Pegando usuário pelo model usuario.id");
var userName = await _usuarioRepositorio.PegarPeloId(usuario.Id);
userName.Nome = usuario.Nome;
userName.DataNascimento = usuario.DataNascimento;
userName.CPF = usuario.CPF;
userName.SetorId = usuario.SetorId;
userName.Status = usuario.Status;
userName.UserName = usuario.UserName;
userName.Email = usuario.Email;
userName.Telefone = usuario.Telefone;
userName.Observacao = usuario.Observacao;
userName.NormalizedUserName = usuario.UserName.ToUpper();
userName.NormalizedEmail = usuario.Email.ToUpper();
if (usuario.PasswordHash != null)
{
var senhaCriptografada = Criptografia.Codifica(usuario.PasswordHash);
userName.PasswordHash = senhaCriptografada;
}
await _usuarioRepositorio.Atualizar(userName);
_logger.LogInformation("Usuário atualizado");
TempData["Mensagem"] = "Atualizado com sucesso";
return(RedirectToAction("Index"));
}
_logger.LogInformation("Modelo não é valido");
var nivelUser = (from n in _contexto.NiveisAcessos
join r in _contexto.UserRoles
on n.Id equals r.RoleId
join u in _contexto.Usuarios
on r.UserId equals u.Id
where u.UserName == usuario.UserName
select n).FirstOrDefault();
ViewData["NivelAcessoId"] = new SelectList(_contexto.NiveisAcessos, "Name", "Name", nivelUser);
ViewData["SetorId"] = new SelectList(_contexto.Setores, "SetorId", "Descricao");
var listStatus = new SelectList(new[]
{
new{ ID = "true", NAME = "Ativo" },
new{ ID = "false", NAME = "Inativo" },
}, "ID", "NAME");
ViewData["StatusId"] = listStatus;
_logger.LogError("Informações inválidas");
return(View(usuario));
}
