public ResponseLoginUsuario Login(RequestLogin request, string token)
{
ResponseLoginUsuario response = new ResponseLoginUsuario();
SeguridadProxy proxy = new SeguridadProxy();
try
{
string TokenLogin = ConfigurationManager.AppSettings["TokenLogin"].ToString();
if (token != null && token.Equals(TokenLogin))
{
response = proxy.Login(request);
}
else
{
response.ResultadoLogin = false;
response.MensajeError = "No está autoizado para utilizar este servicio";
}
}
catch (Exception ex)
{
response.ResultadoLogin = false;
response.MensajeError = ex.Message.ToString();
}
return(response);
}
public ResponseLoginUsuario Login(RequestLogin request)
{
var response = new ResponseLoginUsuario();
try
{
response = SeguridadBL.Login(request);
}
catch (Exception ex)
{
response.Resultado.Message = ex.Message;
response.Resultado.ErrCode = ex.GetHashCode().ToString();
if (ex.InnerException != null)
{
response.Resultado.Messages.Add(new Result {
Message = ex.InnerException.Message
});
}
}
return(response);
}
public async Task <BaseResponse> AutenticarUsuario(RequestLoginUsuario request)
{
try
{
_logger.LogInformation("Inicio autenticação do usuário");
var senhaEncrypt = HelpExtensions.Encrypt(request.Senha);
var usuario = await _usuarioRepository.ObterUsuario(request.Email, senhaEncrypt);
var tokenHandler = new JwtSecurityTokenHandler();
var key = Encoding.ASCII.GetBytes(_configuration.GetValue <string>("Secret"));
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(new Claim[] {
new Claim(ClaimTypes.Name, usuario.Nome.ToString()),
new Claim(ClaimTypes.Email, usuario.Email.ToString())
}),
Expires = DateTime.UtcNow.AddHours(2),
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
};
var token = tokenHandler.CreateToken(tokenDescriptor) as JwtSecurityToken;
ResponseLoginUsuario response = new ResponseLoginUsuario();
response.IdUsuario = usuario.Id;
response.Token = token.RawData;
_logger.LogInformation("Fim da autenticação do usuário");
return(await ObterStatusCode("Autenticação realizada com sucesso.", StatusCodes.Status200OK, response));
}
catch (Exception ex)
{
return(await ObterStatusCode("Erro ao autenticar o usuário", StatusCodes.Status400BadRequest, null, ex));
}
}
public ResponseLoginUsuario Login(RequestLogin request)
{
var response = new ResponseLoginUsuario();
try
{
response = SeguridadBL.Login(request);
}
catch (Exception ex)
{
response.Resultado.Message = ex.Message;
response.Resultado.ErrCode = ex.GetHashCode().ToString();
if (ex.InnerException != null)
response.Resultado.Messages.Add(new Result { Message = ex.InnerException.Message });
}
return response;
}
/// <summary>
/// Cambia la contraseña de un usuario externo, si el campo es vacio se crea una contraseña, de lo contrario registra al constraseña enviada.
/// </summary>
/// <param name="request">Constraseña a registrar</param>
/// <returns>Contraseña generada</returns>
public static ResponseCambioClave CambiarClaveWeb(RequestCambioClave request)
{
ResponseCambioClave response = new ResponseCambioClave();
var publicCrypter = new SimpleInteroperableEncryption();
var info = GetInfoBasicaUsuariosByCodigo(new RequestInfoBasicaUsuarioDTO
{
CodigoUsuario = request.CodigoUsuario,
Dominio = request.Dominio
});
if (!info.Resultado.Success)
{
throw new InvalidOperationException("El usuario no existe!");
}
if (info.InfoBasica.Tipo != "E")
{
throw new InvalidOperationException("Sólo los usuarios externos pueden cambiar su contraseña");
}
//SI SE HA SOLICITADO CONTRASEÑA, SE VALIDA LA CONTRASEÑA ANTIGUA
if (request.TipoCambioClave == TipoCambioClave.Ui)
{
// Comprobamos si el campo de Respuesta Secreta se encuentra lleno para validar
// que el usuario se olvidó se contraseña y posteriormente hacer el cambio.
if (string.IsNullOrEmpty(request.RespuestaSecreta))
{
ResponseLoginUsuario responseLogin = Login(new RequestLogin
{
CodigoUsuario = request.CodigoUsuario,
Clave = publicCrypter.Decrypt(request.ClaveAntigua),
Dominio = request.Dominio,
AcronimoAplicacion = request.Acronimo
});
if (!responseLogin.Resultado.Success)
{
throw new Exception("La contraseña es incorrecta.");
}
}
else
{
// Comprobamos que la respuesta a la pregunta Secreta sea válida.
using (var ctx = new SeguridadEntities())
{
var clave = (from clav in ctx.Claves
where clav.IdUsuario == info.InfoBasica.IdUsuario &&
clav.Ultimo
select new { RespuestaSecreta = clav.Respuesta }).FirstOrDefault();
if (clave != null)
{
if (clave.RespuestaSecreta != GRCrypto.Encriptar(request.RespuestaSecreta))
{
throw new SecurityException("La respuesta secreta no coincide!");
}
}
}
}
}
// En caso sea un reseteo de clave
if (request.TipoCambioClave == TipoCambioClave.Sys)
{
request.ClaveAntigua = request.ClaveNuevaConfirmada = request.ClaveNueva = publicCrypter.Decrypt(request.ClaveNueva);
}
else
{
//DESENCRIPTAR LA CONTRASENIA
request.ClaveAntigua = publicCrypter.Decrypt(request.ClaveAntigua);
request.ClaveNueva = publicCrypter.Decrypt(request.ClaveNueva);
request.ClaveNuevaConfirmada = publicCrypter.Decrypt(request.ClaveNuevaConfirmada);
}
Result result = ValidacionCambiarClaveWeb(request);
if (result.Success == false)
{
throw new Exception(result.Message);
}
bool primeraClave = false;
try
{
//Validamos si tiene Clave registrada.
GRPrincipal.Load(request.CodigoUsuario, request.Dominio);
}
catch (DataPortalException ex)
{
if (ex.BusinessException != null)
{
if (ex.BusinessException.GetType() == typeof(UsuarioSinClaveException))
{ //SI LA EXCEPCION ES USUARIOSINCLAVE SE LE CREA UNA CLAVE
ActivarUsuario activarUsuario = ActivarUsuario.GetActivarUsuario(new FiltroUsuarios
{
Usuario = request.CodigoUsuario, Dominio = request.Dominio
});
activarUsuario.PreguntaSecreta = activarUsuario.RespuestaSecreta = request.CodigoUsuario;
activarUsuario.ClaveSecreta = activarUsuario.ConfirmarClave = request.ClaveNueva;
activarUsuario.Save();
primeraClave = true;
}
}
}
if (!primeraClave)
{
var cambiarClave = CambiarClave.GetCambiarClave(new FiltroUsuarios
{
Usuario = request.CodigoUsuario, Dominio = request.Dominio
});
cambiarClave.ClaveNueva = cambiarClave.ConfirmarClave = request.ClaveNueva;
cambiarClave.RespuestaSecreta = string.IsNullOrEmpty(request.RespuestaSecreta)
? cambiarClave.SecretAnswer : request.RespuestaSecreta;
CambiarClave.ByPassClave = true;
cambiarClave.Save();
}
response.Correo = info.InfoBasica.Correo;
response.Nombres = info.InfoBasica.NombresCompletos;
response.CodigoUsuario = request.CodigoUsuario;
return(response);
}
public static ResponseLoginUsuario Login(RequestLogin request)
{
var response = new ResponseLoginUsuario();
try
{
if (string.IsNullOrEmpty(request.Clave) || string.IsNullOrEmpty(request.CodigoUsuario))
{
throw new InvalidOperationException("El usuario y clave son obligatorios.");
}
if (string.IsNullOrEmpty(request.AcronimoAplicacion))
{
throw new InvalidOperationException("El acrónimo es obligatorio.");
}
// Desencriptamos el mensaje recibido.
var cryptocon = new SimpleInteroperableEncryption();
request.Clave = cryptocon.Decrypt(request.Clave);
//Comprobamos que el Nombre de Usuario contiene un Dominio
var infoUser = new UserDomain {
Usuario = request.CodigoUsuario, Dominio = request.Dominio
};
//Guardamos en el GlobalContext el valor que se reciba del Acrónimo
Csla.ApplicationContext.GlobalContext["Acronimo"] = request.AcronimoAplicacion;
if (string.IsNullOrEmpty(request.Dominio))
{
throw new InvalidOperationException("El dominio es obligatorio.");
}
var result = false;
//Comprobamos primero el tipo de Usuario
if (GRPrincipal.Load(infoUser.Usuario, infoUser.Dominio))
{
InfoUsuario.Initialize();
if (InfoUsuario.Instancia.Tipo) // Si es interno
{
result = GRPrincipal.Login(infoUser.Usuario, request.Clave, request.Dominio);
}
else // Si es externo
{
result = GRPrincipal.Login(infoUser.Usuario, GRCrypto.Encriptar(request.Clave));
}
}
else
{
throw new InvalidOperationException("El usuario no está inscrito para este Sistema");
}
if (!result)
{
throw new SecurityException("El usuario o clave no son válidos!");
}
response.Resultado.Success = result;
response.IdPerfilUsuario = InfoUsuario.Instancia.IdPerfilUsuario;
}
catch (DataPortalException ex)
{
response.Resultado.Message = ex.BusinessException.Message;
}
catch (Exception ex)
{
var msg = ex.Message;
if (ex.InnerException != null)
{
msg = ex.InnerException.Message;
}
response.Resultado.Message = msg;
}
return(response);
}
public virtual ActionResult Login(string usuario, string password)
{
SeguridadBL seguridadBL = new SeguridadBL();
var hashPermisosBotones = new List <string>();
try
{
//ContentResult loginResponse = (ContentResult)(new SeguridadController()).Login(usuario, password);
//GR.Scriptor.Membership.Entidades.ResponseLoginUsuario responseLoginUsuario = Newtonsoft.Json.JsonConvert.DeserializeObject<GR.Scriptor.Membership.Entidades.ResponseLoginUsuario>(loginResponse.Content);
//OBTENEMOS EL LOGIN
ResponseLoginUsuario objLogin = seguridadBL.Login(new RequestLogin
{
Clave = password,
CodigoUsuario = usuario
});
if (objLogin == null)
{
throw new Exception("Servicio Login no disponible.");
}
if (objLogin.ResultadoLogin == false)
{
throw new Exception(objLogin.MensajeError);
}
(new ManejadorLog()).RegistrarEvento(MethodBase.GetCurrentMethod().Name, Newtonsoft.Json.JsonConvert.SerializeObject(objLogin));
//OBTENEMOS LOS DATOS DE SEGURIDAD DEL USUARIO
ResponseInfoUsuarioDTO objInfo = seguridadBL.GetInformacionUsuario(objLogin.IdPerfilUsuario);
(new ManejadorLog()).RegistrarEvento(MethodBase.GetCurrentMethod().Name, Newtonsoft.Json.JsonConvert.SerializeObject(objInfo));
objInfo.IdPerfilUsuario = objLogin.IdPerfilUsuario;
var tablaHash = new List <string>();
List <ResponseOpcionUI> menuOrdenado = new List <ResponseOpcionUI>();
seguridadBL.HacerTablaHash(objInfo.OpcionesUI, ref tablaHash, ref menuOrdenado, ref hashPermisosBotones);
Session["usuario"] = new ResponseUsuarioMscDTO()
{
Usuario = new UsuarioDTO()
{
IdUsuario = objInfo.IdUsuario,
IdPerfilUsuario = objLogin.IdPerfilUsuario,
CodigoCargo = objInfo.CodigoCargo,
CodigoUsuario = objInfo.CodigoUsuario,
Email = objInfo.Correo,
NombrePersona = objInfo.NombresCompletos.Split('(')[0],
NombreUsuario = objInfo.CodigoUsuario.Split('\\')[1],
Menu = menuOrdenado,
Recursos = objInfo.RecursosAdicionales,
Sedes = objInfo.Sedes,
//TipoReclamo = objInfo.TipoReclamo,
//Permisos = permisos,
Permisos = tablaHash,
RolDescripcion = objInfo.Roles[0].Descripcion,
esExterno = objInfo.TipoUsuario == "E" ? true : false,
TipoUsuario = objInfo.TipoUsuario,
Alias = objInfo.Alias,
PermisosBotones = hashPermisosBotones,
Roles = objInfo.Roles
},
};
FormsAuthentication.SetAuthCookie(objInfo.CodigoUsuario, false);
return(Json(new Result {
Satisfactorio = true
}, JsonRequestBehavior.AllowGet));
}
catch (Exception ex)
{
(new ManejadorLog()).RegistrarEvento(MethodBase.GetCurrentMethod().Name, ex.Message, ex.StackTrace);
return(Json(new Result {
Satisfactorio = false, Mensaje = ex.Message, Data = hashPermisosBotones
}, JsonRequestBehavior.AllowGet));
}
}
