Before_request as middleware alternative in Flask - Mini Project: Build & Apply

Using before_request as Middleware Alternative in Flask

📖 Scenario: You are building a simple Flask web app that needs to check if a user is authenticated before allowing access to certain pages.Instead of writing the authentication check inside every route, you want to use Flask's before_request function as a middleware alternative to run this check automatically before each request.

🎯 Goal: Create a Flask app that uses before_request to check if a user is logged in before accessing the /dashboard route. If the user is not logged in, redirect them to the /login page.

📋 What You'll Learn

Create a Flask app instance named app

Define a global variable logged_in set to False initially

Use @app.before_request to create a function named check_login that checks if the user is logged in

If the user is not logged in and tries to access /dashboard, redirect to /login

Create two routes: /login and /dashboard that return simple text responses

💡 Why This Matters

🌍 Real World

Web apps often need to check user authentication before allowing access to certain pages. Using before_request as middleware helps keep the code clean and centralized.

💼 Career

Understanding middleware patterns and request lifecycle in Flask is essential for backend web development roles.

1

Set up Flask app and login status

Import Flask and redirect from flask. Create a Flask app instance called app. Create a global variable called logged_in and set it to False.

Flask

from flask import Flask, redirect

# Your code here

Hint

Use app = Flask(__name__) to create the app instance.

Set logged_in = False to represent the user not logged in yet.

2

Add before_request function to check login

Use the @app.before_request decorator to create a function named check_login. Inside it, check if logged_in is False and if the requested path is /dashboard. If both are true, return a redirect to /login.

Flask

from flask import Flask, redirect, request

app = Flask(__name__)

logged_in = False

# Add before_request function to check login
# Your code here

Hint

Use @app.before_request to run check_login before every request.

Use request.path to get the current URL path.

3

Create /login and /dashboard routes

Create a route /login that returns the text 'Please log in.'. Create another route /dashboard that returns the text 'Welcome to your dashboard.'.

Flask

from flask import Flask, redirect, request

app = Flask(__name__)

logged_in = False

@app.before_request
def check_login():
    if not logged_in and request.path == '/dashboard':
        return redirect('/login')

# Add /login and /dashboard routes
# Your code here

Hint

Use @app.route('/login') and @app.route('/dashboard') to define routes.

Return simple strings from each route function.

4

Add app run block for local testing

Add the standard Flask app run block: if __name__ == '__main__': and inside it call app.run(debug=True).

Flask

from flask import Flask, redirect, request

app = Flask(__name__)

logged_in = False

@app.before_request
def check_login():
    if not logged_in and request.path == '/dashboard':
        return redirect('/login')

@app.route('/login')
def login():
    return 'Please log in.'

@app.route('/dashboard')
def dashboard():
    return 'Welcome to your dashboard.'

# Add app run block
# Your code here

Hint

This block allows you to run the Flask app locally for testing.

Practice

1. What is the main purpose of the before_request function in Flask?

easy

A. To send the final response to the client

B. To handle errors after a request has been processed

C. To define routes and their handlers

D. To run code before every request to perform tasks like login checks or logging

Solution

1. Step 1: Understand the role of before_request

   The before_request function runs before each request to the Flask app, allowing pre-processing like login checks or logging.

2. Step 2: Compare with other Flask functions

   Functions like error handlers run after requests, and route handlers define endpoints, so they differ from before_request.

3. Final Answer:

   To run code before every request to perform tasks like login checks or logging -> Option D

4. Quick Check:

   before_request runs before requests = D [OK]

Hint: before_request runs code before requests start [OK]

Common Mistakes:

• Confusing before_request with error handlers
• Thinking before_request sends responses directly
• Mixing route definition with before_request

2. Which of the following is the correct way to register a before_request function in Flask?

easy

A. @app.before_request\ndef my_function(): pass

B. app.before_request(my_function())

C. app.before_request = my_function()

D. app.before_request = my_function

Solution

1. Step 1: Recall Flask decorator syntax

   Flask uses decorators like @app.before_request above a function to register it as a before_request handler.

2. Step 2: Analyze each option

   @app.before_request\ndef my_function(): pass uses the correct decorator syntax. app.before_request(my_function()) calls the function instead of decorating. Options C and D assign incorrectly.

3. Final Answer:

   @app.before_request\ndef my_function(): pass -> Option A

4. Quick Check:

   Use @app.before_request decorator = A [OK]

Hint: Use @app.before_request decorator above the function [OK]

Common Mistakes:

• Calling the function instead of decorating
• Assigning function instead of decorating
• Missing the @ symbol for decorator

3. Given this Flask code, what will be the output when accessing /?

from flask import Flask, request, abort
app = Flask(__name__)

@app.before_request
def check_auth():
    if request.args.get('token') != 'secret':
        abort(401)

@app.route('/')
def home():
    return 'Welcome!'

# Assume app runs normally

medium

A. Displays 'Welcome!' if URL has ?token=secret, else 401 Unauthorized error

B. Always displays 'Welcome!' regardless of token

C. Always returns 401 Unauthorized error

D. Raises a syntax error due to missing return in before_request

Solution

1. Step 1: Understand the before_request check

   The check_auth function runs before every request and aborts with 401 if the 'token' query parameter is not 'secret'.

2. Step 2: Analyze the route behavior

   If the token is correct, the request proceeds to home() which returns 'Welcome!'. Otherwise, the request is stopped early with 401.

3. Final Answer:

   Displays 'Welcome!' if URL has ?token=secret, else 401 Unauthorized error -> Option A

4. Quick Check:

   before_request aborts if token wrong = C [OK]

Hint: before_request can block requests early with abort() [OK]

Common Mistakes:

• Thinking before_request must return a value
• Assuming route runs even if abort called
• Confusing query parameters with headers

4. Identify the error in this Flask code using before_request:

from flask import Flask
app = Flask(__name__)

@app.before_request
def setup():
    print('Setup done')

@app.route('/')
def index():
    return 'Hello'

medium

A. Missing parentheses in @app.before_request decorator

B. No return statement in before_request function causes error

C. No error; code works correctly

D. Route function must be named before_request

Solution

1. Step 1: Check before_request function requirements

   The before_request function can run code and does not need to return anything unless it wants to stop the request.

2. Step 2: Verify decorator and route correctness

   The decorator syntax is correct, and the route function is properly defined with a return statement.

3. Final Answer:

   No error; code works correctly -> Option C

4. Quick Check:

   before_request can have no return = B [OK]

Hint: before_request functions don't need to return unless blocking [OK]

Common Mistakes:

• Expecting before_request to always return a response
• Confusing decorator syntax with function call
• Thinking route function must be named before_request

5. You want to use before_request to check if a user is logged in by verifying a session key. If not logged in, redirect to /login. Which code snippet correctly implements this?

hard

A. from flask import redirect, session

def check_login():
if 'user' not in session:
return redirect('/login')
app.before_request(check_login())

B. from flask import redirect, session

@app.before_request
def check_login():
if 'user' not in session:
return redirect('/login')

C. from flask import redirect, session

@app.before_request
def check_login():
if session['user'] is None:
return redirect('/login')

D. from flask import redirect

@app.before_request
def check_login():
if session.get('user') == False:
return redirect('/login')

Solution

1. Step 1: Check session key existence safely

   from flask import redirect, session @app.before_request def check_login(): if 'user' not in session: return redirect('/login') uses 'user' not in session which safely checks if the user is logged in.

2. Step 2: Confirm correct decorator and redirect usage

   from flask import redirect, session @app.before_request def check_login(): if 'user' not in session: return redirect('/login') uses the @app.before_request decorator and returns a redirect response correctly to stop further processing.

3. Final Answer:

   from flask import redirect, session @app.before_request def check_login(): if 'user' not in session: return redirect('/login') -> Option B

4. Quick Check:

   Use @app.before_request and check 'user' in session = A [OK]

Hint: Use @app.before_request and check session key presence [OK]

Common Mistakes:

• Calling the function instead of decorating
• Checking session key with wrong condition
• Not returning redirect to stop request