Example #1
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());
        }
Example #2
0
        public async Task <Dictionary <string, object> > CrearUsuario(UsuarioDto usuarioNuevo)
        {
            httpStatusCode = HttpStatusCode.OK;
            resultado      = Resultado.Success;
            mensaje        = "";
            Usuario usuario = null;

            if (!usuarioNuevo.IsNull())
            {
                if (await ValidaNuevo(usuarioNuevo).ConfigureAwait(true))
                {
                    if (usuarioNuevo.Contrasena.BuildHashString(out byte[] contrhash, out byte[] contrsalt, out mensaje))
                    {
                        // Mapear datos de DTO al modelo.
                        usuario = usuarioNuevo.Map <Usuario>();

                        // Obtener fecha de registro.
                        usuario.FechaRegist = DateTime.Now;

                        // Inicializar la contraseña con Hash y el Salt.
                        usuario.ContrasHash = contrhash;
                        usuario.ContrasSalt = contrsalt;

                        // Generar nuevo código de opción.
                        string maxcod = await _repoWrapper.Usuario.MaxIdAsync();

                        string newcod = (int.Parse(maxcod, CultureInfo.InvariantCulture) + 1).ToString().Trim().PadLeft(15, '0');

                        usuario.CodUsuario = newcod;

                        // 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.
                        _ = CreaCambioRestringido(usuario, paramGenUsu.CodActiCuenta, out string randomCode);

                        // Salvar datos de usuario.
                        _repoWrapper.Usuario.Create(usuario);

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

                            mensaje = "Usuario creado con éxito.";
                        }
                        else
                        {
                            usuario        = null;
                            httpStatusCode = HttpStatusCode.InternalServerError;
                            resultado      = Resultado.Error;
                            mensaje        = "Inconsistencia al salvar usuario.";
                        }
                    }
                    else
                    {
                        usuario        = null;
                        httpStatusCode = HttpStatusCode.BadRequest;
                        resultado      = Resultado.Error;
                    }
                }
            }
            else
            {
                usuario        = null;
                httpStatusCode = HttpStatusCode.BadRequest;
                resultado      = Resultado.Error;
                mensaje        = "Datos de usuario incorrectos.";
            }

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

            if (resultado == Resultado.Success)
            {
                usuarioNuevo = usuario.Map <UsuarioDto>();
                _resultService.AddValue("usuario", usuarioNuevo);
            }

            return(_resultService.GetProperties());
        }
Example #3
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());
        }