flaskbb-plugin-like 1.0.0.dev0__py3-none-any.whl

flaskbb_plugin_like-1.0.0.dev0.dist-info/METADATA

@@ -0,0 +1,51 @@
+Metadata-Version: 2.5
+Name: flaskbb-plugin-like
+Version: 1.0.0.dev0
+Summary: Like functionality for FlaskBB - let users like posts and see who liked them
+Project-URL: Homepage, https://github.com/flaskbb/flaskbb-plugin-like
+Project-URL: Repository, https://github.com/flaskbb/flaskbb-plugin-like
+Project-URL: Issues, https://github.com/flaskbb/flaskbb-plugin-like/issues
+Project-URL: Changelog, https://github.com/flaskbb/flaskbb-plugin-like/blob/master/CHANGELOG.md
+Author-email: Peter Justin <peter.justin@outlook.com>
+Maintainer-email: Peter Justin <peter.justin@outlook.com>
+License-Expression: BSD-3-Clause
+License-File: LICENSE
+Keywords: flaskbb,like,likes,plugin
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Web Environment
+Classifier: Framework :: Flask
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.12
+Requires-Dist: flaskbb>=3.0.0
+Description-Content-Type: text/markdown
+
+Like
+====
+
+Like functionality for FlaskBB. Lets users like posts and see who liked them.
+
+
+Installation
+------------
+
+Install *flaskbb-plugin-like* with
+``pip install flaskbb-plugin-like``
+
+And run the migrations:
+``flaskbb db upgrade``
+
+
+Credits
+-------
+Forked from [flaskbb-plugin-vanity](https://github.com/micha030201/flaskbb-plugin-vanity) by Михаил Лебедев.
+
+License
+-------
+This project is licensed under the terms of the [BSD License](/LICENSE).

flaskbb_plugin_like-1.0.0.dev0.dist-info/RECORD

@@ -0,0 +1,17 @@
+like/__init__.py,sha256=6gilrMXZEaZTS4sIGaBvY_sTBEFs9J4fiBmKdBqMh7Y,2774
+like/forms.py,sha256=paftjPk2cq5RmDUnm8JQZKd3UpQ4Y9XqGQk31tN1efw,427
+like/models.py,sha256=d4MEqJVq8iHK0bUtHH4wMvg3gn6Rf9SQ9XsB5MbP67E,4742
+like/utils.py,sha256=X_TeGsvPxcnRzL4VlfTHsuE-Zm5guZeL8ISjpKeIw7g,3065
+like/views.py,sha256=90i_pSA3LHW-VcvnIZc3AIZPUoWLQ7MdrN7kWF5yIOY,4549
+like/migrations/202607311200_b7d2e4f6a9c1_add_like_association.py,sha256=8IMz4iE9ybDLrH5Ei_iT1Fy0L8QvCrA_j6jmfsRwcRk,2579
+like/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+like/static/like.js,sha256=Xao0lqzuQM_YCvCQMIKEBEkeeG4J2Y6LI-iWn6Azw18,1772
+like/templates/like/_like_button.html,sha256=MSgB5Y6vePLx0CzUz_Ub0LstG3iL8rylZYj8sJrsK4M,2015
+like/templates/like/_like_counts.html,sha256=6yg_EqfmkL-_9T4iCahE0kqVS_s2XsuPbKeq0kO1Fpg,263
+like/templates/like/_scripts.html,sha256=UyFZ5q0_DQ36ieUFTjXzbk7MYDhkCGmXnN7Jj3AxjQA,73
+like/templates/like/liked_posts.html,sha256=omvEgW7vbamz6YzDNrnLX5W_Ik2cu4rsxUl1Dj4_7MU,1932
+flaskbb_plugin_like-1.0.0.dev0.dist-info/METADATA,sha256=IW7NhJp606WZasI-FxLzLRg3XrMDd7QKBldGeO3pNxM,1778
+flaskbb_plugin_like-1.0.0.dev0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+flaskbb_plugin_like-1.0.0.dev0.dist-info/entry_points.txt,sha256=iQnjmlVJFj3yQ8exgU0tHzgHy_Mvhqy9UGLrVsDcDmw,30
+flaskbb_plugin_like-1.0.0.dev0.dist-info/licenses/LICENSE,sha256=0fSTfZMRcOWJ7ZMsVF4Lrshq8kb4hha4qviRKNL3Vc4,1575
+flaskbb_plugin_like-1.0.0.dev0.dist-info/RECORD,,

flaskbb_plugin_like-1.0.0.dev0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

flaskbb_plugin_like-1.0.0.dev0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[flaskbb_plugins]
+like = like

flaskbb_plugin_like-1.0.0.dev0.dist-info/licenses/LICENSE

@@ -0,0 +1,33 @@
+Copyright (c) 2018 Михаил Лебедев
+Copyright (c) 2026 Peter Justin
+
+Some rights reserved.
+
+Redistribution and use in source and binary forms of the software as well
+as documentation, with or without modification, are permitted provided
+that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright
+  notice, this list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the following
+  disclaimer in the documentation and/or other materials provided
+  with the distribution.
+
+* The names of the contributors may not be used to endorse or
+  promote products derived from this software without specific
+  prior written permission.
+
+THIS SOFTWARE AND DOCUMENTATION IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT
+NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE AND DOCUMENTATION, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGE.

like/__init__.py

@@ -0,0 +1,115 @@
+"""
+like
+~~~~
+
+Like functionality for FlaskBB. Lets users like posts and see who liked
+them, via a button on the post menu.
+
+:copyright: (c) 2026 by Peter Justin, (c) 2018 by Михаил Лебедев.
+:license: BSD License, see LICENSE for more details.
+"""
+
+import os
+
+from flask import Flask
+from flask_babelplus import gettext as _
+from flask_login import current_user
+from flaskbb.settings import BoolSetting, SettingGroup
+from flaskbb.display.navigation import NavigationLink
+from flaskbb.forum.models import Post
+from flaskbb.user.models import User
+from flaskbb.utils.helpers import real, render_template
+from pluggy import HookimplMarker
+
+from .forms import LikeActionForm
+from .utils import (
+    DEFAULT_ALLOW_SELF_LIKE,
+    can_like_post,
+    has_liked,
+    likes_given_count,
+    likes_received_count,
+)
+from .views import like_bp
+
+__version__ = "1.0.0"
+
+hookimpl = HookimplMarker("flaskbb")
+
+
+@hookimpl
+def flaskbb_load_migrations():
+    return os.path.join(os.path.dirname(__file__), "migrations")
+
+
+@hookimpl
+def flaskbb_load_translations():
+    return os.path.join(os.path.dirname(__file__), "translations")
+
+
+@hookimpl
+def flaskbb_load_blueprints(app: Flask):
+    app.register_blueprint(
+        like_bp, url_prefix=app.config.get("PLUGIN_LIKE_URL_PREFIX", "/like")
+    )
+
+
+SETTINGS = SettingGroup(
+    key="like",
+    name="Like Settings",
+    description="Settings for the like plugin.",
+    settings=(
+        BoolSetting(
+            key="ALLOW_SELF_LIKE",
+            value=DEFAULT_ALLOW_SELF_LIKE,
+            name="Allow liking your own posts",
+            description="If enabled, a user may like their own posts.",
+        ),
+    ),
+)
+
+
+@hookimpl
+def flaskbb_load_setting_groups():
+    return SETTINGS
+
+
+@hookimpl
+def flaskbb_tpl_post_menu_before(post: Post):
+    user = real(current_user)
+    can_like = user.is_authenticated and can_like_post(user, post)
+    already_liked = user.is_authenticated and has_liked(user, post)
+    return render_template(
+        "like/_like_button.html",
+        post=post,
+        can_like=can_like,
+        already_liked=already_liked,
+        form=LikeActionForm(),
+    )
+
+
+@hookimpl
+def flaskbb_tpl_post_author_info_after(user: User | None, post: Post):
+    if user is None:
+        return None
+
+    return render_template(
+        "like/_like_counts.html",
+        user=user,
+        likes_given=likes_given_count(user),
+        likes_received=likes_received_count(user),
+    )
+
+
+@hookimpl
+def flaskbb_tpl_scripts():
+    return render_template("like/_scripts.html")
+
+
+@hookimpl
+def flaskbb_tpl_profile_sidebar_links(user: User):
+    return NavigationLink(
+        endpoint="like.liked_posts",
+        name=_("Liked posts"),
+        icon="fa fa-heart",
+        urlforkwargs={"username": user.username},
+    )

like/forms.py

@@ -0,0 +1,18 @@
+"""
+like.forms
+~~~~~~~~~~
+
+Forms used to like/unlike a post. Their only real job is to carry the
+CSRF token - which post to (un)like comes from the URL.
+
+:copyright: (c) 2026 by Peter Justin.
+:license: BSD License, see LICENSE for more details.
+"""
+
+from flask_wtf import FlaskForm
+
+
+class LikeActionForm(FlaskForm):
+    """Used in _like_button.html to like or unlike a post.
+    It just contains the hidden CSRF field
+    """

like/migrations/202607311200_b7d2e4f6a9c1_add_like_association.py

@@ -0,0 +1,85 @@
+"""Add like_association and the user like counters
+
+Revision ID: b7d2e4f6a9c1
+Revises:
+Create Date: 2026-07-31 12:00:00.000000
+
+"""
+
+import sqlalchemy as sa
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision = "b7d2e4f6a9c1"
+down_revision = None
+branch_labels = ("like",)
+depends_on = "8ad96e49dc6"  # flaskbb core init migration - creates posts/users
+
+
+def upgrade():
+    con = op.get_bind()
+    inspector = sa.inspect(con.engine)
+
+    if not inspector.has_table("like_association"):
+        op.create_table(
+            "like_association",
+            sa.Column("post_id", sa.Integer(), nullable=False),
+            sa.Column("user_id", sa.Integer(), nullable=False),
+            sa.ForeignKeyConstraint(
+                ["post_id"],
+                ["posts.id"],
+                name=op.f("fk_like_association_post_id_posts"),
+                ondelete="CASCADE",
+            ),
+            sa.ForeignKeyConstraint(
+                ["user_id"],
+                ["users.id"],
+                name=op.f("fk_like_association_user_id_users"),
+                ondelete="CASCADE",
+            ),
+            sa.PrimaryKeyConstraint(
+                "post_id", "user_id", name=op.f("pk_like_association")
+            ),
+        )
+
+    # a fresh install that went through db.create_all() already has them
+    user_columns = {c["name"] for c in inspector.get_columns("users")}
+    with op.batch_alter_table("users", schema=None) as batch_op:
+        if "likes_given" not in user_columns:
+            batch_op.add_column(
+                sa.Column(
+                    "likes_given", sa.Integer(), nullable=False, server_default="0"
+                )
+            )
+        if "likes_received" not in user_columns:
+            batch_op.add_column(
+                sa.Column(
+                    "likes_received", sa.Integer(), nullable=False, server_default="0"
+                )
+            )
+
+    op.execute(
+        """
+        UPDATE users SET likes_given = (
+            SELECT COUNT(*) FROM like_association
+            WHERE like_association.user_id = users.id
+        )
+        """
+    )
+    op.execute(
+        """
+        UPDATE users SET likes_received = (
+            SELECT COUNT(*) FROM like_association
+            JOIN posts ON posts.id = like_association.post_id
+            WHERE posts.user_id = users.id
+        )
+        """
+    )
+
+
+def downgrade():
+    op.drop_table("like_association")
+
+    with op.batch_alter_table("users", schema=None) as batch_op:
+        batch_op.drop_column("likes_received")
+        batch_op.drop_column("likes_given")

like/models.py

@@ -0,0 +1,131 @@
+"""
+like.models
+~~~~~~~~~~~
+
+The model for a user's like on a post.
+
+:copyright: (c) 2026 by Peter Justin, (c) 2018 by Михаил Лебедев.
+:license: BSD License, see LICENSE for more details.
+"""
+
+from typing import TYPE_CHECKING, cast
+
+from flaskbb.extensions import db
+from flaskbb.forum.models import Post
+from flaskbb.user.models import User
+from flaskbb.utils.database import BaseModel
+from sqlalchemy import Connection, ForeignKey, Integer, Table, event, update
+from sqlalchemy.ext.associationproxy import association_proxy
+from sqlalchemy.orm import Mapped, Mapper, mapped_column, relationship
+
+
+class PostLike(BaseModel):
+    __tablename__ = "like_association"
+
+    post_id: Mapped[int] = mapped_column(
+        ForeignKey("posts.id", ondelete="CASCADE"), primary_key=True
+    )
+    user_id: Mapped[int] = mapped_column(
+        ForeignKey("users.id", ondelete="CASCADE"), primary_key=True
+    )
+
+    # Both sides load via `selectin`, never `joined` - see
+    # https://github.com/flaskbb/flaskbb/issues/503. `joined` folds into
+    # whatever query loads a Post/User, including flaskbb's own hand-built
+    # outerjoin in Topic.get_posts, and corrupts its column layout.
+    # `selectin` always runs as its own separate, batched query instead, so
+    # it can chain (post -> liked_by_users -> user) without ever touching a
+    # query this plugin doesn't own.
+    post: Mapped["Post"] = relationship(
+        "Post",
+        backref=db.backref(
+            "liked_by_users", lazy="selectin", cascade="all, delete-orphan"
+        ),
+    )
+    user: Mapped["User"] = relationship(
+        "User",
+        lazy="selectin",
+        backref=db.backref("user_liked_posts", cascade="all, delete-orphan"),
+    )
+
+
+Post.likers = association_proxy(
+    "liked_by_users",
+    "user",
+    creator=lambda user: PostLike(user=user),  # pyright: ignore
+)
+
+# Denormalized like counters on the core `users` table. Counting from
+# like_association on every render costs a query per distinct post author
+# per page; these are two columns that come along with the User row that
+# flaskbb has already loaded.
+#
+# Assigning a mapped_column onto an already-mapped class goes through
+# declarative's _add_attribute, which appends the column to the `users`
+# Table and adds the property to User's mapper - the same monkey-patching
+# this plugin already does with Post.likers above. like/migrations adds
+# the actual DB columns.
+User.likes_given = mapped_column(Integer, default=0, server_default="0", nullable=False)
+User.likes_received = mapped_column(
+    Integer, default=0, server_default="0", nullable=False
+)
+
+
+if TYPE_CHECKING:
+
+    class LikeUser(User):
+        """A ``User`` with the two counters added above. They are added at
+        import time, so a type checker cannot see them on ``User`` itself -
+        cast to this to read or write them.
+        """
+
+        likes_given: int = 0
+        likes_received: int = 0
+
+else:
+    LikeUser = User
+
+
+def _apply_delta(connection: Connection, like: PostLike, delta: int) -> None:
+    """Two people liking the same post at once can't lose an increment. Runs
+    on the flush's connection, in the same transaction as the row itself.
+
+    The post's author is looked up as a subquery instead of via
+    ``like.post.user_id``: emitting a lazy load from inside a flush event is
+    not allowed, and on the delete path the Post may already be gone from the
+    session. If the post has no author (guest post, or the author's row went
+    first), the subquery is NULL and the UPDATE matches nothing.
+    """
+    users = cast(Table, User.__table__)
+    posts = cast(Table, Post.__table__)
+    author_id = (
+        db.select(posts.c.user_id).where(posts.c.id == like.post_id).scalar_subquery()
+    )
+    connection.execute(
+        update(users)
+        .where(users.c.id == like.user_id)
+        .values(likes_given=users.c.likes_given + delta)
+    )
+    connection.execute(
+        update(users)
+        .where(users.c.id == author_id)
+        .values(likes_received=users.c.likes_received + delta)
+    )
+
+
+@event.listens_for(PostLike, "after_insert")
+def _increment_like_counts(
+    mapper: Mapper[PostLike], connection: Connection, target: PostLike
+) -> None:
+    _apply_delta(connection, target, 1)
+
+
+@event.listens_for(PostLike, "after_delete")
+def _decrement_like_counts(
+    mapper: Mapper[PostLike], connection: Connection, target: PostLike
+) -> None:
+    # Keeps the counters honest on paths this plugin never sees: deleting a
+    # post or a user cascades through the ORM relationships above, which
+    # deletes each PostLike individually and fires this. A raw SQL delete
+    # against like_association bypasses it - see recalculate_like_counts.
+    _apply_delta(connection, target, -1)

like/static/like.js

@@ -0,0 +1,58 @@
+(function () {
+  "use strict";
+
+  function patchCounts(counts) {
+    for (const entry of counts) {
+      const blocks = document.querySelectorAll(
+        `.like-counts[data-user-id="${entry.user_id}"]`
+      );
+      for (const block of blocks) {
+        block.querySelector(".like-counts-given").textContent = entry.given;
+        block.querySelector(".like-counts-received").textContent =
+          entry.received;
+      }
+    }
+  }
+
+  // Delegated, because the widget this fires on is replaced by the response
+  // of the request it just sent.
+  document.addEventListener("submit", async (event) => {
+    const form = event.target.closest("form[data-like-form]");
+    if (!form) {
+      return;
+    }
+    event.preventDefault();
+
+    const widget = form.closest(".like-widget");
+    const button = form.querySelector("button[type=submit]");
+    button.disabled = true;
+
+    let response;
+    try {
+      response = await fetch(form.action, {
+        method: "POST",
+        headers: { "X-Requested-With": "XMLHttpRequest" },
+        // Carries the form's CSRF token, so the view's LikeActionForm
+        // validates exactly like it does for a plain post.
+        body: new FormData(form),
+      });
+    } catch (error) {
+      // Offline or the request never landed - nothing changed server side,
+      // so let the user try again.
+      button.disabled = false;
+      return;
+    }
+
+    if (!response.ok) {
+      // A stale token, or the post was liked/unliked from somewhere else in
+      // the meantime. Submit for real so the user lands on the same page the
+      // no-JS flow would have given them.
+      form.submit();
+      return;
+    }
+
+    const data = await response.json();
+    widget.outerHTML = data.widget;
+    patchCounts(data.counts);
+  });
+})();

like/templates/like/_like_button.html

@@ -0,0 +1,41 @@
+{% set likes = post.likers | length %}
+<div class="like-widget d-inline" data-post-id="{{ post.id }}">
+    <a href="#" data-bs-toggle="modal" data-bs-target="#likers-post-{{ post.id }}">
+        <small>{{ _("%(count)s like%(plural)s", count=likes, plural="" if likes == 1 else "s") }}</small>
+    </a>
+    <div class="modal fade" id="likers-post-{{ post.id }}" tabindex="-1" aria-hidden="true">
+        <div class="modal-dialog" role="document">
+            <div class="modal-content">
+                <div class="modal-header">
+                    <h5 class="modal-title">{{ _("Users who liked this post") }}</h5>
+                    <button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="Close"></button>
+                </div>
+                <div class="modal-body">
+                    {% for liker in post.likers %}
+                    <div><a href="{{ liker.url }}">{{ liker.username }}</a></div>
+                    {% else %}
+                    <div>{{ _("No likes yet") }}</div>
+                    {% endfor %}
+                </div>
+            </div>
+        </div>
+    </div>
+
+    {% if can_like %}
+    {# No data-bs-toggle="tooltip" here: aurora instantiates its tooltips once
+       on page load and doesn't expose bootstrap to plugin scripts, so a button
+       swapped in by like.js would end up without one. A plain title attribute
+       survives the swap. #}
+    <form class="d-inline"
+          data-like-form
+          method="post"
+          action="{{ url_for('like.unlike_post' if already_liked else 'like.like_post', post_id=post.id) }}">
+        {{ form.hidden_tag() }}
+        {% if already_liked %}
+        <button type="submit" class="btn btn-icon fas fa-heart text-red" title="{{ _('Withdraw like') }}" aria-label="{{ _('Withdraw like') }}"></button>
+        {% else %}
+        <button type="submit" class="btn btn-icon far fa-heart text-red" title="{{ _('Like') }}" aria-label="{{ _('Like') }}"></button>
+        {% endif %}
+    </form>
+    {% endif %}
+</div>

like/templates/like/_like_counts.html

@@ -0,0 +1,4 @@
+<div class="like-counts" data-user-id="{{ user.id }}">
+    <div>{{ _("Likes given") }}: <span class="like-counts-given">{{ likes_given }}</span></div>
+    <div>{{ _("Likes received") }}: <span class="like-counts-received">{{ likes_received }}</span></div>
+</div>

like/templates/like/_scripts.html

@@ -0,0 +1 @@
+<script src="{{ url_for('like.static', filename='like.js') }}"></script>

like/templates/like/liked_posts.html

@@ -0,0 +1,56 @@
+{% extends theme("user/profile_layout.html") %}
+{%- from theme("_macros/pagination.html") import render_pagination %}
+
+{% block breadcrumb %}
+<ol class="breadcrumb flaskbb-breadcrumb bg-light">
+    <li class="breadcrumb-item"><a href="{{ url_for('forum.index') }}">{% trans %}Forum{% endtrans %}</a></li>
+    <li class="breadcrumb-item"><a href="{{ user.url }}">{{ user.username }}</a></li>
+    <li class="breadcrumb-item active">{{ _("Liked posts") }}</li>
+</ol>
+{% endblock %}
+
+{% block profile_content %}
+<div class="col-12 profile-content">
+
+    {% for post in posts.items %}
+    <div class="card page mb-3">
+        <div class="card-header page-header topic-header fw-normal">
+            {% trans trimmed
+                post_url=post.url,
+                topic_title=post.topic.title,
+                forum_url=post.topic.forum.url,
+                forum_title=post.topic.forum.title
+            %}
+                <strong><a href="{{ post_url }}">{{ topic_title }}</a></strong>
+                in forum <a href="{{ forum_url }}">{{ forum_title }}</a>
+            {% endtrans %}
+        </div>
+        <div class="card-body page-body topic-content">
+            <div class="col-12 ps-3">
+                <div class="topic-created">
+                    {{ post.date_created|format_datetime }}
+                </div>
+                <div class="topic-content">
+                    {{ post.content|markup }}
+                </div>
+            </div>
+        </div>
+    </div>
+    {% else %}
+    <div class="row">
+        <div class="col-12">
+            <div class="alert-message alert-message-info" role="alert">
+                {{ _("No posts liked yet") }}
+            </div>
+        </div>
+    </div>
+    {% endfor %}
+
+    {% if posts.items %}
+    <div class="col-12 controls-col">
+        {{ render_pagination(posts, url_for('like.liked_posts', username=user.username)) }}
+    </div>
+    {% endif %}
+
+</div>
+{% endblock %}

like/utils.py

@@ -0,0 +1,90 @@
+"""
+like.utils
+~~~~~~~~~~
+
+Helpers for liking/unliking a post and for counting a user's likes.
+
+:copyright: (c) 2026 by Peter Justin, (c) 2018 by Михаил Лебедев.
+:license: BSD License, see LICENSE for more details.
+"""
+
+from typing import cast
+
+from flaskbb.settings import flaskbb_config
+from flaskbb.extensions import db
+from flaskbb.forum.models import Post
+from flaskbb.user.models import User
+from sqlalchemy import func
+
+from .models import LikeUser, PostLike
+
+DEFAULT_ALLOW_SELF_LIKE = False
+
+
+def allow_self_like() -> bool:
+    # Falls back to the setting's own default when the plugin hasn't been
+    # installed yet (admin panel > Plugins > Install seeds it into the
+    # settings table).
+    value = flaskbb_config["LIKE_ALLOW_SELF_LIKE"]
+    return bool(value) if value is not None else DEFAULT_ALLOW_SELF_LIKE
+
+
+def can_like_post(user: User, post: Post) -> bool:
+    """Mirrors the old vanity plugin's ``Post.allowed_to_like`` - a post
+    can be liked if its topic and forum aren't locked, the post still has
+    a topic (it might have been orphaned by a delete), and the user shares
+    a group with the post's forum. Liking your own post is only allowed
+    when the ``LIKE_ALLOW_SELF_LIKE`` setting is on.
+    """
+    topic = post.topic
+    if topic is None or topic.locked or topic.forum.locked:
+        return False
+    if not allow_self_like() and post.user == user:
+        return False
+    forum_group_ids = {group.id for group in topic.forum.groups}
+    user_group_ids = {group.id for group in user.groups}
+    return bool(forum_group_ids & user_group_ids)
+
+
+def like_post(user: User, post: Post) -> None:
+    PostLike(post_id=post.id, user_id=user.id).save()
+
+
+def unlike_post(user: User, post: Post) -> None:
+    like = PostLike.get(PostLike.post_id == post.id, PostLike.user_id == user.id)
+    if like is not None:
+        like.delete()
+
+
+def has_liked(user: User, post: Post) -> bool:
+    like = PostLike.get(PostLike.post_id == post.id, PostLike.user_id == user.id)
+    return like is not None
+
+
+def likes_given_count(user: User) -> int:
+    return cast(LikeUser, user).likes_given
+
+
+def likes_received_count(user: User) -> int:
+    return cast(LikeUser, user).likes_received
+
+
+def recalculate_like_counts(user: User) -> User:
+    """Recomputes both counters from like_association. The counters are
+    maintained by the events in like/models.py, which cover every ORM path;
+    anything that deletes likes with raw SQL (or a stale DB from before the
+    counters existed) needs this to resync.
+    """
+    # PostLike has no `id` - its primary key is (post_id, user_id) - so
+    # CRUDMixin.count()'s default `column=cls.id` doesn't exist here.
+    counts = cast(LikeUser, user)
+    counts.likes_given = PostLike.count(
+        PostLike.user_id == user.id, column=PostLike.post_id
+    )
+    counts.likes_received = db.session.execute(
+        db.select(func.count(PostLike.post_id))
+        .join(Post, PostLike.post_id == Post.id)
+        .where(Post.user_id == user.id)
+    ).scalar_one()
+    user.save()
+    return user

like/views.py

@@ -0,0 +1,150 @@
+"""
+like.views
+~~~~~~~~~~
+
+The views for liking/unliking a post and for a user's liked-posts page.
+
+:copyright: (c) 2026 by Peter Justin, (c) 2018 by Михаил Лебедев.
+:license: BSD License, see LICENSE for more details.
+"""
+
+from flask import Blueprint, abort, flash, jsonify, redirect, request
+from flask.views import MethodView
+from flask_babelplus import gettext as _
+from flask_login import current_user, login_required
+from flaskbb.settings import flaskbb_config
+from flaskbb.extensions import db
+from flaskbb.forum.models import Forum, Post, Topic
+from flaskbb.user.models import Group, User
+from flaskbb.utils.helpers import real, register_view, render_template
+
+from .forms import LikeActionForm
+from .models import PostLike
+from .utils import (
+    can_like_post,
+    has_liked,
+    like_post,
+    likes_given_count,
+    likes_received_count,
+    unlike_post,
+)
+
+like_bp = Blueprint(
+    "like", __name__, template_folder="templates", static_folder="static"
+)
+
+
+def _is_ajax() -> bool:
+    return request.headers.get("X-Requested-With") == "XMLHttpRequest"
+
+
+def _counts_for(user: User) -> dict[str, int]:
+    return {
+        "user_id": user.id,
+        "given": likes_given_count(user),
+        "received": likes_received_count(user),
+    }
+
+
+def _like_state(post: Post, user: User):
+    """The re-rendered like widget plus the counters the (un)like changed.
+
+    Both counters are read after ``like_post``/``unlike_post`` committed, so
+    the values the after_insert/after_delete events wrote are already visible.
+    They are sent as numbers rather than markup because they live in the post
+    author sidebar - a different part of the page from the widget, and
+    possibly in several places at once if the same user has more than one post
+    on it.
+    """
+    counts = [_counts_for(user)]
+    if post.user is not None and post.user != user:
+        counts.append(_counts_for(post.user))
+    return jsonify(
+        widget=render_template(
+            "like/_like_button.html",
+            post=post,
+            can_like=can_like_post(user, post),
+            already_liked=has_liked(user, post),
+            form=LikeActionForm(),
+        ),
+        counts=counts,
+    )
+
+
+class LikePost(MethodView):
+    decorators = [login_required]
+
+    def post(self, post_id: int):
+        post = Post.get_or_404(Post.id == post_id)
+        user = real(current_user)
+
+        form = LikeActionForm()
+        if not form.validate_on_submit():
+            flash(_("Could not verify the like request, please try again."), "danger")
+            return redirect(post.url)
+
+        if has_liked(user, post) or not can_like_post(user, post):
+            abort(403)
+
+        like_post(user, post)
+        if _is_ajax():
+            return _like_state(post, user)
+        return redirect(post.url)
+
+
+class UnlikePost(MethodView):
+    decorators = [login_required]
+
+    def post(self, post_id: int):
+        post = Post.get_or_404(Post.id == post_id)
+        user = real(current_user)
+
+        form = LikeActionForm()
+        if not form.validate_on_submit():
+            flash(_("Could not verify the like request, please try again."), "danger")
+            return redirect(post.url)
+
+        if not has_liked(user, post):
+            abort(403)
+
+        unlike_post(user, post)
+        if _is_ajax():
+            return _like_state(post, user)
+        return redirect(post.url)
+
+
+class LikedPosts(MethodView):
+    def get(self, username: str):
+        page = request.args.get("page", 1, type=int)
+        user = User.get_by_or_404(username=username)
+        viewer = real(current_user)
+        group_ids = [g.id for g in viewer.groups]
+
+        stmt = (
+            db.select(Post)
+            .join(PostLike, PostLike.post_id == Post.id)
+            .join(Topic, Post.topic_id == Topic.id)
+            .join(Forum, Topic.forum_id == Forum.id)
+            .where(
+                PostLike.user_id == user.id,
+                Forum.groups.any(Group.id.in_(group_ids)),
+            )
+            .order_by(Post.id.desc())
+        )
+        posts = db.paginate(stmt, page=page, per_page=flaskbb_config["POSTS_PER_PAGE"])
+        return render_template("like/liked_posts.html", user=user, posts=posts)
+
+
+register_view(
+    like_bp, routes=["/<int:post_id>/like"], view_func=LikePost.as_view("like_post")
+)
+register_view(
+    like_bp,
+    routes=["/<int:post_id>/unlike"],
+    view_func=UnlikePost.as_view("unlike_post"),
+)
+register_view(
+    like_bp,
+    routes=["/<username>/liked-posts"],
+    view_func=LikedPosts.as_view("liked_posts"),
+)