claude-code-templates
Version:
CLI tool to setup Claude Code configurations with framework-specific commands, automation hooks and MCP Servers for your projects
244 lines (202 loc) • 6.42 kB
Markdown
# Flask Blueprint Generator
Create organized Flask blueprints for modular application structure.
## Usage
```bash
# Create a new blueprint
flask create-blueprint users
flask create-blueprint api/v1
```
## Blueprint Structure
Generates a complete blueprint with:
- Routes and view functions
- Error handlers
- Template folder structure
- Static file organization
## Example Blueprint
```python
# app/blueprints/users/__init__.py
from flask import Blueprint
users_bp = Blueprint(
'users',
__name__,
url_prefix='/users',
template_folder='templates',
static_folder='static'
)
from . import routes, models
# app/blueprints/users/routes.py
from flask import render_template, request, redirect, url_for, flash
from . import users_bp
from .models import User
from .forms import UserForm
def index():
"""List all users."""
users = User.query.all()
return render_template('users/index.html', users=users)
def create():
"""Create a new user."""
form = UserForm()
if form.validate_on_submit():
user = User(
username=form.username.data,
email=form.email.data
)
user.save()
flash('User created successfully!', 'success')
return redirect(url_for('users.index'))
return render_template('users/create.html', form=form)
def detail(user_id):
"""Show user details."""
user = User.query.get_or_404(user_id)
return render_template('users/detail.html', user=user)
def edit(user_id):
"""Edit an existing user."""
user = User.query.get_or_404(user_id)
form = UserForm(obj=user)
if form.validate_on_submit():
user.username = form.username.data
user.email = form.email.data
user.save()
flash('User updated successfully!', 'success')
return redirect(url_for('users.detail', user_id=user.id))
return render_template('users/edit.html', form=form, user=user)
def delete(user_id):
"""Delete a user."""
user = User.query.get_or_404(user_id)
user.delete()
flash('User deleted successfully!', 'success')
return redirect(url_for('users.index'))
# Error handlers
def not_found(error):
return render_template('users/404.html'), 404
def internal_error(error):
return render_template('users/500.html'), 500
```
## Blueprint Models
```python
# app/blueprints/users/models.py
from app.extensions import db
from werkzeug.security import generate_password_hash, check_password_hash
from datetime import datetime
class User(db.Model):
"""User 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(255), nullable=False)
created_at = db.Column(db.DateTime, default=datetime.utcnow)
updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
is_active = db.Column(db.Boolean, default=True)
def __repr__(self):
return f'<User {self.username}>'
def set_password(self, password):
"""Set password hash."""
self.password_hash = generate_password_hash(password)
def check_password(self, password):
"""Check password hash."""
return check_password_hash(self.password_hash, password)
def save(self):
"""Save user to database."""
db.session.add(self)
db.session.commit()
def delete(self):
"""Delete user from database."""
db.session.delete(self)
db.session.commit()
def to_dict(self):
"""Convert to dictionary."""
return {
'id': self.id,
'username': self.username,
'email': self.email,
'created_at': self.created_at.isoformat(),
'is_active': self.is_active
}
```
## Blueprint Forms
```python
# app/blueprints/users/forms.py
from flask_wtf import FlaskForm
from wtforms import StringField, EmailField, PasswordField, BooleanField
from wtforms.validators import DataRequired, Email, Length, EqualTo
from .models import User
class UserForm(FlaskForm):
"""User creation/edit form."""
username = StringField(
'Username',
validators=[
DataRequired(),
Length(min=3, max=80)
]
)
email = EmailField(
'Email',
validators=[
DataRequired(),
Email(),
Length(max=120)
]
)
password = PasswordField(
'Password',
validators=[
DataRequired(),
Length(min=8)
]
)
confirm_password = PasswordField(
'Confirm Password',
validators=[
DataRequired(),
EqualTo('password', message='Passwords must match')
]
)
is_active = BooleanField('Active')
def validate_username(self, field):
"""Validate username uniqueness."""
if User.query.filter_by(username=field.data).first():
raise ValidationError('Username already exists.')
def validate_email(self, field):
"""Validate email uniqueness."""
if User.query.filter_by(email=field.data).first():
raise ValidationError('Email already registered.')
```
## Registration in Main App
```python
# app/__init__.py
from flask import Flask
from app.blueprints.users import users_bp
def create_app():
app = Flask(__name__)
# Register blueprints
app.register_blueprint(users_bp)
return app
```
## Template Structure
```
templates/
├── base.html
└── users/
├── index.html
├── create.html
├── detail.html
├── edit.html
├── 404.html
└── 500.html
```
## Best Practices
- Use blueprints to organize related functionality
- Keep models, forms, and routes in separate files
- Implement proper error handling
- Use URL prefixes for namespacing
- Follow RESTful routing conventions
- Include comprehensive docstrings
- Add form validation and CSRF protection