Exemplo n.º 1
0
        private void LoginRemoto()
        {
            using (var proxy = new ProxySeguridad())
            {
                var cryptocon = new SimpleInteroperableEncryption();

                var respuesta = proxy.Login(new RequestLogin
                {
                    AcronimoAplicacion = ConfigurationManager.AppSettings["AcronimoAplicacion"],
                    CodigoUsuario      = txtUser.Text,
                    Clave   = cryptocon.Encrypt(txtPass.Text),
                    Dominio = cboDominio.EditValue.ToString(),
                });

                if (!respuesta.Resultado.Success)
                {
                    throw new SecurityException(respuesta.Resultado.Message);
                }

                InfoUsuario.Initialize();
                InfoUsuario.Instancia.IdPerfilUsuario = respuesta.IdPerfilUsuario;

                var response = proxy.GetInfoUsuario(new RequestInfoUsuario
                {
                    IdPerfilUsuario = InfoUsuario.Instancia.IdPerfilUsuario
                });

                InfoUsuario.Instancia.NombresCompletos   = response.NombresCompletos;
                InfoUsuario.Instancia.CorreoUsuario      = response.Correo;
                InfoUsuario.Instancia.Dominio            = response.Dominio;
                InfoUsuario.Instancia.FechaUltimoIngreso = DateTime.Today;
            }
        }
Exemplo n.º 2
0
        public bool CambiarContrasenia(RequestCambioClave request)
        {
            bool done = false;

            SimpleInteroperableEncryption crypter = new SimpleInteroperableEncryption(WebConfigReader.SemillaEncriptacionPublica);

            //ENCRIPTAMOS LAS CONTRASEÑAS
            request.ClaveAntigua         = crypter.Encrypt(request.ClaveAntigua);
            request.ClaveNueva           = crypter.Encrypt(request.ClaveNueva);
            request.ClaveNuevaConfirmada = crypter.Encrypt(request.ClaveNuevaConfirmada);

            request.Dominio         = WebConfigReader.DominioAplicacion;
            request.Acronimo        = WebConfigReader.AcronimoAplicacion;
            request.TipoCambioClave = TipoCambioClave.Ui;

            ResponseCambioClave response = (new SeguridadProxyRest()).CambiarClaveWeb(request);

            if (response.Result.Satisfactorio == false)
            {
                throw new Exception(response.Result.Mensaje);
            }

            done = true;

            return(done);
        }
Exemplo n.º 3
0
        public bool ResetarContrasenia(RequestCambioClave request)
        {
            bool done = false;

            SimpleInteroperableEncryption crypter = new SimpleInteroperableEncryption(WebConfigReader.SemillaEncriptacionPublica);

            string contraseniaGenerada = Helper.GenerarContrasenia();

            request.ClaveAntigua = request.ClaveNuevaConfirmada = request.ClaveNueva = crypter.Encrypt(contraseniaGenerada);

            request.Dominio         = WebConfigReader.DominioAplicacion;
            request.Acronimo        = WebConfigReader.AcronimoAplicacion;
            request.TipoCambioClave = TipoCambioClave.Sys;

            ResponseCambioClave response = (new SeguridadProxyRest()).CambiarClaveWeb(request);

            if (response.Result.Satisfactorio == false)
            {
                throw new Exception(response.Result.Mensaje);
            }

            this.NotificarCambioConstraseniaMSC(response.CodigoUsuario, response.Correo, response.Nombres, contraseniaGenerada);

            done = true;

            return(done);
        }
Exemplo n.º 4
0
        public bool CambiarConstraseniaMSC(RequestCambioClave request)
        {
            bool done = false;

            Result result = this.ValidacionCambiarConstraseniaMSC(request);

            if (result.Satisfactorio == false)
            {
                throw new Exception(result.Mensaje);
            }

            SimpleInteroperableEncryption crypter = new SimpleInteroperableEncryption(WebConfigReader.SemillaEncriptacionPublica);

            string contraseniaGenerada = string.Empty;

            if (request.TipoCambioClave == TipoCambioClave.Sys)
            {
                contraseniaGenerada  = Helper.GenerarContrasenia();
                request.ClaveAntigua = request.ClaveNuevaConfirmada = request.ClaveNueva = crypter.Encrypt(contraseniaGenerada);
            }
            else
            {
                //ENCRIPTAMOS LAS CONTRASEÑAS
                request.ClaveAntigua         = crypter.Encrypt(request.ClaveAntigua);
                request.ClaveNueva           = crypter.Encrypt(request.ClaveNueva);
                request.ClaveNuevaConfirmada = crypter.Encrypt(request.ClaveNuevaConfirmada);
            }
            request.Dominio  = WebConfigReader.DominioAplicacion;
            request.Acronimo = WebConfigReader.AcronimoAplicacion;


            ResponseCambioClave response = (new SeguridadProxyRest()).CambiarClaveWeb(request);

            if (response.Result.Satisfactorio == false)
            {
                throw new Exception(response.Result.Mensaje);
            }

            //ENVIAMOS EL CORREO
            if (request.TipoCambioClave == TipoCambioClave.Sys)
            {
                this.NotificarCambioConstraseniaMSC(response.CodigoUsuario, response.Correo, response.Nombres, contraseniaGenerada);
            }

            done = true;

            return(done);
        }
Exemplo n.º 5
0
        private void btnEncriptar_Click(object sender, EventArgs e)
        {
            try
            {
                var crypto = new SimpleInteroperableEncryption();

                var resultado = crypto.Encrypt(txtClave.Text);

                Clipboard.SetText(resultado);
                lblResultado.Text = string.Format("Resultado: {0}", resultado);
                MessageBox.Show("Texto copiado al portapapeles", Text, MessageBoxButtons.OK, MessageBoxIcon.Information);
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }
Exemplo n.º 6
0
        //public GenerarClaveUsuarioResponseDTO ResetearContrasenia(GenerarClaveUsuarioRequestDTO request)
        //{
        //    GenerarClaveUsuarioResponseDTO response = new GenerarClaveUsuarioResponseDTO();
        //    ResponseCambioClaveDTO responseProxy = new ResponseCambioClaveDTO();

        //    SimpleInteroperableEncryption crypter = new SimpleInteroperableEncryption(WebConfigReader.Encriptacion.SemillaEncriptacionPublica);
        //    RequestCambioClaveDTO requestDTO = new RequestCambioClaveDTO();

        //    string contraseniaGenerada = HelperSeguridad.GenerarContrasenia();
        //    requestDTO.ClaveAntigua = requestDTO.ClaveNuevaConfirmada = requestDTO.ClaveNueva = crypter.Encrypt(contraseniaGenerada);

        //    requestDTO.Dominio = request.DominioAplicacion;
        //    requestDTO.Acronimo = request.AcronimoAplicacion;
        //    requestDTO.TipoCambioClave = TipoCambioClave.Sys;
        //    requestDTO.CodigoUsuario = request.Usuario.Trim();

        //    responseProxy = (new SeguridadProxy()).CambiarClaveWeb(requestDTO);

        //    int codigoError = 0;

        //    if (responseProxy.Result.Satisfactorio == false)
        //        if (int.TryParse(responseProxy.Result.CodigoError, out codigoError) && codigoError < 0)
        //        {
        //            throw new ResultException { Result = responseProxy.Result };
        //        }
        //        else if (!int.TryParse(responseProxy.Result.CodigoError, out codigoError) && codigoError == 0)
        //        {
        //            throw new ResultException { Result = responseProxy.Result };
        //        }
        //        else
        //        {
        //            throw new Exception(responseProxy.Result.Mensaje);
        //        }

        //    this.NotificarCambioConstraseniaMSC(responseProxy.CodigoUsuario, responseProxy.Correo, responseProxy.Nombres, contraseniaGenerada);

        //    return response;
        //}


        //public void NotificarCambioConstraseniaMSC(string CodigoUsuario, string Correo, string Nombres, string contraseniaGenerada)
        //{
        //    RequestNotificacionDTO requestNotificacion = new RequestNotificacionDTO();

        //    #region VALIDAMOS EL CORREO DEL CLIENTE

        //    if (string.IsNullOrEmpty(Correo))
        //        return;

        //    #endregion


        //    requestNotificacion.CodigoLinea = "HLL";
        //    requestNotificacion.CorreosPara.Add(Correo);
        //    requestNotificacion.CorreoDe = WebConfigReader.Mailer.From;
        //    requestNotificacion.CodigoNotificacion = (int)TipoNotificacion.NotificacionRecordarClave;



        //    requestNotificacion.CuerpoValores = new Dictionary<string, string>() {
        //                                               { "{Cliente}", Nombres },
        //                                               { "{Usuario}", CodigoUsuario },
        //                                               { "{Clave}", contraseniaGenerada },
        //                                               { "{urlpagina}", WebConfigReader.Aplicacion.UrlAplicacion.Trim() }
        //                                            };

        //    Task task = new Task((Action<Object>)EnviarCorreo, requestNotificacion);
        //    task.Start();
        //}

        //public void EnviarCorreo(Object requestNotificacion)
        //{
        //    NotificacionBL notificacionBL = new NotificacionBL();
        //    notificacionBL.requestNotificationDTO = requestNotificacion as RequestNotificacionDTO;
        //    notificacionBL.EnviarNotificacionAsync();
        //}


        public CambiarClaveUsuarioResponseDTO CambiarClaveUsuario(CambiarClaveUsuarioRequestDTO request)
        {
            CambiarClaveUsuarioResponseDTO response      = new CambiarClaveUsuarioResponseDTO();
            ResponseCambioClaveDTO         responseProxy = new ResponseCambioClaveDTO();

            RequestCambioClaveDTO         requestDTO = new RequestCambioClaveDTO();
            SimpleInteroperableEncryption crypter    = new SimpleInteroperableEncryption(WebConfigReader.Encriptacion.SemillaEncriptacionPublica);

            //string contraseniaGenerada = HelperSeguridad.GenerarContrasenia();

            //ENCRIPTAMOS LAS CONTRASEÑAS
            requestDTO.Dominio         = request.DominioAplicacion;
            requestDTO.Acronimo        = request.AcronimoAplicacion;
            requestDTO.TipoCambioClave = TipoCambioClave.Ui;
            requestDTO.ClaveAntigua    = request.ClaveAnterior;                                //crypter.Encrypt(request.ClaveAnterior);
            requestDTO.ClaveNueva      = requestDTO.ClaveNuevaConfirmada = request.ClaveNueva; //crypter.Encrypt(request.ClaveNueva);
            requestDTO.CodigoUsuario   = request.Usuario.Trim();

            responseProxy = (new SeguridadProxy()).CambiarClaveWeb(requestDTO);

            int codigoError = 0;

            if (responseProxy.Result.Satisfactorio == false)
            {
                if (int.TryParse(responseProxy.Result.CodigoError, out codigoError) && codigoError < 0)
                {
                    throw new ResultException {
                              Result = responseProxy.Result
                    };
                }
                else if (!int.TryParse(responseProxy.Result.CodigoError, out codigoError) && codigoError == 0)
                {
                    throw new ResultException {
                              Result = responseProxy.Result
                    };
                }
                else
                {
                    throw new Exception(responseProxy.Result.Mensaje);
                }
            }

            return(response);
        }
        public byte[] cargarDatos(string dato)
        {
            var crypt          = new SimpleInteroperableEncryption(ConfigurationManager.AppSettings["MetodoEncriptacion"].ToString());
            var datoEncriptado = crypt.Encrypt(dato);

            QRCoder.QRCodeGenerator qRCodeGenerator = new QRCoder.QRCodeGenerator();
            QRCoder.QRCodeData      qRCodeData      = qRCodeGenerator.CreateQrCode(datoEncriptado, QRCoder.QRCodeGenerator.ECCLevel.Q);
            QRCoder.QRCode          qRCode          = new QRCoder.QRCode(qRCodeData);
            //transformamos en bits
            Bitmap bmp = qRCode.GetGraphic(7);

            using (MemoryStream ms = new MemoryStream())
            {
                //importante para generar el qr
                bmp.Save(ms, ImageFormat.Bmp);
                //row.CodigoQR = ms.ToArray();

                return(ms.ToArray());
            }
        }
Exemplo n.º 8
0
        public ResponseLoginUsuario Login(RequestLogin request)
        {
            var crypt   = new SimpleInteroperableEncryption(WebConfigReader.SemillaEncriptacionPublica);
            var dominio = WebConfigReader.DominioAplicacion;

            request.AcronimoAplicacion = WebConfigReader.AcronimoAplicacion;
            request.Clave = crypt.Encrypt(request.Clave);
            //request.Dominio = dominio.ToUpper();

            if (request.CodigoUsuario.IndexOf("\\") > -1)
            {
                request.Dominio       = request.CodigoUsuario.Split('\\')[0].ToUpper();
                request.CodigoUsuario = request.CodigoUsuario.Split('\\')[1];
            }
            else
            {
                request.Dominio = dominio.ToUpper();
            }

            return((new SeguridadProxyRest()).Login(request));
        }
Exemplo n.º 9
0
        public ResponseCambiarClaveUsuario CambiarClaveUsuario(RequestCambiarClaveUsuarioViewModel request)
        {
            var response = new ResponseCambiarClaveUsuario();

            try
            {
                SimpleInteroperableEncryption crypter = new SimpleInteroperableEncryption(WebConfigReader.SemillaEncriptacionPublica);
                var requestAgente = new RequestCambiarClaveUsuario();
                requestAgente.Usuario            = request.Usuario;
                requestAgente.ClaveAnterior      = crypter.Encrypt(request.ClaveAnterior);
                requestAgente.ClaveNueva         = crypter.Encrypt(request.ClaveNueva);
                requestAgente.AcronimoAplicacion = WebConfigReader.AcronimoAplicacion;
                requestAgente.DominioAplicacion  = WebConfigReader.DominioAplicacion;
                response = new TransmisionesProxyrest().CambiarClaveUsuario(requestAgente);
            }
            catch (Exception ex)
            {
                response.Result = new Result {
                    Satisfactorio = false
                };
                ManejadorExcepciones.PublicarExcepcion(ex, PoliticaExcepcion.AgenteServicios);
            }
            return(response);
        }
        public async void EnvioCorreo(TipoCorreo tipoCorreo)
        {
            var Ruta   = string.Empty;
            var Cadena = new String[] {
                string.Format("{0} {1} {2}", Nombres, ApellidoPaterno, ApellidoMaterno),
                Codigo,
                DateTime.Today.ToString("D"),
                DateTime.Today.AddDays(90).ToString("D")
            };

            var Contenido = new ContenidoMail();

            switch (tipoCorreo)
            {
            case TipoCorreo.UsuarioNuevoExterno:
                Ruta             = "ErickOrlando.Seguridad.Negocio.Editables.Usuarios.PlantillaCorreo.htm";
                Contenido.Asunto = string.Format(Properties.Resources.msgAsuntoActivacion, this.Codigo);
                break;

            case TipoCorreo.UsuarioNuevoInterno:
                Ruta             = "ErickOrlando.Seguridad.Negocio.Editables.Usuarios.PlantillaCorreoUsuarioAD.htm";
                Contenido.Asunto = string.Format(Properties.Resources.msgAsuntoActivacion, this.Codigo);
                Cadena           = new String[]
                {
                    Nombres,
                    Codigo,
                    Dominio
                };
                break;

            case TipoCorreo.CambioClave:
                Ruta             = "ErickOrlando.Seguridad.Negocio.Editables.Usuarios.PlantillaContrasena.htm";
                Contenido.Asunto = string.Format(Properties.Resources.msgAsuntoRestablecimiento, this.Codigo);
                break;
            }

            try
            {
                TextReader texto = new StreamReader(Assembly.GetExecutingAssembly().GetManifestResourceStream(Ruta));

                #region Configuracion del Correo
                var crypto = new SimpleInteroperableEncryption();

                Contenido.RemitenteMail   = ConfigurationManager.AppSettings["RemitenteEmail"];
                Contenido.RemitenteNombre = ConfigurationManager.AppSettings["RemitenteNombre"];
                Contenido.Servidor        = ConfigurationManager.AppSettings["SMTPServer"];
                Contenido.Puerto          = int.Parse(ConfigurationManager.AppSettings["PuertoSMTP"]);
                Contenido.Credenciales    = new System.Net.NetworkCredential(
                    crypto.Decrypt(ConfigurationManager.AppSettings["CredencialUser"]),
                    crypto.Decrypt(ConfigurationManager.AppSettings["CredencialPass"]));
                Contenido.UsarSSL       = true;
                Contenido.CuerpoMensaje = texto.ReadToEnd();
                Contenido.ListaDestinatarios.Add(Correo);
                Contenido.ArrayValores = Cadena;
                Contenido.Html         = true;
                texto.Close();
                #endregion

                #region Contenido del Correo
                using (MailMessage mail = new MailMessage())
                {
                    mail.From = new MailAddress(Contenido.RemitenteMail, Contenido.RemitenteNombre);
                    foreach (var Destinatario in Contenido.ListaDestinatarios)
                    {
                        mail.To.Add(Destinatario);
                    }
                    foreach (var Destinatario in Contenido.ListaDestinatariosCC)
                    {
                        mail.CC.Add(Destinatario);
                    }
                    foreach (var Destinatario in Contenido.ListaDestinatariosBCC)
                    {
                        mail.Bcc.Add(Destinatario);
                    }
                    var CuerpoHTML = new StringBuilder();

                    if (Contenido.ArrayValores.Length > 0)
                    {
                        CuerpoHTML.AppendFormat(Contenido.CuerpoMensaje, Contenido.ArrayValores);
                    }
                    else
                    {
                        CuerpoHTML.Append(Contenido.CuerpoMensaje);
                    }

                    CuerpoHTML.AppendLine();
                    CuerpoHTML.AppendLine();
                    CuerpoHTML.AppendLine();

                    CuerpoHTML.Append(Contenido.Html ? Contenido.PieDeCorreoHTML : Contenido.PieDeCorreo);

                    mail.Subject    = Contenido.Asunto;
                    mail.Body       = CuerpoHTML.ToString();
                    mail.IsBodyHtml = Contenido.Html;

                    //Limpiamos el StringBuilder
                    CuerpoHTML.Length = 0;

                    var smtp = new SmtpClient();
                    smtp.Host = Contenido.Servidor;
                    if (Contenido.Puerto.HasValue)
                    {
                        smtp.Port = Contenido.Puerto.Value;
                    }

                    if (Contenido.Credenciales != null)
                    {
                        smtp.Credentials = Contenido.Credenciales;
                    }
                    else
                    {
                        smtp.UseDefaultCredentials = true;
                    }

                    if (Contenido.Servidor.ToLower() == "localhost" || Contenido.Servidor == "127.0.0.1")
                    {
                        smtp.DeliveryMethod = SmtpDeliveryMethod.PickupDirectoryFromIis;
                    }

                    if (!string.IsNullOrEmpty(Contenido.DirectorioRecojoIIS))
                    {
                        smtp.PickupDirectoryLocation = Contenido.DirectorioRecojoIIS;
                    }

                    smtp.EnableSsl = Contenido.UsarSSL;

                    //await smtp.SendMailAsync(mail);
                    await smtp.SendMailAsync(mail);
                }
                #endregion
            }
            catch (SmtpException ex)
            {
                var msg = string.Format("{0}\n{1}",
                                        ex.Message, ex.InnerException == null ? string.Empty : ex.InnerException.Message);
                System.Diagnostics.Trace.WriteLine(msg);
            }
        }
Exemplo n.º 11
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);
        }
Exemplo n.º 12
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);
        }
Exemplo n.º 13
0
        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);
        }