public void Test5()
        {
            String esperado  = "Error de caracteres, solo se pueden ingresar letras minusculas y espacios";
            String resultado = Codificar.Codificador(cadena5);

            Assert.AreEqual(esperado, resultado);
        }
        public void Test4()
        {
            String esperado  = "4433555 555666096667775553";
            String resultado = Codificar.Codificador(cadena4);

            Assert.AreEqual(esperado, resultado);
        }
        public void Test3()
        {
            String esperado  = "333666 666022 2777";
            String resultado = Codificar.Codificador(cadena3);

            Assert.AreEqual(esperado, resultado);
        }
        public void Test1()
        {
            String esperado  = "44 444";
            String resultado = Codificar.Codificador(cadena1);

            Assert.AreEqual(esperado, resultado);
        }
Esempio n. 5
0
        public async Task <IActionResult> Login(Login login, string returnUrl = null)
        {
            if (!ModelState.IsValid)
            {
                return(RedirectToAction(nameof(LoginController.Index)));
            }

            var response = await apiServicio.ObtenerElementoAsync1 <Response>(login,
                                                                              new Uri(WebApp.BaseAddressSeguridad),
                                                                              "/api/Adscpassws/Login");



            if (!response.IsSuccess)
            {
                return(RedirectToAction(nameof(LoginController.Index), new { mensaje = response.Message }));
            }

            var usuario = JsonConvert.DeserializeObject <Adscpassw>(response.Resultado.ToString());

            var codificar = new Codificar
            {
                Entrada = Convert.ToString(DateTime.Now),
            };

            Guid guidUsuario;

            guidUsuario = Guid.NewGuid();

            var permisoUsuario = new PermisoUsuario
            {
                Usuario = usuario.AdpsLogin,
                Token   = Convert.ToString(guidUsuario),
            };



            var salvarToken = await apiServicio.InsertarAsync <Response>(permisoUsuario, new Uri(WebApp.BaseAddressSeguridad), "/api/Adscpassws/SalvarToken");


            var claims = new[]
            {
                new Claim(ClaimTypes.Name, usuario.AdpsLogin),
                new Claim(ClaimTypes.SerialNumber, Convert.ToString(guidUsuario))
            };



            var principal = new ClaimsPrincipal(new ClaimsIdentity(claims, CookieAuthenticationDefaults.AuthenticationScheme));

            await HttpContext.Authentication.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme, principal);

            if (string.IsNullOrEmpty(returnUrl))
            {
                return(RedirectToAction(nameof(HomesController.Index), "Homes"));
            }

            return(LocalRedirect(returnUrl));
        }
        public void Test2()
        {
            String esperado = "999337777";

            String resultado = Codificar.Codificador(cadena2);

            Assert.AreEqual(esperado, resultado);
        }
Esempio n. 7
0
        public async Task <Response> PostAdscpassw([FromBody] Adscpassw adscpassw)
        {
            try
            {
                if (!ModelState.IsValid)
                {
                    return(new Response
                    {
                        IsSuccess = false,
                        Message = Mensaje.ModeloInvalido
                    });
                }

                var respuesta = Existe(adscpassw);
                if (!respuesta.IsSuccess)
                {
                    adscpassw.AdpsFechaCambio           = DateTime.Now;
                    adscpassw.AdpsFechaVencimiento      = DateTime.Now.AddMonths(3);
                    adscpassw.AdpsIntentos              = 0;
                    adscpassw.AdpsPasswCg               = adscpassw.AdpsLogin;
                    adscpassw.AdpsPreguntaRecuperacion  = Mensaje.UsuarioSinConfirmar;
                    adscpassw.AdpsRespuestaRecuperacion = Mensaje.UsuarioSinConfirmar;
                    adscpassw.AdpsPassword              = Codificar.SHA512(adscpassw.AdpsLogin);
                    db.Adscpassw.Add(adscpassw);
                    await db.SaveChangesAsync();

                    return(new Response
                    {
                        IsSuccess = true,
                        Message = Mensaje.Satisfactorio
                    });
                }

                return(new Response
                {
                    IsSuccess = false,
                    Message = Mensaje.ExisteRegistro
                });
            }
            catch (Exception ex)
            {
                await GuardarLogService.SaveLogEntry(new LogEntryTranfer
                {
                    ApplicationName      = Convert.ToString(Aplicacion.SwSeguridad),
                    ExceptionTrace       = ex,
                    Message              = Mensaje.Excepcion,
                    LogCategoryParametre = Convert.ToString(LogCategoryParameter.Critical),
                    LogLevelShortName    = Convert.ToString(LogLevelParameter.ERR),
                    UserName             = "",
                });

                return(new Response
                {
                    IsSuccess = false,
                    Message = Mensaje.Error,
                });
            }
        }
        public Codificar SHA512([FromBody] Codificar codificar)
        {
            var bytes = System.Text.Encoding.UTF8.GetBytes(codificar.Entrada);

            using (var hash = System.Security.Cryptography.SHA512.Create())
            {
                var hashedInputBytes = hash.ComputeHash(bytes);

                // Convert to text
                // StringBuilder Capacity is 128, because 512 bits / 8 bits in byte * 2 symbols for byte
                var hashedInputStringBuilder = new System.Text.StringBuilder(256);
                foreach (var b in hashedInputBytes)
                {
                    hashedInputStringBuilder.Append(b.ToString("X2"));
                }
                var resultado = new Codificar
                {
                    Entrada = codificar.Entrada,
                    Salida  = hashedInputStringBuilder.ToString(),
                };

                return(resultado);
            };
        }
        public async Task <IActionResult> Login(Login login, string returnUrl = null)
        {
            if (!ModelState.IsValid)
            {
                return(RedirectToAction(nameof(LoginController.Index)));
            }

            var response = await apiServicio.ObtenerElementoAsync1 <Response>(login,
                                                                              new Uri(WebApp.BaseAddressSeguridad),
                                                                              "api/Adscpassws/Login");

            UsuarioBloqueado(response, login);

            if (!response.IsSuccess)
            {
                return(this.Redireccionar("Login", "Index", $"{Mensaje.Aviso}|{response.Message}|{TiempoMensaje.Tiempo1}"));
            }

            // var usuario = JsonConvert.DeserializeObject<Adscpassw>(response.Resultado.ToString());

            var codificar = new Codificar
            {
                Entrada = Convert.ToString(DateTime.Now),
            };

            Guid guidUsuario;

            guidUsuario = Guid.NewGuid();

            var permisoUsuario = new PermisoUsuario
            {
                Usuario = login.Usuario,
                Token   = Convert.ToString(guidUsuario)
            };
            var salvarToken = await apiServicio.InsertarAsync <Response>(permisoUsuario, new Uri(WebApp.BaseAddressSeguridad), "api/Adscpassws/SalvarToken");

            var dependenciaDatosViewModel = await apiServicio.ObtenerElementoAsync1 <DependenciaDatosViewModel>(new IdFiltrosViewModel { NombreUsuario = login.Usuario }, new Uri(WebApp.BaseAddressTH), "api/Dependencias/ObtenerDependenciaDatosViewModelPorUsuarioActual");

            var empleado = await apiServicio.ObtenerElementoAsync1 <Empleado>(login.Usuario, new Uri(WebApp.BaseAddressTH), "api/Empleados/EmpleadoSegunNombreUsuario");

            var listadoAdscmiems = (await apiServicio.Listar <Adscmiem>(new Uri(WebApp.BaseAddressSeguridad), "api/Adscmiems/ListarAdscmiem")).Where(c => c.AdmiEmpleado == login.Usuario);

            var claims = new List <Claim>
            {
                new Claim(ClaimTypes.Name, login.Usuario),
                new Claim(ClaimTypes.SerialNumber, Convert.ToString(guidUsuario))
            };

            if (dependenciaDatosViewModel != null)
            {
                if (dependenciaDatosViewModel.IdSucursal > 0)
                {
                    claims.Add(new Claim("IdSucursal", dependenciaDatosViewModel.IdSucursal.ToString()));
                }

                if (!String.IsNullOrEmpty(dependenciaDatosViewModel.NombreSucursal))
                {
                    claims.Add(new Claim("NombreSucursal", dependenciaDatosViewModel.NombreSucursal));
                }

                if (dependenciaDatosViewModel.IdDependencia > 0)
                {
                    claims.Add(new Claim("IdDependencia", dependenciaDatosViewModel.IdDependencia.ToString()));
                }

                if (!String.IsNullOrEmpty(dependenciaDatosViewModel.NombreDependencia))
                {
                    claims.Add(new Claim("NombreDependencia", dependenciaDatosViewModel.NombreDependencia));
                }
            }

            if (empleado != null)
            {
                if (empleado.IdEmpleado > 0)
                {
                    claims.Add(new Claim("IdEmpleado", empleado.IdEmpleado.ToString()));
                }

                if (empleado.Persona != null)
                {
                    claims.Add(new Claim("NombreEmpleado", $"{empleado.Persona.Nombres} {empleado.Persona.Apellidos}"));
                }
            }

            foreach (var item in listadoAdscmiems)
            {
                claims.Add(new Claim("ADMI_Grupo", item.AdmiGrupo));
            }

            var principal = new ClaimsPrincipal(new ClaimsIdentity(claims, "Cookies"));
            await HttpContext.Authentication.SignInAsync("Cookies", principal, new Microsoft.AspNetCore.Http.Authentication.AuthenticationProperties {
                IsPersistent = true
            });

            if (string.IsNullOrEmpty(returnUrl))
            {
                return(this.Redireccionar("Homes", "Menu", $"{Mensaje.Informacion}|{login.Usuario}:{Mensaje.Bienvenido}|{TiempoMensaje.Tiempo1}"));
            }

            return(LocalRedirect(returnUrl));
        }