Beispiel #1
0
        public async Task <Dictionary <string, object> > CambiarContrasena(RecuperaContrasenaDto recuperaContrasena)
        {
            httpStatusCode = HttpStatusCode.BadRequest;
            resultado      = Resultado.Error;
            mensaje        = string.Empty;

            if (!recuperaContrasena.IsNull())
            {
                // Buscar en parámetros generales el código de tipo de cambio que corresponde a activación de cuenta.
                ParamGenUsu paramGenUsu = await _repoWrapper.ParamGenUsu.GetParamGenUsuAsync();

                CambioRestringido cambioRestringido = await _repoWrapper.CambioRestringido.GetUltimoCambioCuentaAsync(recuperaContrasena.CodUsuario, paramGenUsu.CodRecupCuenta);

                if (!cambioRestringido.IsNull())
                {
                    if (!cambioRestringido.IntentoCambio.Any(x => x.IntenExitoso.IsStringTrue()))
                    {
                        Usuario usuario = cambioRestringido.CodUsuarioNavigation;

                        if (!usuario.IsNull())
                        {
                            if (usuario.UsuarActivo.IsStringTrue())
                            {
                                // Crear nuevo intento de cambio.
                                IntentoCambio intentoCambio = CreaIntentoCambio(cambioRestringido);

                                // Verificar el código de recuperación.
                                if (recuperaContrasena.CodRecuperacion.VerifyHashCode(usuario.ContrasSalt, usuario.CambioRestringido.FirstOrDefault().CodActivHash))
                                {
                                    IList <ContrasenaAnt> listaContrasenaAnt = await _repoWrapper.ContrasenaAnt.GetUltimasContrasenas(usuario.CodUsuario, (int)paramGenUsu.CantContrAntValid - 1);

                                    // Verificar que la nueva contraseña no coincida con ninguna de las n anteriores.
                                    if (VerificaContrasenasAnt(usuario, recuperaContrasena.Contrasena, listaContrasenaAnt, out ContrasenaAnt contrasenaAnt))
                                    {
                                        if (recuperaContrasena.Contrasena.BuildHashString(out byte[] contrhash, out byte[] contrsalt, out mensaje))
                                        {
                                            // Inicializar la contraseña con Hash y el Salt.
                                            usuario.ContrasHash = contrhash;
                                            usuario.ContrasSalt = contrsalt;

                                            cambioRestringido.ContrasenaAnt = contrasenaAnt;

                                            if (await InsertarIntentoCambio(cambioRestringido, intentoCambio))
                                            {
                                                httpStatusCode = HttpStatusCode.OK;
                                                resultado      = Resultado.Success;
                                                mensaje        = "Cuenta recuperada con éxito!";
                                            }
                                            else
                                            {
                                                httpStatusCode = HttpStatusCode.InternalServerError;
                                                mensaje        = "Inconsistencia actualizando datos de recuperación de contraseña.";
                                            }
                                        }
                                    }
                                    else
                                    {
                                        mensaje = string.Format("La nueva contraseña debe ser diferente a las últimas {0} contraseñas anteriores.", (int)paramGenUsu.CantContrAntValid);
                                    }
                                }
                                else
                                {
                                    intentoCambio.IntenExitoso = "N";
                                    int cantIntentos = cambioRestringido.IntentoCambio.Count + 1;

                                    if (await InsertarIntentoCambio(cambioRestringido, intentoCambio))
                                    {
                                        if (cantIntentos < paramGenUsu.CantIntentRecu) // Otro intento fallido.
                                        {
                                            mensaje = "El código de recuperación de contraseña no es válido.";
                                        }
                                        else // Llegó al límite de intentos de activación de la cuenta.
                                        {
                                            // Incicializar datos para la solicitud de recuperación de contraseña.
                                            CambioRestringido cambioRestringidoNuevo = CreaCambioRestringido(usuario, paramGenUsu.CodRecupCuenta, out string randomCode);

                                            _repoWrapper.CambioRestringido.Create(cambioRestringidoNuevo);

                                            if (await _repoWrapper.SaveAsync() > 0)
                                            {
                                                // Enviar correo para recuperar contraseña.
                                                EnviarCorreo(usuario, randomCode, 3);

                                                mensaje = "Ha excedido el número máximo de intentos de recuperación de contraseña. Favor revisar su correo e intentar con el nuevo código.";
                                            }
                                            else
                                            {
                                                httpStatusCode = HttpStatusCode.InternalServerError;
                                                mensaje        = "Inconsistencia salvando datos de recuperación de contraseña.";
                                            }
                                        }
                                    }
                                    else
                                    {
                                        httpStatusCode = HttpStatusCode.InternalServerError;
                                        mensaje        = "Inconsistencia actualizando datos de recuperación de contraseña.";
                                    }
                                }
                            }
                            else // Lógica para enviar correo de activar cuenta.
                            {
                                // Incicializar datos para la solicitud de activación de cuenta.
                                CambioRestringido cambioRestringidoNuevo = CreaCambioRestringido(usuario, paramGenUsu.CodActiCuenta, out string randomCode);

                                _repoWrapper.CambioRestringido.Create(cambioRestringidoNuevo);

                                if (await _repoWrapper.SaveAsync() > 0)
                                {
                                    // Enviar correo para activar cuenta.
                                    EnviarCorreo(usuario, randomCode, 2);

                                    ActivaCuentaDto activaCuenta = new ActivaCuentaDto()
                                    {
                                        CodUsuario = usuario.CodUsuario
                                    };

                                    _resultService.AddValue("ActivaCuentaDto", activaCuenta);

                                    httpStatusCode = HttpStatusCode.PreconditionRequired; // 428 - alert
                                    resultado      = Resultado.Warning;
                                    mensaje        = "Debe activar la cuenta antes de cambiar la contraseña. Revise su correo para obtener el código.";
                                }
                                else
                                {
                                    httpStatusCode = HttpStatusCode.InternalServerError;
                                    mensaje        = "Inconsistencia salvando datos de recuperación de contraseña.";
                                }
                            }
                        }
                        else
                        {
                            httpStatusCode = HttpStatusCode.NotFound;
                            mensaje        = "El usuario no existe.";
                        }
                    }
                    else
                    {
                        resultado = Resultado.Warning;
                        mensaje   = "La contraseña fue recuperada con anterioridad. Si olvidó su nueva contraseña debe repetir el proceso de recuperación de contraseña desde el inicio.";
                    }
                }
                else
                {
                    httpStatusCode = HttpStatusCode.NotFound;
                    mensaje        = "No existe solicitud de recuperación de cuenta pendiente.";
                }
            }
            else
            {
                mensaje = "Debe suministrar los datos para cambiar la contraseña.";
            }

            _resultService.AddValue("StatusCode", httpStatusCode);
            _resultService.AddValue(resultado, mensaje);

            return(_resultService.GetProperties());
        }
Beispiel #2
0
        public async Task <Dictionary <string, object> > RecuperarCuenta(UsuarioDto usuarioDto)
        {
            httpStatusCode = HttpStatusCode.BadRequest;
            resultado      = Resultado.Error;
            mensaje        = string.Empty;
            RecuperaContrasenaDto recuperaContrasena = default;

            if (!usuarioDto.IsNull())
            {
                if (_emailService.ValidEmail(usuarioDto.CorreoUsuar, _emailConfiguration.RegExp))
                {
                    //Usuario usuario = await _dbContext.Usuario.SingleOrDefaultAsync(x => x.CorreoUsuar.ToUpper() == usuarioDto.CorreoUsuar.ToUpper()).ConfigureAwait(true);
                    Usuario usuario = await _repoWrapper.Usuario.FindByEmailAsync(usuarioDto.CorreoUsuar);

                    if (!usuario.IsNull())
                    {
                        // Buscar en parámetros generales el código de tipo de cambio que corresponde a activación de cuenta.
                        ParamGenUsu paramGenUsu = await _repoWrapper.ParamGenUsu.GetParamGenUsuAsync();

                        if (usuario.UsuarActivo.IsStringTrue())
                        {
                            // Incicializar datos para la solicitud de recuperación de cuenta.
                            CambioRestringido cambioRestringidoNuevo = CreaCambioRestringido(usuario, paramGenUsu.CodRecupCuenta, out string randomCode);

                            // Añadir nueva solicitud de cambio.
                            _repoWrapper.CambioRestringido.Create(cambioRestringidoNuevo);

                            // Actualizar datos de usuario.
                            _repoWrapper.Usuario.Update(usuario);

                            if (await _repoWrapper.SaveAsync() > 0)
                            {
                                EnviarCorreo(usuario, randomCode, 3);

                                recuperaContrasena = new RecuperaContrasenaDto()
                                {
                                    CodUsuario = usuario.CodUsuario
                                };

                                httpStatusCode = HttpStatusCode.OK;
                                resultado      = Resultado.Success;
                                mensaje        = "Código de recuparación enviado. Favor revise su correo.";
                            }
                            else
                            {
                                httpStatusCode = HttpStatusCode.InternalServerError;
                                mensaje        = "Inconsistencia al salvar datos de usuario.";
                            }
                        }
                        else // Lógica para enviar correo de activar cuenta.
                        {
                            // Incicializar datos para la solicitud de activación de cuenta.
                            CambioRestringido cambioRestringidoNuevo = CreaCambioRestringido(usuario, paramGenUsu.CodActiCuenta, out string randomCode);

                            // Añadir nueva solicitud de cambio.
                            _repoWrapper.CambioRestringido.Create(cambioRestringidoNuevo);

                            // Actualizar datos de usuario.
                            _repoWrapper.Usuario.Update(usuario);

                            if (await _repoWrapper.SaveAsync() > 0)
                            {
                                // Enviar correo para activar cuenta.
                                EnviarCorreo(usuario, randomCode, 2);

                                ActivaCuentaDto activaCuenta = new ActivaCuentaDto()
                                {
                                    CodUsuario = usuario.CodUsuario
                                };

                                _resultService.AddValue("ActivaCuentaDto", activaCuenta);

                                httpStatusCode = HttpStatusCode.PreconditionRequired; // 428 - alert
                                resultado      = Resultado.Warning;
                                mensaje        = "Debe activar la cuenta antes de recuperar la contraseña. Revise su correo para obtener el código.";
                            }
                            else
                            {
                                httpStatusCode = HttpStatusCode.InternalServerError;
                                mensaje        = "Inconsistencia al salvar datos de usuario.";
                            }
                        }
                    }
                    else
                    {
                        mensaje = "La dirección de correo no está registrada.";
                    }
                }
                else
                {
                    mensaje = "La dirección de correo no es válida.";
                }
            }
            else
            {
                mensaje = "Debe suministrar los datos para la recuperación de la cuenta.";
            }

            _resultService.AddValue("StatusCode", httpStatusCode);
            _resultService.AddValue(resultado, mensaje);

            if (resultado == Resultado.Success)
            {
                _resultService.AddValue("RecuperaContrasenaDto", recuperaContrasena);
            }

            return(_resultService.GetProperties());
        }
Beispiel #3
0
        public async Task <Dictionary <string, object> > ActivarCuenta(ActivaCuentaDto activarCuenta)
        {
            httpStatusCode = HttpStatusCode.BadRequest;
            resultado      = Resultado.Error;
            mensaje        = string.Empty;

            if (!activarCuenta.IsNull())
            {
                // Buscar en parámetros generales el código de tipo de cambio que corresponde a activación de cuenta.
                ParamGenUsu paramGenUsu = await _repoWrapper.ParamGenUsu.GetParamGenUsuAsync();

                CambioRestringido cambioRestringido = await _repoWrapper.CambioRestringido.GetUltimoCambioCuentaAsync(activarCuenta.CodUsuario, paramGenUsu.CodActiCuenta);

                if (!cambioRestringido.IsNull())
                {
                    Usuario usuario = cambioRestringido.CodUsuarioNavigation;

                    if (!usuario.IsNull())
                    {
                        if (!usuario.UsuarActivo.IsStringTrue())
                        {
                            // Crear nuevo intento de cambio.
                            IntentoCambio intentoCambio = CreaIntentoCambio(cambioRestringido);

                            // Verificar el código de activación.
                            if (activarCuenta.CodActivacion.VerifyHashCode(usuario.ContrasSalt, usuario.CambioRestringido.FirstOrDefault().CodActivHash))
                            {
                                usuario.UsuarActivo = "S";

                                if (await InsertarIntentoCambio(cambioRestringido, intentoCambio))
                                {
                                    httpStatusCode = HttpStatusCode.OK;
                                    resultado      = Resultado.Success;
                                    mensaje        = "Cuenta activada con éxito!";
                                }
                                else
                                {
                                    httpStatusCode = HttpStatusCode.InternalServerError;
                                    mensaje        = "Inconsistencia actualizando datos de activación de cuenta.";
                                }
                            }
                            else
                            {
                                intentoCambio.IntenExitoso = "N";
                                int cantIntentos = cambioRestringido.IntentoCambio.Count + 1;

                                if (await InsertarIntentoCambio(cambioRestringido, intentoCambio))
                                {
                                    if (cantIntentos < paramGenUsu.CantIntentAct) // Otro intento fallido.
                                    {
                                        mensaje = "El código no es válido.";
                                    }
                                    else // Llegó al límite de intentos de activación de la cuenta.
                                    {
                                        // Incicializar datos para la solicitud de activación de cuenta.
                                        CambioRestringido cambioRestringidoNuevo = CreaCambioRestringido(usuario, paramGenUsu.CodActiCuenta, out string randomCode);

                                        _repoWrapper.CambioRestringido.Create(cambioRestringidoNuevo);

                                        if (await _repoWrapper.SaveAsync() > 0)
                                        {
                                            // Enviar correo para activar cuenta.
                                            EnviarCorreo(usuario, randomCode, 2);

                                            mensaje = "Ha excedido el número máximo de intentos de activación. Favor revisar su correo e intentar con el nuevo código.";
                                        }
                                        else
                                        {
                                            httpStatusCode = HttpStatusCode.InternalServerError;
                                            mensaje        = "Inconsistencia salvando datos de activación de cuenta.";
                                        }
                                    }
                                }
                                else
                                {
                                    httpStatusCode = HttpStatusCode.InternalServerError;
                                    mensaje        = "Inconsistencia actualizando datos de activación de cuenta.";
                                }
                            }
                        }
                        else
                        {
                            resultado = Resultado.Warning;
                            mensaje   = "La cuenta fue activada con anterioridad.";
                        }
                    }
                    else
                    {
                        httpStatusCode = HttpStatusCode.NotFound;
                        mensaje        = "El usuario no existe.";
                    }
                }
                else
                {
                    httpStatusCode = HttpStatusCode.NotFound;
                    mensaje        = "No existe solicitud de activación de cuenta pendiente.";
                }
            }
            else
            {
                mensaje = "Favor suministrar datos de activación de la cuenta.";
            }

            _resultService.AddValue("StatusCode", httpStatusCode);
            _resultService.AddValue(resultado, mensaje);

            return(_resultService.GetProperties());
        }
Beispiel #4
0
        public async Task <Dictionary <string, object> > Autenticarse(UsuarioDto usuarioDto)
        {
            httpStatusCode = HttpStatusCode.OK;
            resultado      = Resultado.Error;
            mensaje        = "";

            Usuario usuario = null;
            string  token   = string.Empty;

            if (!usuarioDto.IsNull())
            {
                // Verificar si existe el correo o número de celular
                if (!string.IsNullOrEmpty(usuarioDto.CorreoUsuar))
                {
                    usuario = await _repoWrapper.Usuario.FindByEmailAsync(usuarioDto.CorreoUsuar);
                }
                else
                {
                    if (!string.IsNullOrEmpty(usuarioDto.NumCelular))
                    {
                        usuario = await _repoWrapper.Usuario.FindByCellAsync(usuarioDto.NumCelular);
                    }
                    else
                    {
                        httpStatusCode = HttpStatusCode.BadRequest;
                        mensaje        = "Debe suministrar el correo o teléfono para la autenticación.";
                    }
                }
            }

            // Verificar si se trajeron datos del usuario.
            if (!usuario.IsNull())
            {
                string contrasena = usuarioDto.Contrasena ?? string.Empty;

                // Verificar que la contraseña es válida.
                if (contrasena.VerifyHashCode(usuario.ContrasSalt, usuario.ContrasHash))
                {
                    // Mapear datos de modelo al DTO.
                    usuarioDto = usuario.Map <UsuarioDto>();

                    token = usuarioDto.CodUsuario.BuildToken(usuarioDto.CorreoUsuar, _appSettings.JwtSecretKey, _appSettings.JwtExpireMinutes);

                    resultado = Resultado.Success;

                    if (!usuarioDto.UsuarActivo.IsStringTrue())
                    {
                        // Buscar en parámetros generales el código de tipo de cambio que corresponde a activación de cuenta.
                        ParamGenUsu paramGenUsu = await _repoWrapper.ParamGenUsu.GetParamGenUsuAsync();

                        // Incicializar datos para la solicitud de activación de cuenta.
                        CambioRestringido cambioRestringidoNuevo = CreaCambioRestringido(usuario, paramGenUsu.CodActiCuenta, out string randomCode);

                        _repoWrapper.CambioRestringido.Create(cambioRestringidoNuevo);

                        if (await _repoWrapper.SaveAsync() > 0)
                        {
                            // Enviar correo para activar cuenta.
                            EnviarCorreo(usuario, randomCode, 2);

                            ActivaCuentaDto activaCuenta = new ActivaCuentaDto()
                            {
                                CodUsuario = usuario.CodUsuario
                            };

                            _resultService.AddValue("ActivaCuentaDto", activaCuenta);

                            httpStatusCode = HttpStatusCode.PreconditionRequired; // 428 - alert
                            resultado      = Resultado.Warning;
                            mensaje        = "Debe activar la cuenta antes de entrar a la aplicación. Revise su correo para obtener el código.";
                        }
                        else
                        {
                            httpStatusCode = HttpStatusCode.InternalServerError;
                            mensaje        = "Inconsistencia salvando datos de activación de cuenta.";
                        }
                    }
                    else
                    {
                        // Validar si existe cambio de contraseña pendiente y anularlo.
                    }
                }
                else
                {
                    httpStatusCode = HttpStatusCode.BadRequest;
                    mensaje        = "Usuario o contraseña incorrecto.";
                }
            }
            else
            {
                httpStatusCode = HttpStatusCode.NotFound;
                mensaje        = "Usuario o contraseña incorrecto.";

                usuarioDto = null;
            }

            _resultService.AddValue("StatusCode", httpStatusCode);
            _resultService.AddValue(resultado, mensaje);

            if (resultado == Resultado.Success)
            {
                _resultService.AddValue("usuario", usuarioDto);
                _resultService.AddValue("token", token);
            }

            return(_resultService.GetProperties());
        }
Beispiel #5
0
 public async Task <IActionResult> ActivarCuenta(ActivaCuentaDto activarCuenta)
 {
     return(new ObjectResult(await _usuarioService.ActivarCuenta(activarCuenta).ConfigureAwait(true)));
 }