Creating a personal blog with Flask is not just another project; it’s a great way to dive into the world of web development. Imagine it as your very own digital canvas where you can share your thoughts, ideas, and stories. Today, let’s walk through how to set up a simple, yet robust, blogging platform with user authentication and all the CRUD operations you might need.

First off, we need to set up our Flask application. Think of it like setting up the foundation of your home. Start by creating a new directory for your project. Grab your terminal and run these commands:

mkdir myblog
cd myblog
pip install flask flask-login flask-sqlalchemy

Next, create a file named app.py where we’ll initialize our Flask app. Here’s the basic structure to get things rolling:

from flask import Flask, render_template, request, redirect, url_for
from flask_login import LoginManager, UserMixin, login_user, logout_user, login_required, current_user
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///blog.db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
app.config['SECRET_KEY'] = 'your_secret_key_here'

db = SQLAlchemy(app)
login_manager = LoginManager(app)
login_manager.login_view = 'login'

Next up, we need a user model to handle authentication. This model will keep our user information neatly stored.

class User(UserMixin, db.Model):
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(64), unique=True, nullable=False)
    email = db.Column(db.String(120), unique=True, nullable=False)
    password = db.Column(db.String(128), nullable=False)

    def __init__(self, username, email, password):
        self.username = username
        self.email = email
        self.password = generate_password_hash(password)

    def check_password(self, password):
        return check_password_hash(self.password, password)

To handle user authentication, we’ll need routes for registration, login, and logout.

For registration, where new users can join your platform:

from flask import flash

@app.route('/register', methods=['GET', 'POST'])
def register():
    if current_user.is_authenticated:
        flash("You are already registered.", "info")
        return redirect(url_for("home"))

    if request.method == 'POST':
        username = request.form['username']
        email = request.form['email']
        password = request.form['password']
        user = User(username=username, email=email, password=password)
        db.session.add(user)
        db.session.commit()
        login_user(user)
        flash("You registered and are now logged in. Welcome!", "success")
        return redirect(url_for("home"))
    return render_template("register.html")

Then for logging in, ensuring that existing users can access their accounts:

@app.route('/login', methods=['GET', 'POST'])
def login():
    if current_user.is_authenticated:
        flash("You are already logged in.", "info")
        return redirect(url_for("home"))

    if request.method == 'POST':
        email = request.form['email']
        password = request.form['password']
        user = User.query.filter_by(email=email).first()
        if user and user.check_password(password):
            login_user(user)
            flash("You are now logged in.", "success")
            return redirect(url_for("home"))
    return render_template("login.html")

And, of course, a route for logging out:

@app.route('/logout')
@login_required
def logout():
    logout_user()
    flash("You are now logged out.", "success")
    return redirect(url_for("home"))

To keep our user sessions in check, we need a function that loads users from our database:

@login_manager.user_loader
def load_user(user_id):
    return User.query.get(int(user_id))

Now that user authentication is squared away, we need a model to store our blog posts.

class Post(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(100), nullable=False)
    content = db.Column(db.Text, nullable=False)
    author_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
    author = db.relationship('User', backref=db.backref('posts', lazy=True))

    def __init__(self, title, content, author):
        self.title = title
        self.content = content
        self.author = author

Blogging wouldn’t be complete without CRUD operations for those posts. Let’s set that up.

Creating a post:

@app.route('/create', methods=['GET', 'POST'])
@login_required
def create_post():
    if request.method == 'POST':
        title = request.form['title']
        content = request.form['content']
        post = Post(title=title, content=content, author=current_user)
        db.session.add(post)
        db.session.commit()
        flash("Post created successfully!", "success")
        return redirect(url_for("home"))
    return render_template("create_post.html")

Reading posts, which essentially means displaying them on the homepage:

@app.route('/')
def home():
    posts = Post.query.all()
    return render_template("home.html", posts=posts)

Updating an existing post:

@app.route('/post/<int:post_id>/update', methods=['GET', 'POST'])
@login_required
def update_post(post_id):
    post = Post.query.get_or_404(post_id)
    if post.author != current_user:
        flash("You do not have permission to edit this post.", "danger")
        return redirect(url_for("home"))
    if request.method == 'POST':
        post.title = request.form['title']
        post.content = request.form['content']
        db.session.commit()
        flash("Post updated successfully!", "success")
        return redirect(url_for("home"))
    return render_template("update_post.html", post=post)

And finally, deleting a post:

@app.route('/post/<int:post_id>/delete', methods=['POST'])
@login_required
def delete_post(post_id):
    post = Post.query.get_or_404(post_id)
    if post.author != current_user:
        flash("You do not have permission to delete this post.", "danger")
        return redirect(url_for("home"))
    db.session.delete(post)
    db.session.commit()
    flash("Post deleted successfully!", "success")
    return redirect(url_for("home"))

Now, to bring your blog to life, create the database and run your application.

if __name__ == '__main__':
    with app.app_context():
        db.create_all()
    app.run(debug=True)

Building a personal blog with Flask includes a series of detailed steps, from setting up the application to creating user models and managing CRUD operations for blog posts. This journey offers a perfect blend of learning and fun. The best part is, you get to tailor your templates and add new features to make your blog uniquely yours.

Keep tinkering with the code, add more flair to your UI, and before you know it, you’ll have a fully functional, engaging blogging platform. Happy coding and happy blogging!