Пример #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());
        }
Пример #2
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());
        }