public ActionResult AlterarSenha(AlterarSenhaViewModel model)
{
if (ModelState.IsValid)
{
var claimsIdentity = User.Identity as ClaimsIdentity;
int usuarioId = 0;
int.TryParse(claimsIdentity.FindFirst("Id").Value, out usuarioId);
var result = usuarioClient.AlterarSenha(model.SenhaAntigaHash, model.SenhaNovaHash, usuarioId);
if (result.Sucesso)
{
AuthenticationManager.SignOut(DefaultAuthenticationTypes.ApplicationCookie);
var redirectUrl = new UrlHelper(Request.RequestContext).Action("ConfirmacaoAlteracaoSenha", "Account");
return(Json(new { Url = redirectUrl }));
}
else
{
ModelState.AddModelError("", result.Mensagem);
return(RetornarComErro(ModelState));
}
}
else
{
this.Response.StatusCode = (int)HttpStatusCode.BadRequest;
return(new JsonResult {
Data = new { codes = ModelState.SelectMany(m => m.Value.Errors).Select(e => e.ErrorMessage) }
});
}
return(View());
}
public ActionResult AlterarSenha(AlterarSenhaViewModel alterarSenhaView)
{
if (!ModelState.IsValid)
{
return(View());
}
//using System.Security.Claims;
var identity = User.Identity as ClaimsIdentity; //Captura o usuário logado, fazendo o cast (conversão) para o tipo ClaimsIdentity
var login = identity.Claims.FirstOrDefault(u => u.Type == "Login").Value;
var usuario = db.Usuarios.FirstOrDefault(u => u.Login == login);
if (alterarSenhaView.SenhaAtual.CriptografarSenha() != usuario.Senha)
{
ModelState.AddModelError("SenhaAtual", "A Senha digitada está incorreta!");
return(View());
}
if (alterarSenhaView.NovaSenha.CriptografarSenha() == usuario.Senha)
{
ModelState.AddModelError("NovaSenha", "A Senha nova está igual antiga!");
return(View());
}
usuario.Senha = alterarSenhaView.NovaSenha.CriptografarSenha();
db.Entry(usuario).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
TempData["Mensagem"] = "Senha alterada com sucesso!";
return(RedirectToAction("Index", "Painel"));
}
public ActionResult _AltSenha(AlterarSenhaViewModel modelViewModel)
{
//ViewBag.IdCategoria = new SelectList(_categoriaApp.GetAll(), "IdCategoria", "Descricao", ProdutoViewModel.IdCategoria);
if (ModelState.IsValid)
{
string code = UserManager.GeneratePasswordResetToken(modelViewModel.Id);
IdentityResult result = UserManager.ResetPassword(modelViewModel.Id, code, modelViewModel.Password);
//return RedirectToAction("Index");
if (result.Succeeded)
{
//_clienteApp.Update(ClienteViewModel);
return(Json(new { success = true }));
}
else
{
foreach (var validationAppError in result.Errors)
{
ModelState.AddModelError(string.Empty, validationAppError);
}
return(PartialView(modelViewModel));
}
//return Json(new { Url = Url.Action("_AltPreco", produtoPrecoViewModel) });
//return Json(produtoPrecoViewModel, JsonRequestBehavior.AllowGet);
}
return(PartialView(modelViewModel));
}
public HttpResponseMessage MudarSenha([FromBody] AlterarSenhaViewModel model)
{
try
{
if (model == null)
{
return(Request.CreateResponse(HttpStatusCode.NotAcceptable, "Campos Inválidos", "text/plain"));
}
if (ModelState.IsValid)
{
var userid = int.Parse(Helper.GetJWTPayloadValue(Request, "id"));
var user = _UserRepo.GetById(userid);
if (Hashing.ValidatePassword(model.SenhaAntiga, user.Password))
{
user.Password = Hashing.HashPassword(model.NovaSenha);
_UserRepo.Update(user);
return(Request.CreateResponse(HttpStatusCode.OK, "Senha Alterada com Successo", "text/plain"));
}
return(Request.CreateResponse(HttpStatusCode.NotAcceptable, "Senha Antiga Inválida", "text/plain"));
}
var errorObj = ModelStateErrors.DisplayModelStateError(ModelState);
return(Request.CreateResponse(HttpStatusCode.NotAcceptable, errorObj, "text/plain"));
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, ex.Message));
}
}
public ActionResult AlterarSenha(AlterarSenhaViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(View());
}
//CAPTURADANDO O LOGIN PARA EFETUAR A TROCA DA SENHA
var identity = User.Identity as ClaimsIdentity;
var login = identity.Claims.FirstOrDefault(c => c.Type == "Login").Value;
var usuario = db.Usuarios.FirstOrDefault(u => u.Login == login);
//COMPARANDO SE A SENHA ATUAL DIGITADA É A MESMA CONTIDA NO BANCO
if (Hash.GerarHash(viewModel.SenhaAtual) != usuario.Senha)
{
ModelState.AddModelError("SenhaAtual", "Senha incorreta");
return(View());
}
//A SENHA ESTANADO CORRETA
usuario.Senha = Hash.GerarHash(viewModel.NovaSenha);
db.Entry(usuario).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
TempData["Mensagem"] = "Senha alterada com sucesso";
return(RedirectToAction("Index", "Painel"));
}
public ActionResult AlterarSenha(AlterarSenhaViewModel model)
{
if (!ModelState.IsValid)
{
return(View());
}
var identity = User.Identity as ClaimsIdentity;
//Obtém o login do usuário autenticado
var login = identity.Claims.FirstOrDefault(x => x.Type == "Login").Value;
//Obtém o usuário do banco de dados.
var usuario = db.Usuarios.FirstOrDefault(x => x.Login == login);
//Se a senha atual corresponde com a senha do usuário autenticado.
if (Hash.GerarHash(model.SenhaAtual) != usuario.Senha)
{
ModelState.AddModelError("SenhaAtual", "Senha incorreta");
return(View());
}
usuario.Senha = Hash.GerarHash(model.NovaSenha);
db.Entry(usuario).State = EntityState.Modified;
db.SaveChanges();
TempData["Mensagem"] = "A senha foi alterada com sucesso.";
return(RedirectToAction("Index", "Home"));
}
public ActionResult AlterarSenha(AlterarSenhaViewModel viewmodel)
{
//validamos o ModelState para verificar as regras definidas via Data Annotationsk
if (!ModelState.IsValid)
{
return(View());
}
//capturamos o usuário que está logado atualmente;
var identity = User.Identity as ClaimsIdentity;
//obtemos o login do usuário conectado;
var login = identity.Claims.FirstOrDefault(c => c.Type == "Login").Value;
//filtramos no banco o usuário logado para que possamos comparar sua senha com a que foi digitada;
var usuario = db.Usuarios.FirstOrDefault(u => u.Login == login);
//caso a senha digitada esteja incorreta, retornamos para a view com esse erro;
if (Hash.GerarHash(viewmodel.SenhaAtual) != usuario.Senha)
{
ModelState.AddModelError("SenhaAtual", "Senha incorreta");
return(View());
}
//alteramos a senha do usuário e gravamos essa modificação no banco de dados;
usuario.Senha = Hash.GerarHash(viewmodel.NovaSenha);
db.Entry(usuario).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
TempData["Mensagem"] = "Senha alterada com sucesso";
//Retornamos para a página inicial do painel.
return(RedirectToAction("Index", "Painel"));
}
public ActionResult AlterarSenha(AlterarSenhaViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(View());
}
var identity = User.Identity as ClaimsIdentity;
var login = identity.Claims.FirstOrDefault(x => x.Type == "Login").Value;
var usuario = ctx.Usuarios.FirstOrDefault(x => x.Login == login);
if (Hash.GerarHash(viewModel.SenhaAtual) != usuario.Senha)
{
ModelState.AddModelError("SenhaAtual", "Senha Incorreta");
return(View());
}
usuario.Senha = Hash.GerarHash(viewModel.NovaSenha);
ctx.Entry(usuario).State = EntityState.Modified;
ctx.SaveChanges();
TempData["Mensagem"] = "Senha alterada com sucesso";
return(RedirectToAction("Index", "Painel"));
}
public ActionResult AlterarSenha(AlterarSenhaViewModel AlterarSenhaViewModel)
{
if (!ModelState.IsValid)
{
return(View());
}
var identity = User.Identity as ClaimsIdentity;
var login = identity.Claims.FirstOrDefault(c => c.Type == "Login").Value;
var usuario = db.Usuarios.FirstOrDefault(u => u.Login == login);
if (EsperaCriativa.Utils.Hash.GeraHash(AlterarSenhaViewModel.SenhaAtual) != usuario.Senha)
{
ModelState.AddModelError("SenhaAtual", "Senha incorreta");
return(View());
}
usuario.Senha = EsperaCriativa.Utils.Hash.GeraHash(AlterarSenhaViewModel.NovaSenha);
db.Entry(usuario).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
TempData["Mensagem"] = "Senha alterada com sucesso";
return(RedirectToAction("Index", "Home"));
}
public ActionResult AlterarSenha(AlterarSenhaViewModel model)
{
using (NimbusAcad_DB_Entities db = new NimbusAcad_DB_Entities())
{
if (!ModelState.IsValid)
{
return(View(model));
}
string userEmail = User.Identity.Name;
RBAC_Usuario RU = db.RBAC_Usuario.Where(o => o.Username.Equals(userEmail)).FirstOrDefault();
if (RU == null)
{
return(RedirectToAction("AlterarSenhaConfirmacao", "Gerenciar"));
}
var result = _userStore.ChangePassword(RU.Usuario_ID, model);
if (result.Equals(OperationStatus.Success))
{
return(RedirectToAction("AlterarSenhaConfirmacao", "Gerenciar"));
}
AddErrors(result);
return(View());
}
}
public async Task <IActionResult> AlterarSenha(AlterarSenhaViewModel vm)
{
try
{
ModelState.Clear();
await UsuarioService.AlterarSenha(Usuario.Identificao.Id, vm?.SenhaAtual, vm?.NovaSenha, vm?.ConfirmarNovaSenha, ConteudoResource.EmailRecuperacao)
.ConfigureAwait(true);
ExibirMensagemSucesso(MensagemResource.SenhaAlteradaSucesso);
}
catch (MensagemException ex)
{
ExibirMensagemErro(ex);
}
catch (Exception)
{
ExibirMensagemErro(MensagemResource.Erro);
}
if (!string.IsNullOrWhiteSpace(vm?.ReturnUrl))
{
return(Redirect(vm.ReturnUrl));
}
return(RedirectToAction(nameof(Index), "Home"));
}
public ActionResult AlterarSenha(AlterarSenhaViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(View());
}
var identity = User.Identity as ClaimsIdentity;
//Login do usuário que está logado
var login = identity.Claims.FirstOrDefault(c => c.Type == "Login").Value;
var usuario = db.Usuarios.FirstOrDefault(u => u.Login == login);
if (Hash.GerarHash(viewModel.SenhaAtual) != usuario.Senha)
{
ModelState.AddModelError("SenhaAtual", "Senha incorreta");
return(View());
}
usuario.Senha = Hash.GerarHash(viewModel.NovaSenha);
//AlterarSenha pela nova senha
db.Entry(usuario).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
TempData["SenhaAlterada"] = "Senha alterada com sucesso";
return(RedirectToAction("Index", "Painel"));
}
public ActionResult AlterarSenha(AlterarSenhaViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(View());
}
var identity = User.Identity as ClaimsIdentity;
var claimsuser = identity.Claims.FirstOrDefault(c => c.Type == "Login");
Usuarios usuarios = db.Usuarios.FirstOrDefault(l => l.Login == claimsuser.Value);
if (usuarios.Senha != Hash.GerarHash(viewModel.SenhaAtual))
{
ModelState.AddModelError("SenhaAtual", "Senha incorreta");
TempData["MensagemErro"] = "Erro";
return(View());
}
usuarios.Senha = Hash.GerarHash(viewModel.NovaSenha);
db.Entry(usuarios).State = EntityState.Modified;
db.SaveChanges();
TempData["Mensagem"] = "Senha alterada com sucesso";
return(View());
}
public ActionResult AlterarSenha(AlterarSenhaViewModel viewmodel)
{
if (!ModelState.IsValid)
{
return(View());
}
//CAPTURA O USUARIO QUE ESTÁ LOGADO
var identity = User.Identity as ClaimsIdentity;
var login = identity.Claims.FirstOrDefault(c => c.Type == "Login").Value;
var usuario = db.usuarios.FirstOrDefault(u => u.Login == login);
if (Hash.GerarHash(viewmodel.SenhaAtual) != usuario.Senha)
{
ModelState.AddModelError("SenhaAtual", "Senha incorreta");
return(View());
}
usuario.Senha = Hash.GerarHash(viewmodel.NovaSenha);
db.Entry(usuario).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
TempData["Mensagem"] = "Senha alterada com sucesso.";
return(RedirectToAction("Index", "Painel"));
}
public ActionResult _AltSenha(string Id)
{
var u = UserManager.FindById(Id);
var userModel = new AlterarSenhaViewModel
{
Id = u.Id
};
//var ClienteViewModel = _clienteApp.GetById(id);
return(PartialView(userModel));
}
public JsonResult AlterarSenha(AlterarSenhaViewModel viewModel)
{
if (SecurityHelper.Authenticate(User.ToPessoa().Usuario.NomeDeUsuario, viewModel.Senha))
{
var requisicao = new AlterarSenhaRequisicao
{
CodigoDaPessoa = User.ToPessoa().Codigo,
NovaSenha = viewModel.NovaSenha
};
var resposta = _pessoaServicoDeAplicacao.AlterarSenha(requisicao);
return(Json(resposta));
}
return(Json(new { Sucesso = false }));
}
public ActionResult Index(AlterarSenhaViewModel model)
{
if (ModelState.IsValid)
{
var analista = _AnalistaRepository.GetByEmail(User.Identity.Name);
if (analista != null)
{
analista.Password = Hashing.HashPassword(model.NovaSenha);
_AnalistaRepository.Update(analista);
return(View("MudarSenha"));
}
}
return(View(model));
}
public async Task <IActionResult> AlterarSenha(AlterarSenhaViewModel model)
{
try
{
var user = await _userManager.FindByNameAsync(User.Identity.Name);
var senhaAtual = user.PasswordHash;
var result = await _signInManager.PasswordSignInAsync(user.Email,
model.SenhaAtual, user.EmailConfirmed, user.EmailConfirmed);
var novaSenha = model.NovaSenha;
if (result.Succeeded)
{
if (novaSenha == model.ConfirmarSenha)
{
var bite = Encoding.UTF8.GetBytes(novaSenha);
using (var hash = SHA256.Create())
{
var hashedInputBytes = hash.ComputeHash(bite);
var hashedInputStringBuilder = new StringBuilder(128);
string hexNumber = "";
foreach (var b in hashedInputBytes)
{
hexNumber += String.Format("{0:X2}", b);
}
string senhaa = hexNumber;
var senha = await _accountRepository.UpdateSenha(senhaa, user.Id);
}
ViewData["Messagen"] = "A senha foi alterada.";
return(View("alterarsenha", model));
}
else
{
ViewData["Messager"] = "A senha digitada é diferente da senha confirmada.";
return(View("alterarsenha", model));
}
}
else
{
ViewData["Message"] = "A senha é diferente da senha atual.";
return(View("alterarsenha", model));
}
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public async Task <ActionResult> AlterarSenha(AlterarSenhaViewModel request)
{
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
var result = await _userAppService.AlterarSenhaUser(request);
if (!result.isValid)
{
AddInRangeError(result.Errors);
}
return(CustomResponse(result.Result));
}
public async Task <IActionResult> AlterarSenha(AlterarSenhaViewModel alterarSenha)
{
try
{
var novaSenhaHash = Criptografia.GerarHash(alterarSenha.SenhaNova);
var antigaSenhaHash = Criptografia.GerarHash(alterarSenha.SenhaAntiga);
var result = await _usuarioService.AlterarSenha(alterarSenha.UsuarioId, antigaSenhaHash, novaSenhaHash);
return(Ok(result));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public async Task <ActionResult> AlterarSenha(AlterarSenhaViewModel model)
{
if (ModelState.IsValid)
{
await _userManager.RemovePasswordAsync(User.Identity.GetUserId());
await _userManager.AddPasswordAsync(User.Identity.GetUserId(), model.Senha);
TempData["Acao"] = "senha";
return(RedirectToAction("Index", "Home"));
}
return(View(model));
}
public async Task <ActionResult> AlterarSenha(AlterarSenhaViewModel viewModel)
{
if (ModelState.IsValid)
{
if (string.IsNullOrWhiteSpace(viewModel.SenhaNova))
{
ViewBag.Message = "Senha muito curta.";
return(View(viewModel));
}
else
if (!string.Equals(viewModel.SenhaNova, viewModel.SenhaNovaConfirmar, System.StringComparison.CurrentCultureIgnoreCase))
{
ViewBag.Message = "Senhas não batem.";
return(View(viewModel));
}
else
{
var pessoa = await _db.PESSOA.Where(pe => pe.EMAIL == viewModel.Email && pe.SENHA == viewModel.SenhaAntiga)
.FirstOrDefaultAsync();
if (pessoa == null)
{
ViewBag.Message = "Email ou senha incorretos.";
return(View(viewModel));
}
else
{
pessoa.SENHA = viewModel.SenhaNova
.ToUpper();
_db.Entry(pessoa).State = EntityState.Modified;
await _db.SaveChangesAsync();
return(RedirectToAction("Index", "Home"));
}
}
}
else
{
ViewBag.Message = "Preencha os campos corretamente.";
return(View(viewModel));
}
}
public ActionResult AlterarSenha(AlterarSenhaViewModel senha)
{
try
{
if (!ModelState.IsValid)
{
ViewBag.Erro = "Dados inválidos. Verifique!";
return(View());
}
//Obtêm as Claims do usuário logado
var identity = User.Identity as ClaimsIdentity;
//Pega o valor do Id do usuário
var id = identity.Claims.FirstOrDefault(x => x.Type == ClaimTypes.NameIdentifier).Value;
//Obtêm o valor de uma Claim nâo definida
var telefone = identity.Claims.FirstOrDefault(x => x.Type == "Telefone").Value;
//Cria uma instancia de UsuarioRepositorio
using (UsuarioRepositorio objRepoUsuario = new UsuarioRepositorio())
{
//Busca o usuário pelo seu Id
UsuarioDomain objUsuario = objRepoUsuario.BuscarPorId(new Guid(id));
//Verifico se a senha informada é igual a Atual
if (Hash.GerarHash(senha.SenhaAtual) != objUsuario.Senha)
{
//Senha inválida eu informo ao usuário
ModelState.AddModelError("SenhaAtual", "Senha incorreta");
return(View());
}
//Atribuimos o valor da nova senha ao objeto usuário
objUsuario.Senha = Hash.GerarHash(senha.NovaSenha);
//Alteramos o usuário no banco
objRepoUsuario.Alterar(objUsuario);
//Definimos a mensagem que irá aparecer na tela
TempData["Sucesso"] = "Senha Alterada";
//Retornamos ao Controller Usuário, Index
return(RedirectToAction("Index", "Usuario"));
}
}
catch (System.Exception ex)
{
ViewBag.Erro = "Ocorreu um erro " + ex.Message;
return(View());
}
}
public ActionResult AlterarSenha(AlterarSenhaViewModel senha)
{
try
{
if (!ModelState.IsValid)
{
ViewBag.Erro = "Ocorreu um erro. Verifique digite uma senha válida!";
return(View());
}
//obtem claims do usuario
var identity = User.Identity as ClaimsIdentity;
// pega valor do id do Usuario
var id = identity.Claims.FirstOrDefault(x => x.Type == ClaimTypes.NameIdentifier).Value;
// obtem o valor de uma clais não definica anteriormente em contaController
var telefomne = identity.Claims.FirstOrDefault(x => x.Type == "Telefone").Value;
using (UsuarioRepositorio objRepUsuario = new UsuarioRepositorio())
{
// verifica se a senha ionformada é igual a atual
UsuarioDomain objUsuario = objRepUsuario.BuscarPorId(new Guid(id));
if (Hash.GerarHash(senha.SenhaAtual) != objUsuario.Senha)
{
// senha invalida informo o usuario
ModelState.AddModelError("Senha Atual", "Senha incorreta");
return(View());
}
// atribue o valor da nova senha ao objeto usuario
objUsuario.Senha = Hash.GerarHash(senha.NovaSenha);
// altera o usuario no bando
objRepUsuario.Alterar(objUsuario);
// Defimos a mensagem que ira aparecer na tela
TempData["Sucesso"] = "Senha Altereda";
// retornamos ao controller Usuario , Index
return(RedirectToAction("Index", "Usuario"));
}
}
catch (Exception ex)
{
ViewBag.message = "Ocorreu um erro" + ex.Message;
return(View());
}
return(RedirectToAction("Index", "Usuario"));
}
public ActionResult AlterarSenha(AlterarSenhaViewModel model)
{
var user = UserManager.FindById(User.Identity.GetUserId <int>());
if (UserManager.CheckPassword(user, model.SenhaAtual))
{
var result = UserManager.ChangePassword(user.Id, model.SenhaAtual, model.Senha);
if (result.Succeeded)
{
TempData["Alerta"] = "Senha alterada com sucesso";
TempData["Classe"] = "green-alert";
return(RedirectToAction("Index"));
}
}
TempData["Alerta"] = "Algo deu errado";
TempData["Classe"] = "yellow-alert";
return(RedirectToAction("Index"));
}
public async Task <IActionResult> AlteraSenha(AlterarSenhaViewModel modelo)
{
if (ModelState.IsValid)
{
var usuario = await _userManager.GetUserAsync(User);
var resultadoTrocaSenha = await _userManager.ChangePasswordAsync(usuario, modelo.SenhaAtual, modelo.SenhaNova);
if (resultadoTrocaSenha.Succeeded)
{
return(RedirectToAction("DadosUsuario", "DadosDeCadastro"));
}
else
{
ModelState.AddModelError("", _localizador["Senha atual incorreta ou algo deu errado"]);
}
}
return(View(modelo));
}
public ActionResult AlterarSenha(AlterarSenhaViewModel senha)
{
try
{
if (!ModelState.IsValid)
{
ViewBag.Erro = "Dados inválidos. Verifique!";
}
// Obtêm as CLAIMS do usuário logado
var identity = User.Identity as ClaimsIdentity;
//Pega o valor do ID do usuário
var id = identity.Claims.FirstOrDefault(x => x.Type == ClaimTypes.NameIdentifier).Value;
var telefone = identity.Claims.FirstOrDefault(x => x.Type == "Telefone").Value;
// Cria uma instancia de UsuarioRepositorio
using (UsuarioRepositorio _repUsuario = new UsuarioRepositorio())
{
// Busca pelo o usuário pelo seu Id
UsuarioDomain usuarioDomain = _repUsuario.BuscarPorId(new Guid(id));
// Verifica se a senha informada é igual a senha atual
if (Hash.GerarHash(senha.SenhaAtual) != usuarioDomain.Senha)
{
ModelState.AddModelError("SenhaAtual", " Senha incorreta");
return(View());
}
usuarioDomain.Senha = Hash.GerarHash(senha.NovaSenha);
_repUsuario.Alterar(usuarioDomain);
TempData["Sucesso"] = " Senha alterada";
return(RedirectToAction("Index", "Usuario"));
}
}
catch (System.Exception ex)
{
ViewBag.Erro = " Ocorreu um erro" + ex.Message;
return(View());
}
}
public ActionResult AlterarSenha(AlterarSenhaViewModel model)
{
try
{
if (ModelState.IsValid)
{
var d = new UsuarioDAL();
d.AtualizarSenha(model.SenhaConfirm, model.idUsuario);
ModelState.Clear();
TempData["Sucesso"] = true;
TempData["Resultado"] = "Senha atualizada com sucesso";
}
}
catch (Exception e)
{
TempData["Sucesso"] = false;
TempData["Resultado"] = "Erro: " + e.Message;
}
return(View());
}
public ActionResult AlterarSenha(AlterarSenhaViewModel model)
{
try
{
if (ModelState.IsValid)
{
var d = new UsuarioDAL();
d.AtualizarSenha(model.SenhaConfirm, model.IdUsuario);
TempData["Sucesso"] = true;
TempData["Mensagem"] = "Senha atualizada com sucesso";
return(RedirectToAction("Consulta", "Usuario"));
}
}
catch (Exception e)
{
TempData["Sucesso"] = false;
TempData["Mensagem"] = "Erro: " + e.Message;
}
return(View());
}
public ActionResult AlterarSenha([NotNull] AlterarSenhaViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(View());
}
var identity = User.Identity as ClaimsIdentity;
var login = identity.Claims.SingleOrDefault(c => c.Type == "Login").Value;
var usuario = db.Usuarios.Single(u => u.Login == login);
if (Hash.Generate(viewModel.SenhaAtual) != usuario.Senha)
{
ModelState.AddModelError(nameof(AlterarSenhaViewModel.SenhaAtual), "Senha incorreta");
return(View());
}
usuario.Senha = Hash.Generate(viewModel.NovaSenha);
db.SaveChanges();
return(RedirectToAction("Index", "Admin"));
}
