public ActionResult AlterarSenha(RedefinirSenhaViewModel model)
{
try
{
if (ModelState.IsValid)
{
UsuarioPersistence up = new UsuarioPersistence();
Usuario u = up.ObterPorId(model.Login);
u.Senha = Criptografia.EncriptarSenha(model.Senha);
up.Atualizar(u);
ViewBag.Mensagem = u.Nome;
//destrói o tícket de acesso do usuário..
FormsAuthentication.SignOut();
//apaga a sessão do usuário..
Session.Remove("Usuario");
return(View("MensagemRedefinirSenha"));
}
}
catch (Exception e)
{
ViewBag.Mensagem = e.Message.ToString();
}
return(View("RedefinirSenha"));
}
public async Task <IActionResult> RedefinirSenhaAsync(RedefinirSenhaViewModel modelo)
{
if (ModelState.IsValid)
{
var usuario = await _userManager.FindByEmailAsync(modelo.Email);
if (usuario == null)
{
return(RedirectToAction("RedefinirSenhaConfirmado"));
}
var token = Encoding.UTF8.GetString(WebEncoders.Base64UrlDecode(modelo.Token));
var resultado = await _userManager.ResetPasswordAsync(usuario, token, modelo.Senha);
if (resultado.Succeeded)
{
return(RedirectToAction("RedefinirSenhaConfirmado"));
}
foreach (var error in resultado.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
return(View(modelo));
}
public async Task <IActionResult> RedefinirSenhaAsync([FromBody] RedefinirSenhaViewModel model, string token)
{
var command = new DefinirNovaSenhaPorTokenCommand(token, model.Email, model.Senha, model.ConfirmaSenha);
var result = await _mediator.Send(command);
return(this.VerificarErros(_notifications, result));
}
public IActionResult RedefinirSenha(string token = null)
{
if (token == null)
{
return(View("Error"));
}
var modelo = new RedefinirSenhaViewModel();
modelo.Token = token;
return(View(modelo));
}
public async Task <IActionResult> Alterar([FromBody] RedefinirSenhaViewModel model)
{
if (ModelState.IsValid)
{
var result = await usuarioService.RedefinirSenhaAsync(model);
if (result.Success)
{
return(Ok(result));
}
return(BadRequest());
}
return(BadRequest());
}
public async Task <RespostaViewModel> RedefinirSenhaAsync(RedefinirSenhaViewModel model)
{
var usuario = await userManager.FindByEmailAsync(model.Email);
if (usuario == null)
{
return(new RespostaViewModel
{
Mensagem = "Usuário não encontrado",
Objeto = null,
Success = false
});
}
if (model.ConfirmarSenha != model.NovaSenha)
{
return(new RespostaViewModel
{
Mensagem = "A combinação de senhas não estão corretas.",
Objeto = null,
Success = false
});
}
var decodedToken = WebEncoders.Base64UrlDecode(model.Token);
string normalToken = Encoding.UTF8.GetString(decodedToken);
var result = await userManager.ResetPasswordAsync(usuario, normalToken, model.NovaSenha);
if (result.Succeeded)
{
return(new RespostaViewModel
{
Mensagem = "Senha alterada com sucesso!",
Objeto = null,
Success = true
});
}
return(new RespostaViewModel
{
Mensagem = "Não foi possível alterar a senha.",
Objeto = null,
Success = false
});
}
public async Task <JsonResult> RedefinirSenha(RedefinirSenhaViewModel model)
{
var result = new { Succeeded = false, errors = new List <String>(), data = "" };
if (!ModelState.IsValid)
{
result = new { Succeeded = false, errors = new List <String> {
"Dados do formulário preenchidos incorretamente"
}, data = "" };
}
else
{
var user = await UserManager.FindByNameAsync(model.Email);
if (user == null)
{
// Don't reveal that the user does not exist
result = new { Succeeded = true, errors = new List <String>(), data = "" };
}
var resultReset = await UserManager.ResetPasswordAsync(user.Id, model.Code, model.Senha);
if (resultReset.Succeeded)
{
result = new { Succeeded = true, errors = new List <String>(), data = "" };
}
else
{
result = new { Succeeded = false, errors = new List <String> {
resultReset.Errors.FirstOrDefault().ToString()
}, data = "" };
AddErrors(resultReset);
}
}
return(Json(result, "application/json", JsonRequestBehavior.AllowGet));
}
public ActionResult AcessarSistema(LoginViewModel loginModel)
{
try
{
if (ModelState.IsValid)
{
UsuarioPersistence up = new UsuarioPersistence();
Usuario u = new Usuario();
u = up.ObterLoginSenha(loginModel.Login,
Criptografia.EncriptarSenha(loginModel.Senha));
if (u != null)
{
if (u.Status.Equals("I"))
{
throw new Exception("Usuário Inativado." + "\n" + "Procure o Administrador do Sistema");
}
if (loginModel.Senha.ToUpper().Equals("ABC123"))
{
RedefinirSenhaViewModel model = new RedefinirSenhaViewModel();
model.Login = u.IdUsuario;
model.Nome = u.Nome;
//não usei o RedirectToAction, porque:
//1-carrega na URL da página os valores do parâmetro da model
//2-faz a validação dos campos obrigatórios ao inicializar a página
//return RedirectToAction("RedefinirSenha", model);
//Navegar pela view, oculta os parâmetros da model..
return(View("RedefinirSenha", model));
}
//criando o tícket para dar acesso a aplicação..
FormsAuthenticationTicket ticket =
new FormsAuthenticationTicket(u.IdUsuario, false, 5);//cinco minutos de inatividade, retorna ao login..
//gravando o ticket em cookie do navegador..
HttpCookie cookie =
new HttpCookie(FormsAuthentication.FormsCookieName,
FormsAuthentication.Encrypt(ticket));
//Gravando o cookie no navegador..
Response.Cookies.Add(cookie);
//gravando o objeto Usuario, seus perfis e menus em sessão..
Session.Add("Usuario", u);
//gravando os itens de menu..
// Session.Add("Menu", u.Perfil.Menus.Where(m=>m.IdMenu.Equals(null)).ToList());
return(RedirectToAction("Index", "Index",
new { area = "AreaIndex" }));
}
ViewBag.Mensagem = "Usuário/Senha Inválido";
}
}
catch (Exception ex)
{
ViewBag.Mensagem = "Erro: " + ex.Message.ToString();
}
return(View("Login"));
}
public ActionResult RedefinirSenha(RedefinirSenhaViewModel model)
{
return(View(model));
}