Autenticación de usuarios: Logout

Podemos agregar estas lineas en la funcion de login para devolver al usuario a hello si ya esta logueado para que no puede ingresar de nuevo a la pagina de login una vez logueado

    if current_user.is_authenticated:
        return redirect(url_for('index'))```

Cuesta llegar hasta aquí. La vaina funciona, no sé muy bien como, pero funciona.

Que tal cambiar

if user_dic.to_dict() is not None:

por

if user_dic.to_dict():

Sanes si tendría alguna implicación?

Tuve que actualizar dos tests.
El get de hello:

    def test_hello_get(self):
        response = self.client.get(url_for('hello'))

        self.assert200(response)

Lo cambié para que se aseguré que me devuelve un status_code de redirección:

  def test_hello_login_required(self):
        response = self.client.get(url_for('hello'))

        self.assertEquals(response.status_code, 302)

Y el de POST sobre la ruta del login:

    def test_auth_login_post(self):
        fake_form = {
            'username': 'fake',
            'password': 'fake-pass'
        }
        
        response = self.client.post(url_for('auth.login'), data=fake_form)
        self.assertRedirects(response, url_for('index'))

Lo cambié por este:

    def test_auth_login_post(self):
        fake_form = {
            'username': 'emmanuel',
            'password': '12345678'
        }
        
        response = self.client.post(url_for('auth.login'), data=fake_form)
        self.assertRedirects(response, url_for('hello'))
        response = self.client.get(url_for('hello'))        
        self.assert200(response)

Que se asegura que redirija a hello y que se puede entrar a hello una vez logeado. Lo malo es que ahora depende de que exista ese usuario en la base de datos que utilizo. Supongo que si se configura un ambiente de CI/CD también se tiene que crear una base de datos para desarrollo en la nube.

me encanta flask, de verdad jajaja

Ahora, al crear un usuario nuevo, hacer logout y poner la misma clave ya no te permite ingresar, esto es porque compruebas un password hasheado con el que mandas el cual no es hasheado, para solucionar esto importas donde werkzeug. security el check password y queda así

from werkzeug.security import generate_password_hash, check_password_hash #para comprobar los hashes

#En login cambiaría password == password_from_db
@auth.route('/login', methods=['GET', 'POST'])
def login():
    login_form = LoginForm()
    context = {
        'login_form': login_form
    }

    if login_form.validate_on_submit():
        username = login_form.username.data
        password = login_form.password.data

        user_doc = get_user(username)

        if user_doc.to_dict() is not None:
            password_from_db = user_doc.to_dict()['password']

            #if password == password_from_db:
	      if check_password_hash(password_from_db, password):
                user_data = UserData(username, password)
                user = UserModel(user_data)

                login_user(user)

                flash('Bienvenido de nuevo')

                redirect(url_for('hello'))
            else:
                flash('La informaición no coincide')
        else:
            flash('El usario no existe')

        return redirect(url_for('index'))

    return render_template('login.html', **context)

Y ahora si cuando el nuevo usuario quiere ingresar ya le permite, aunque los primeros que guardamos sin los hashes ya no serían accesibles

Hasta lo unico que no me ha gustado tanto de los entornos virtuales, es que a veces se hay que reiniciar el entorno para que funcione o se reflejen los cambios

Despues de hacer el login no me redirige a Hello, simplemente me pone:
“Bienvenido de nuev”
“Please login in to access this page”

Y me aparece de nuevo el login_form

me ayudan por favor? mi codigo es diferente al del profesor porque estoy siguiendo con base de datos sql

@auth.route('/login', methods=['GET', 'POST'])
def login():
    login_form = Form()
    context = {
        'login_form' : login_form
    }
    if login_form.validate_on_submit():
        username = login_form.username.data
        password = login_form.password.data
        user_db = Users.query.filter_by(username=username).first()

        if user_db is not None:
            if password == user_db.password:
                session['id_user'] = user_db.id_user
                session['name'] = user_db.name

                flash('Bienvenido de nuevo!')

                redirect(url_for('hello'))
            else: 

Tuve problemas con la verificación del user en el login, por lo que busque en la documentación firebase y encontré otra sintaxis, al momento de escribir esto estoy usando Python 3.10, espero les sirva por si tienen el mismo problema. Este seria el código a modificar en views en el método login():

if login_form.validate_on_submit():
        username = login_form.username.data 
        password = login_form.password.data

        user_ref = get_user(username)
        user_doc = user_ref.get()
        if user_doc.exists:
            password_from_db = user_doc.to_dict()['password']
            
#el resto es igual

'Flask' object has no attribute 'login_manager'```

interesante😅

Dentro del modelo de usuario que creamos, el que usamos con el decorador @login_manager.user_loader para cargar el current_user, podemos guardar atributos y metodos para ser usados solamente cuando tenemos un usuario logueado correctamente.

Tuve muchos errores con import cíclicos de Python. Al fina lo solucioné inicializando mi base de datos en mi archivo db_service desde el init del módulo. Así no requería que se iniciara antes.