public static IEnumerable <ResponseUsuarioCargo> ListarUsuariosPorCargo(RequestDTOUsuarioPorCargo request)
{
var resultado = new List <ResponseUsuarioCargo>();
using (var ctx = new SeguridadEntities())
{
var query = ctx.SelectAllUsuarios();
foreach (var item in query)
{
foreach (var codCargo in request.CodigosCargo)
{
if (item.Cargo == codCargo)
{
resultado.Add(new ResponseUsuarioCargo
{
CodigoUsuario = item.CodigoUsuario,
IdUsuario = item.IdUsuario,
NombresCompletos = string.Format("{0} {1} {2}",
item.Nombres, item.ApellidoPaterno, item.ApellidoMaterno),
CorreoUsuario = item.Correo
});
}
}
}
}
return(resultado);
}
public static ResponseInfoBasicaUsuarioDTO GetInfoBasicaUsuarios(RequestInfoBasicaUsuarioDTO request)
{
var response = new ResponseInfoBasicaUsuarioDTO();
using (var ctx = new SeguridadEntities())
{
var query = ReturnInfoUsuario(ctx).Where(u => u.IdUsuario == request.CodigoUsuario);
response.InfoBasica = query.FirstOrDefault();
response.Resultado.Success = (response.InfoBasica != null);
}
return(response);
}
public static bool CerrarSesion(RequestInfoUsuario request)
{
using (var context = new SeguridadEntities())
{
var perfilUsuario = (from perf in context.PerfilUsuario
where perf.IdPerfilUsuario == request.IdPerfilUsuario
select perf).SingleOrDefault();
if (perfilUsuario != null)
{
perfilUsuario.Logueado = false;
}
var result = context.SaveChanges();
return(result > 0);
}
}
private static IQueryable <ResponseInfoUsuarios> ReturnInfoUsuario(SeguridadEntities contexto)
{
var query = from u in contexto.Usuarios
join c in contexto.Claves on u.IdUsuario equals c.IdUsuario into gp
from userexterno in gp.DefaultIfEmpty()
join cargo in contexto.Cargo on u.IdCargo equals cargo.IdCargo
where userexterno.Ultimo == true
select new ResponseInfoUsuarios
{
IdUsuario = u.IdUsuario,
CodigoCargo = cargo.CodigoCargo,
Cargo = cargo.Descripcion,
CodigoUsuario = u.CodigoUsuario,
Correo = u.Correo,
Tipo = u.Tipo,
DNI = u.DNI,
NombresCompletos = u.Nombres + " " + u.ApellidoPaterno + " " + u.ApellidoMaterno,
Dominio = u.Dominio,
PreguntaSecreta = (userexterno == null) ? string.Empty : userexterno.Pregunta,
};
return(query);
}
public static IEnumerable <ResponseInfoUsuarios> ListarUsuarios(RequestListarUsuario request)
{
using (var contexto = new SeguridadEntities())
{
var resultado = new List <ResponseInfoUsuarios>();
var query = contexto.SelectAllUsuarios();
foreach (var item in query)
{
resultado.Add(new ResponseInfoUsuarios
{
IdUsuario = item.IdUsuario,
CodigoUsuario = item.CodigoUsuario,
DNI = item.DNI,
NombresCompletos = string.Format("{0} {1} {2}", item.Nombres, item.ApellidoPaterno, item.ApellidoMaterno),
Correo = item.Correo,
CodigoCargo = item.Cargo,
Cargo = item.Cargo
});
}
return(resultado);
}
}
/// <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 ResponseUsuarioInsert InsertUsuario(RequestDTOUsuarioInsert request)
{
ResponseUsuarioInsert result = new ResponseUsuarioInsert();
var perfil = ErickOrlando.Seguridad.Negocio.Editables.PerfilUsuario.NewPerfilUsuario();
var usuario = Usuario.NewUsuario();
try
{
if (String.IsNullOrEmpty(request.Codigo))
{
return(result);
}
string IdAplicacion = string.Empty;
string IdEmpresa = string.Empty;
string IdEmpresaPertenencia = string.Empty;
string IdRol = string.Empty;
string IdCargo = string.Empty;
using (var ctx = new SeguridadEntities())
{
// Buscamos el ID de la Aplicacion.
IdAplicacion = (from app in ctx.Aplicaciones
where app.Acronimo == request.Acronimo
select app.IdAplicacion).SingleOrDefault();
if (string.IsNullOrEmpty(IdAplicacion))
{
throw new ApplicationException(string.Format("La Aplicación {0} no existe!", request.Acronimo));
}
// Buscamos el ID de la Empresa.
IdEmpresa = (from emp in ctx.Empresas
where emp.RUC == request.RUCEmpresa
select emp.IdEmpresa).SingleOrDefault();
if (string.IsNullOrEmpty(IdEmpresa))
{
throw new ApplicationException(string.Format("La Empresa con el RUC {0} no existe!", request.RUCEmpresa));
}
if (request.RUCEmpresa != request.RUCEmpresaPertenencia)
{
// Buscamos el ID de la Empresa Pertenencia.
IdEmpresaPertenencia = (from emp in ctx.Empresas
where emp.RUC == request.RUCEmpresaPertenencia
select emp.IdEmpresa).SingleOrDefault();
if (string.IsNullOrEmpty(IdEmpresaPertenencia))
{
throw new ApplicationException(string.Format("La Empresa con el RUC {0} no existe!", request.RUCEmpresaPertenencia));
}
}
else
{
IdEmpresaPertenencia = IdEmpresa;
}
// Buscamos el ID del Rol.
IdRol = (from roles in ctx.Roles
where roles.IdAplicacion == IdAplicacion &&
roles.NombreRol == request.Rol
select roles.IdRol).SingleOrDefault();
if (string.IsNullOrEmpty(IdRol))
{
throw new ApplicationException(string.Format("No se encuentra el Rol {0}", request.Rol));
}
// Buscamos el ID del Cargo.
IdCargo = (from cargo in ctx.Cargo
where cargo.Descripcion == request.Cargo
select cargo.IdCargo).SingleOrDefault();
if (string.IsNullOrEmpty(IdCargo))
{
throw new ApplicationException(string.Format("No se encuentra el cargo {0}", request.Cargo));
}
ctx.Database.Connection.Close();
}
//Creacion de nuevo usuario
usuario.IdEmpresa = IdEmpresa;
usuario.IdEmpresaPertenencia = IdEmpresaPertenencia;
usuario.IdCargo = IdCargo;
usuario.Nombres = request.Nombres;
usuario.Alias = request.Alias;
usuario.Dominio = request.Dominio;
usuario.ApellidoMaterno = request.ApellidoMaterno;
usuario.ApellidoPaterno = request.ApellidoPaterno;
usuario.Codigo = request.Codigo;
usuario.Correo = request.Correo;
usuario.DNI = request.DNI;
usuario.Estado = true;
usuario.NotificarConCorreo = request.NotificacionConCorreo;
usuario.Tipo = request.Tipo;
usuario = usuario.Save();
//Recuperando usuario creado
var usuarioCreado = usuario;
//Estableciendo variables de entorno
Csla.ApplicationContext.GlobalContext["Placa"] = Environment.MachineName;
Csla.ApplicationContext.GlobalContext["Usuario"] = Environment.UserName;
//Creacion de perfil
perfil.IdAplicacion = IdAplicacion;
perfil.IdUsuario = usuarioCreado.Id;
perfil.Usuario = usuarioCreado.Nombres;
perfil.Aplicacion = IdAplicacion;
perfil.Caduca = request.Caduca;
perfil.VigenciaInicio = DateTime.Now;
perfil.VigenciaFin = DateTime.Now.AddYears(1);
//Asignando rol
var rolPerfil = perfil.RolesPerfiles.AddNew();
rolPerfil.IdRol = IdRol;
rolPerfil.IdAplicacion = IdAplicacion;
//Agregando permisos
rolPerfil.AgregarPermisos();
//Estableciendo recursos
var recursosList = RecursosInfoList.GetRecursosInfoList();
if (request.ListaRecursos != null)
{
foreach (var recurso in request.ListaRecursos)
{
string recursoact = recurso.Substring(0, recurso.IndexOf(":")).Trim();
string[] recursodetalle = recurso.Substring(recurso.IndexOf(":") + 1).Trim().Split(',');
foreach (var itemrecurso in recursosList.Where(x => x.Descripcion == recursoact))
{
var recursodetalles = from p in itemrecurso.Detalles
where recursodetalle.Contains(p.Descripcion)
select p;
foreach (var itemrecursodetalle in recursodetalles)
{
var recursoitem = perfil.Recursos.AddNew();
recursoitem.Conceder = true;
recursoitem.IdRecursoDetalle = itemrecursodetalle.ID;
perfil.Recursos.Add(recursoitem);
}
}
}
}
perfil.Save();
string Clave = string.Empty;
if (usuario.Tipo == "E")
{
//Creacion de contraseña
if (String.IsNullOrEmpty(request.Clave))
{
Clave = GenerarClaveAleatoria();
}
else
{
var crypto = new SimpleInteroperableEncryption();
Clave = crypto.Decrypt(request.Clave);
}
//Hay que intentar el Login para identificar si se debe crear la contraseña.
try
{
Csla.ApplicationContext.GlobalContext["Acronimo"] = request.Acronimo;
GRPrincipal.Load(usuario.Codigo, usuario.Dominio);
//GRPrincipal.Login(usuario.Codigo, GRCrypto.Encriptar( "clave"));
}
catch (DataPortalException ex)
{
if (ex.BusinessException.GetType() == typeof(UsuarioNoActivoException) ||
ex.BusinessException.GetType() == typeof(UsuarioSinClaveException))
{
var activacion = ActivarUsuario.GetActivarUsuario(new FiltroUsuarios
{
Usuario = usuario.Codigo,
Dominio = usuario.Dominio
});
activacion.NombreUsuario = request.Codigo;
activacion.PreguntaSecreta = request.PreguntaSecreta;
activacion.RespuestaSecreta = request.RespuestaSecreta;
activacion.ClaveSecreta = Clave;
activacion.ConfirmarClave = Clave;
try
{
activacion.Save();
}
catch (ValidationException)
{
throw new InvalidOperationException(activacion.BrokenRulesCollection.ToString());
}
}
}
}
result.IdUsuario = usuarioCreado.Id;
result.Clave = (string.IsNullOrEmpty(request.Clave)) ? Clave : string.Empty;
result.Codigo = request.Codigo;
result.Alias = request.Alias;
result.Resultado.Success = true;
result.Resultado.Message = string.Empty;
}
catch (ValidationException)
{
var msg1 = usuario.BrokenRulesCollection.ToString();
var msg2 = perfil.BrokenRulesCollection.ToString();
if (string.IsNullOrEmpty(msg1))
{
result.Resultado.Message = msg2;
}
else if (string.IsNullOrEmpty(msg2))
{
result.Resultado.Message = msg1;
}
else
{
result.Resultado.Message = string.Format("{0} {1}", msg1, msg2);
}
}
catch (DataPortalException ex)
{
result.Resultado.Message = ex.BusinessException.Message;
if (ex.BusinessException.InnerException != null)
{
result.Resultado.Messages.Add(new Result {
Message = ex.BusinessException.InnerException.Message
});
}
}
catch (Exception ex)
{
var msg = ex.Message;
if (ex.InnerException != null)
{
msg = ex.InnerException.Message;
}
result.Resultado.Message = msg;
}
return(result);
}
public static ResponseInfoUsuarioDTO GetInfoUsuario(RequestInfoUsuario request)
{
ResponseInfoUsuarioDTO result = new ResponseInfoUsuarioDTO();
if (String.IsNullOrEmpty(request.IdPerfilUsuario))
{
return(result);
}
using (var contexto = new SeguridadEntities())
{
var perfilNegocio = PerfilUsuarioInfoList.GetPerfilUsuarioInfoList(
new FiltroCriteria
{
NombreCampo = "IdPerfilUsuario",
ValorBusqueda = request.IdPerfilUsuario
}).FirstOrDefault();
var dominios = ErickOrlando.Seguridad.Entidades.DominioInfoList.GetDominioInfoList();
foreach (var dominio in dominios)
{
if (dominio.NombreLargo == perfilNegocio.Dominio)
{
perfilNegocio.Dominio = dominio.NombreCorto;
}
}
#region Informacion Basica
result.IdUsuario = perfilNegocio.IdUsuario;
result.CodigoUsuario = string.Format(@"{0}\{1}",
perfilNegocio.Dominio, perfilNegocio.CodigoUsuario);
result.NombresCompletos = perfilNegocio.NombresCompletos;
result.Dominio = perfilNegocio.Dominio;
result.Correo = perfilNegocio.Correo;
result.CodigoCargo = perfilNegocio.CodigoCargo;
result.Cargo = perfilNegocio.Cargo;
result.Alias = perfilNegocio.Alias;
result.TipoUsuario = perfilNegocio.TipoUsuario;
#endregion
#region Roles del PerfilUsuario
result.Roles = new List <ResponseRoles>();
foreach (var rolPerfil in perfilNegocio.Roles)
{
result.Roles.Add(new ResponseRoles
{
IdRol = rolPerfil.IdRol,
Codigo = rolPerfil.CodigoRol,
Descripcion = rolPerfil.NombreRol
});
}
#endregion
#region OpcionesUI
result.OpcionesUI = ListarOpciones(perfilNegocio,
result.Roles.Select(r => r.IdRol).ToList()).ToList();
#endregion
#region Recursos
result.RecursosAdicionales = new List <ResponseRecursoAdicional>();
foreach (var recurso in perfilNegocio.Recursos)
{
if (recurso.Conceder)
{
result.RecursosAdicionales.Add(new ResponseRecursoAdicional
{
Codigo = recurso.Codigo,
Descripcion = recurso.Descripcion
});
}
}
#endregion
}
return(result);
}
