Flask Web Application

Project Structure

Organize your code into the following structure:

flask-moviehub/
├── app/
│   ├── __init__.py          # App factory
│   ├── models.py            # Database models
│   ├── auth/
│   │   ├── __init__.py      # Auth blueprint
│   │   ├── routes.py        # Auth routes
│   │   └── forms.py         # WTForms
│   ├── main/
│   │   ├── __init__.py      # Main blueprint
│   │   └── routes.py        # Main routes
│   ├── api/
│   │   ├── __init__.py      # API blueprint
│   │   └── routes.py        # API endpoints
│   ├── templates/
│   │   ├── base.html        # Base template
│   │   ├── auth/            # Auth templates
│   │   └── main/            # Main templates
│   └── static/
│       ├── css/             # Stylesheets
│       └── js/              # JavaScript
├── migrations/              # Database migrations
├── tests/
│   ├── test_auth.py         # Auth tests
│   ├── test_models.py       # Model tests
│   └── test_api.py          # API tests
├── instance/
│   └── movies.db            # SQLite database
├── config.py                # Configuration
├── requirements.txt         # Dependencies
├── run.py                   # Entry point
└── README.md                # Documentation

Database Models (SQLAlchemy)

Create the following database models:

• User: id, username, email, password_hash, created_at
• Movie: id, title, overview, release_date, budget, revenue, rating, runtime
• Favorite: id, user_id, movie_id, created_at (many-to-many relationship)
• Review: id, user_id, movie_id, rating, content, created_at (optional)

from flask_sqlalchemy import SQLAlchemy
from flask_login import UserMixin
from werkzeug.security import generate_password_hash, check_password_hash
from datetime import datetime

db = SQLAlchemy()

# Association table for favorites
favorites = db.Table('favorites',
    db.Column('user_id', db.Integer, db.ForeignKey('users.id'), primary_key=True),
    db.Column('movie_id', db.Integer, db.ForeignKey('movies.id'), primary_key=True),
    db.Column('created_at', db.DateTime, default=datetime.utcnow)
)

class User(UserMixin, db.Model):
    __tablename__ = 'users'
    
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(80), unique=True, nullable=False)
    email = db.Column(db.String(120), unique=True, nullable=False)
    password_hash = db.Column(db.String(256), nullable=False)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)
    
    favorites = db.relationship('Movie', secondary=favorites, 
                               backref=db.backref('favorited_by', lazy='dynamic'))
    
    def set_password(self, password):
        self.password_hash = generate_password_hash(password)
    
    def check_password(self, password):
        return check_password_hash(self.password_hash, password)

class Movie(db.Model):
    __tablename__ = 'movies'
    
    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(200), nullable=False)
    overview = db.Column(db.Text)
    release_date = db.Column(db.Date)
    budget = db.Column(db.BigInteger, default=0)
    revenue = db.Column(db.BigInteger, default=0)
    runtime = db.Column(db.Integer)
    vote_average = db.Column(db.Float, default=0.0)
    vote_count = db.Column(db.Integer, default=0)
    popularity = db.Column(db.Float, default=0.0)

User Authentication (Flask-Login)

Implement secure authentication:

• Registration: Username, email, password with validation
• Login: Email/username and password authentication
• Logout: Clear session and redirect
• Password hashing: Use Werkzeug's generate_password_hash
• Protected routes: Use @login_required decorator
• Sessions: Flask-Login session management

from flask import Blueprint, render_template, redirect, url_for, flash, request
from flask_login import login_user, logout_user, login_required, current_user
from app.models import User, db
from app.auth.forms import LoginForm, RegistrationForm

auth = Blueprint('auth', __name__)

@auth.route('/register', methods=['GET', 'POST'])
def register():
    if current_user.is_authenticated:
        return redirect(url_for('main.index'))
    
    form = RegistrationForm()
    if form.validate_on_submit():
        user = User(username=form.username.data, email=form.email.data)
        user.set_password(form.password.data)
        db.session.add(user)
        db.session.commit()
        flash('Registration successful! Please log in.', 'success')
        return redirect(url_for('auth.login'))
    return render_template('auth/register.html', form=form)

@auth.route('/login', methods=['GET', 'POST'])
def login():
    if current_user.is_authenticated:
        return redirect(url_for('main.index'))
    
    form = LoginForm()
    if form.validate_on_submit():
        user = User.query.filter_by(email=form.email.data).first()
        if user and user.check_password(form.password.data):
            login_user(user, remember=form.remember.data)
            next_page = request.args.get('next')
            flash('Welcome back!', 'success')
            return redirect(next_page or url_for('main.index'))
        flash('Invalid email or password', 'danger')
    return render_template('auth/login.html', form=form)

RESTful API Endpoints

Create JSON API endpoints:

• GET /api/movies - List all movies (with pagination)
• GET /api/movies/<id> - Get single movie by ID
• POST /api/movies - Create new movie (auth required)
• PUT /api/movies/<id> - Update movie (auth required)
• DELETE /api/movies/<id> - Delete movie (auth required)
• GET /api/movies/search?q= - Search movies by title

from flask import Blueprint, jsonify, request
from flask_login import login_required, current_user
from app.models import Movie, db

api = Blueprint('api', __name__)

@api.route('/movies', methods=['GET'])
def get_movies():
    page = request.args.get('page', 1, type=int)
    per_page = request.args.get('per_page', 20, type=int)
    
    movies = Movie.query.paginate(page=page, per_page=per_page)
    
    return jsonify({
        'movies': [movie.to_dict() for movie in movies.items],
        'total': movies.total,
        'pages': movies.pages,
        'current_page': page
    })

@api.route('/movies/<int:id>', methods=['GET'])
def get_movie(id):
    movie = Movie.query.get_or_404(id)
    return jsonify(movie.to_dict())

@api.route('/movies', methods=['POST'])
@login_required
def create_movie():
    data = request.get_json()
    
    movie = Movie(
        title=data['title'],
        overview=data.get('overview', ''),
        budget=data.get('budget', 0),
        revenue=data.get('revenue', 0)
    )
    db.session.add(movie)
    db.session.commit()
    
    return jsonify(movie.to_dict()), 201

Templates (Jinja2 + Bootstrap)

Create responsive web pages:

• base.html: Layout with navbar, footer, flash messages
• index.html: Home page with featured movies
• movies.html: Movie grid with pagination
• movie_detail.html: Single movie details
• login.html / register.html: Auth forms
• profile.html: User profile with favorites

Configuration

Environment-based configuration:

• Development: Debug mode, SQLite, verbose logging
• Production: No debug, secure cookies, HTTPS
• Environment variables: SECRET_KEY, DATABASE_URL
• .env file: Local environment variables

import os
from dotenv import load_dotenv

load_dotenv()

class Config:
    SECRET_KEY = os.environ.get('SECRET_KEY') or 'dev-secret-key'
    SQLALCHEMY_DATABASE_URI = os.environ.get('DATABASE_URL') or \
        'sqlite:///instance/movies.db'
    SQLALCHEMY_TRACK_MODIFICATIONS = False

class DevelopmentConfig(Config):
    DEBUG = True

class ProductionConfig(Config):
    DEBUG = False
    # Use PostgreSQL in production
    SQLALCHEMY_DATABASE_URI = os.environ.get('DATABASE_URL')

config = {
    'development': DevelopmentConfig,
    'production': ProductionConfig,
    'default': DevelopmentConfig
}