🌶️ Flask Web Development

Description: Create a Flask application with multiple interconnected pages.

• Create a route for the Home page (/) that displays a welcome message
• Create a route for the About page (/about) with information about your site
• Create a route for the Contact page (/contact) with contact details
• Add navigation links between all pages
• Use type converters for a User Profile page (/user/<int:user_id>)
• Bonus: Add a dynamic /products/<category> route that displays different products based on category

# Starter Code
from flask import Flask

app = Flask(__name__)

@app.route('/')
def home():
    return "Welcome to my website!"

# TODO: Add /about, /contact, /user/ routes

if __name__ == '__main__':
    app.run(debug=True)

Description: Build a blog page using Jinja2 templates with loops and conditionals.

• Create a templates/blog.html template
• Use a for loop ({% for post in posts %}) to display multiple blog posts
• Use conditionals ({% if post.featured %}) to highlight featured posts
• Display post title, author, date, and content using {{ variable }} syntax
• Use template inheritance with a base.html layout
• Bonus: Add a filter ({{ post.content | truncate(100) }}) to show post previews

<!-- templates/blog.html -->
{% extends 'base.html' %}

{% block content %}
<h1>Blog Posts</h1>

{% for post in posts %}
    <article class="{% if post.featured %}featured{% endif %}">
        <h2>{{ post.title }}</h2>
        <p>By {{ post.author }} on {{ post.date }}</p>
        <p>{{ post.content | truncate(150) }}</p>
    </article>
{% else %}
    <p>No posts available.</p>
{% endfor %}
{% endblock %}

Description: Build a user registration form with server-side validation.

• Create an HTML form with fields: username, email, password, confirm password
• Handle both GET (display form) and POST (process form) methods
• Validate that username is at least 3 characters
• Validate email format using basic checks or regex
• Ensure password and confirm password match
• Display error messages on the form if validation fails
• Bonus: Add CSRF protection using Flask-WTF

from flask import Flask, render_template, request, flash, redirect

app = Flask(__name__)
app.secret_key = 'your-secret-key'

@app.route('/register', methods=['GET', 'POST'])
def register():
    if request.method == 'POST':
        username = request.form['username']
        email = request.form['email']
        password = request.form['password']
        confirm = request.form['confirm']
        
        # TODO: Add validation logic
        if len(username) < 3:
            flash('Username must be at least 3 characters', 'error')
        elif password != confirm:
            flash('Passwords do not match', 'error')
        else:
            flash('Registration successful!', 'success')
            return redirect('/login')
    
    return render_template('register.html')

Description: Create a complete RESTful API for managing a resource (e.g., books, tasks, or products).

• GET /api/items - Return a list of all items as JSON
• GET /api/items/<int:id> - Return a single item by ID (404 if not found)
• POST /api/items - Create a new item from JSON body, return 201 status
• PUT /api/items/<int:id> - Update an existing item completely
• PATCH /api/items/<int:id> - Partially update an item
• DELETE /api/items/<int:id> - Delete an item, return 204 No Content
• Use proper HTTP status codes (200, 201, 204, 400, 404)
• Bonus: Add pagination for the GET all endpoint

from flask import Flask, jsonify, request, abort

app = Flask(__name__)

# In-memory storage
items = [
    {'id': 1, 'name': 'Item One', 'price': 19.99},
    {'id': 2, 'name': 'Item Two', 'price': 29.99},
]
next_id = 3

# GET all items
@app.route('/api/items', methods=['GET'])
def get_items():
    return jsonify({'items': items})

# GET single item
@app.route('/api/items/<int:item_id>', methods=['GET'])
def get_item(item_id):
    item = next((i for i in items if i['id'] == item_id), None)
    if item is None:
        abort(404)
    return jsonify(item)

# TODO: Implement POST, PUT, PATCH, DELETE

Description: Connect your Flask app to a SQLite database and implement CRUD operations.

• Install Flask-SQLAlchemy: pip install flask-sqlalchemy
• Configure SQLite database connection in your app
• Create a Model class (e.g., Task or User) with columns
• Implement Create: Add new records to the database
• Implement Read: Query and display all records
• Implement Update: Modify existing records
• Implement Delete: Remove records from the database
• Bonus: Add a search/filter feature using query parameters

from flask import Flask
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///tasks.db'
db = SQLAlchemy(app)

# Define a Model
class Task(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(100), nullable=False)
    completed = db.Column(db.Boolean, default=False)
    
    def to_dict(self):
        return {'id': self.id, 'title': self.title, 'completed': self.completed}

# Create tables
with app.app_context():
    db.create_all()

# CRUD Operations
@app.route('/tasks', methods=['GET'])
def get_tasks():
    tasks = Task.query.all()
    return jsonify([task.to_dict() for task in tasks])

@app.route('/tasks', methods=['POST'])
def create_task():
    data = request.get_json()
    task = Task(title=data['title'])
    db.session.add(task)
    db.session.commit()
    return jsonify(task.to_dict()), 201

# TODO: Implement GET by ID, PUT/PATCH, DELETE