예제 #1
0
        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);
        }
예제 #2
0
        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);
        }
예제 #3
0
        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);
            }
        }
예제 #4
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);
        }
예제 #5
0
        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);
            }
        }
예제 #6
0
        /// <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);
        }
예제 #7
0
        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);
        }
예제 #8
0
        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);
        }