public async Task <Response> CambiarContraseñaUsuariosExternos([FromBody] CambiarContrasenaViewModel cambiarContrasenaViewModel)
{
try
{
var salida = CodificarHelper.SHA512(new Codificar {
Entrada = cambiarContrasenaViewModel.ContrasenaActual
}).Salida;
var usuario = await db.Adscpassw.Where(x => x.AdpsLogin.ToUpper() == cambiarContrasenaViewModel.Usuario.ToUpper() && x.AdpsPasswPoint == salida).FirstOrDefaultAsync();
if (usuario == null)
{
return(new Response {
IsSuccess = false, Message = Mensaje.UsuariooContrasenaIncorrecto
});
}
if (usuario.AdpsTipoUso != Constantes.UsuarioInterno)
{
SincorizarContrasenaUsuarioExternos(cambiarContrasenaViewModel.Usuario, cambiarContrasenaViewModel.ConfirmacionContrasena);
return(new Response {
IsSuccess = true, Message = Mensaje.CambioContrasenaExito
});
}
return(new Response {
IsSuccess = false, Message = Mensaje.NoHabilitadoCambioContrasena
});
}
catch (Exception)
{
throw;
}
}
public ActionResult CambiarContrasena()
{
var model = new CambiarContrasenaViewModel();
model.Fill(CargarDatosContext(), Session.GetUsuarioId());
return(View(model));
}
public async Task <IActionResult> ActualizarContrasena(CambiarContrasenaViewModel cambioContrasena)
{
var cliente = await _service.GetByIdAsync(cambioContrasena.IdUsuario);
if (cliente == null)
{
ModelState.AddModelError("", "Usuario invalido");
return(View(nameof(CambiarContrasena), cambioContrasena));
}
if (cambioContrasena.NuevaContrasena.Trim() != cambioContrasena.ConfirmacionContrasena.Trim())
{
ModelState.AddModelError("", "Las contrasenas deben coincidir");
return(View(nameof(CambiarContrasena), cambioContrasena));
}
if (cambioContrasena.NuevaContrasena.Trim() == cliente.Contrasena)
{
ModelState.AddModelError("", "La nueva contrasena no puede ser igual a la anterior");
return(View(nameof(CambiarContrasena), cambioContrasena));
}
if (!ModelState.IsValid)
{
return(View(nameof(CambiarContrasena), cambioContrasena));
}
cliente.Contrasena = cambioContrasena.NuevaContrasena;
cliente.ExpiracionContrasena = DateTime.Now.AddDays(30).Date;
await _service.EditAsync(cliente);
return(RedirectToAction(nameof(Login)));
}
public async Task <IActionResult> CambiarContrasena(CambiarContrasenaViewModel cambiarContrasenaViewModel)
{
try
{
if (string.IsNullOrEmpty(cambiarContrasenaViewModel.ConfirmacionContrasena) || string.IsNullOrEmpty(cambiarContrasenaViewModel.ContrasenaActual) || string.IsNullOrEmpty(cambiarContrasenaViewModel.NuevaContrasena))
{
ModelState.AddModelError("", "Debe introducir todos los datos por favor...");
return(View());
}
if (cambiarContrasenaViewModel.NuevaContrasena != cambiarContrasenaViewModel.ConfirmacionContrasena)
{
ModelState.AddModelError("", "La contraseña nueva no coincide con la confirmación");
return(View());
}
var claim = HttpContext.User.Identities.Where(x => x.NameClaimType == ClaimTypes.Name).FirstOrDefault();
var token = claim.Claims.Where(c => c.Type == ClaimTypes.SerialNumber).FirstOrDefault().Value;
var NombreUsuario = claim.Claims.Where(c => c.Type == ClaimTypes.Name).FirstOrDefault().Value;
Response response = new entidades.Utils.Response();
cambiarContrasenaViewModel.Usuario = NombreUsuario;
response = await apiServicio.ObtenerElementoAsync1 <Response>(cambiarContrasenaViewModel,
new Uri(WebApp.BaseAddressSeguridad),
"api/Adscpassws/CambiarContrasenaUsuariosExternos");
if (response.IsSuccess)
{
var responseLog = new EntradaLog
{
ExceptionTrace = null,
LogCategoryParametre = Convert.ToString(LogCategoryParameter.Permission),
LogLevelShortName = Convert.ToString(LogLevelParameter.ADV),
ObjectPrevious = null,
ObjectNext = JsonConvert.SerializeObject(response.Resultado),
};
await apiServicio.SalvarLog <entidades.Utils.Response>(HttpContext, responseLog);
return(RedirectToActionPermanent("Menu", "Homes"));
}
ModelState.AddModelError("", response.Message);
return(View());
}
catch (Exception ex)
{
var responseLog = new EntradaLog
{
ExceptionTrace = ex.Message,
LogCategoryParametre = Convert.ToString(LogCategoryParameter.Critical),
LogLevelShortName = Convert.ToString(LogLevelParameter.ERR),
ObjectPrevious = null,
ObjectNext = null,
};
await apiServicio.SalvarLog <entidades.Utils.Response>(HttpContext, responseLog);
return(BadRequest());
}
}
public ActionResult ChangePassword()
{
int segundos_restantes;
string scc;
try
{
segundos_restantes = Int32.Parse(HttpContext.Session["STCP"].ToString());
}
catch
{
segundos_restantes = 1;
}
try
{
scc = HttpContext.Session["SCC"].ToString();
}
catch
{
scc = "false";
}
if (segundos_restantes == -1)
{
ViewBag.Mensaje = "Su contraseña ha caducado, por favor ingrese una nueva.";
}
else
{
ViewBag.Mensaje = "false";
}
if (scc == "true")
{
ViewBag.Mensaje = "La contraseña actual fue establecida por el administrador, por favor ingrese una nueva.";
}
else
{
ViewBag.Mensaje = "false";
}
IdentityPersonalizado ident = (IdentityPersonalizado)ControllerContext.HttpContext.User.Identity;
CambiarContrasenaViewModel model = new CambiarContrasenaViewModel();
model.original_password = ident.Password;
return(View(model));
}
public ActionResult CambiarContrasena(CambiarContrasenaViewModel model)
{
try
{
var usuario = context.Usuario.FirstOrDefault(x => x.UsuarioId == model.UsuarioId);
usuario.Password = model.ContrasenaNueva;
context.SaveChanges();
PostMessage(MessageType.Success);
}
catch (Exception ex)
{
PostMessage(MessageType.Error);
}
return(RedirectToAction("Index", "Home"));
}
public async Task <ActionResult> ResetContrasena(CambiarContrasenaViewModel model)
{
using (var context = new BodMantEntities())
{
var User = context.usuario.Find(model.IdUser);
string code = await UserManager.GeneratePasswordResetTokenAsync(User.IdAspnetUser);
var result = await UserManager.ResetPasswordAsync(User.IdAspnetUser, code, model.NewPassword);
return(Json(new MensajeRespuestaViewModel
{
Titulo = "Cambiar Contrasena",
Mensaje = result.Succeeded ? "Se cambio Satisfactoriamente" : "Error al cambiar la contrasena",
Estado = result.Succeeded
}, JsonRequestBehavior.AllowGet));
}
}
public ActionResult ChangePassword([Bind(Include = "original_password,password,new_password,repeat_password")] CambiarContrasenaViewModel cambio)
{
IdentityPersonalizado ident = (IdentityPersonalizado)ControllerContext.HttpContext.User.Identity;
if (ModelState.IsValid)
{
string newPass = SeguridadUtilidades.SHA256Encripta(cambio.new_password);
c_usuario c_usuario = db.c_usuario.Find(ident.Id_usuario);
h_password Pass = new h_password();
Pass.id_usuario = c_usuario.id_usuario;
Pass.password = newPass;
Pass.fe_actualizacion = DateTime.Now;
db.h_password.Add(Pass);
c_usuario.password = newPass;
c_usuario.id_estatus_usuario = 2;
c_usuario.fe_cambio_password = DateTime.Now;
db.SaveChanges();
HttpContext.Session["SCC"] = "false";
return(RedirectToAction("Success"));
}
string scc;
try
{
scc = HttpContext.Session["SCC"].ToString();
}
catch
{
scc = "false";
}
if (scc == "true")
{
ViewBag.Mensaje = "La contraseña actual fue establecida por el administrador, por favor ingrese una nueva.";
}
else
{
ViewBag.Mensaje = "false";
}
return(View());
}
public ActionResult CambiarContrasena(CambiarContrasenaViewModel model)
{
try
{
var usuario = context.Usuario.FirstOrDefault(x => x.UsuarioId == model.UsuarioId);
if (model.Password != usuario.Password)
{
PostMessage(MessageType.Warning, "Las contraseñas no coinciden.");
return(View(model));
}
usuario.Estado = ConstantHelpers.EstadoActivo;
usuario.Password = model.NewPassword;
context.SaveChanges();
return(Dashboard());
}
catch (Exception ex)
{
return(View(model));
}
}
public IActionResult CambiarContrasena(int id)
{
var cambioContrasena = new CambiarContrasenaViewModel
{
IdUsuario = id
};
/* --------------------------- para mongodb registro bitacora */
var bitacora = new BitacoraViewModel()
{
fecha = DateTime.Now,
Entidad = "Cliente",
Accion = "Cambio Contrasena",
Detalle = id.ToString()
};
_bitacoraService.Create(bitacora);
/* --------------------------- para mongodb registro bitacora */
return(View(cambioContrasena));
}
public async Task <IActionResult> CambiarContrasena(CambiarContrasenaViewModel model)
{
#region CambiarContrasena
try
{
var usuarioInfo = _httpContextAccessor.GetUsuarioInfoViewModel();
var user = await _repository.FirstOrDefault <ApplicationUser>(x => x.Id.Equals(usuarioInfo.Id));
var result = await _usuarioRepository.CambiarContrasena(user, model.ContrasenaActual, model.NuevaContrasena);
if (!result.Succeeded)
{
if (result.Errors.Any(x => x.Code.Equals("PasswordMismatch")))
{
throw new MessageAlertException(MessageAlertType.Warning, Mensajes.Usuarios_Msj19);
}
throw new MessageAlertException(MessageAlertType.Warning, Mensajes.USUARIOS_MSJ15);
}
ShowMessageSuccess(Mensajes.USUARIOS_MSJ14);
}
catch (MessageAlertException ex)
{
_logger.LogError(ex.Message);
GenerarAlerta(ex);
}
catch (Exception ex)
{
_logger.LogError(ex.Message);
ShowMessageException(ex.Message);
}
return(RedirectToAction(nameof(Perfil)));
#endregion
}
