Community board: downvotes, familiar vote labels, UI polish

- Voting now works like Reddit. Each user has one vote per post, up (+1)
  or down (-1). Casting the same vote again clears it, and the opposite
  vote switches it.
- CommunityVote gains a value column, and CommunityPost gains
  downvote_count and score. Score is up minus down and drives the Top
  sort. On first boot add_community backfills existing votes as upvotes.
- Only upvotes carry over when a duplicate is merged, and only upvoters
  get the "fixed" notification.
- Vote labels: questions, features, feedback and announcements use
  Upvote / Downvote. Bugs use Me too / Can't reproduce.
- List cards get an up/down vote rail with the score and vote in place,
  so the post doesn't have to be opened. The post page gets a labelled
  vote bar with separate counts.
- UI polish:
  - header card
  - Active / New / Top tabs
  - flair chips that scroll sideways on phones
  - "Before you post" sidebar
  - flair colour accents on cards and posts
  - per-name avatar colours
  - numbered bug steps
  - Expected / Actual boxes edged green and red
  - flair picker cards with descriptions in the new-post form
  - refreshed admin and notification pages
- Mobile fixes: the page no longer scrolls sideways at 375px, vote
  buttons stay on one line, and screenshots sit side by side.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: Manishrdy

database/models.py

@@ -1321,7 +1321,9 @@ class CommunityPost(db.Model):
     # True while the latest word on the thread is not an admin's
     needs_admin = db.Column(db.Boolean, nullable=False, default=True, index=True)
 
-    vote_count = db.Column(db.Integer, nullable=False, default=0)
+    vote_count = db.Column(db.Integer, nullable=False, default=0)       # upvotes
+    downvote_count = db.Column(db.Integer, nullable=False, default=0)
+    score = db.Column(db.Integer, nullable=False, default=0, index=True)  # up - down, drives "Top"
     comment_count = db.Column(db.Integer, nullable=False, default=0)
 
     created_at = db.Column(db.DateTime, nullable=False, default=datetime.utcnow, index=True)
@@ -1365,12 +1367,13 @@ class CommunityComment(db.Model):
 
 
 class CommunityVote(db.Model):
-    """One "me too" / "I want this" per user per post."""
+    """One vote per user per post: +1 (upvote / "Me too") or -1 (downvote)."""
     __tablename__ = 'community_votes'
 
     id = db.Column(db.Integer, primary_key=True)
     post_id = db.Column(db.Integer, db.ForeignKey('community_posts.id', ondelete='CASCADE'), nullable=False, index=True)
     user_id = db.Column(db.String(120), db.ForeignKey('users.id', ondelete='CASCADE'), nullable=False, index=True)
+    value = db.Column(db.Integer, nullable=False, default=1)
     created_at = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
 
     __table_args__ = (

migrations/add_community.py

@@ -63,6 +63,8 @@ def run_migration(db, app):
                 conn.execute(text("ALTER TABLE users ADD COLUMN community_muted_until DATETIME"))
                 print("[Migration] add_community: added users.community_muted_until.")
 
+            had_score = (conn.dialect.has_table(conn, "community_posts")
+                         and "score" in _columns(conn, "community_posts"))
             for name in COMMUNITY_MODELS:
                 table = getattr(models, name).__table__
                 if not conn.dialect.has_table(conn, table.name):
@@ -73,6 +75,16 @@ def run_migration(db, app):
                     for index in table.indexes:
                         index.create(bind=conn, checkfirst=True)
 
+            if not had_score:
+                # Downvotes arrived after the first release: every existing
+                # vote is an upvote (value defaulted to 1); derive the counters.
+                conn.execute(text("""
+                    UPDATE community_posts SET
+                        vote_count = (SELECT COUNT(*) FROM community_votes v WHERE v.post_id = community_posts.id AND v.value > 0),
+                        downvote_count = (SELECT COUNT(*) FROM community_votes v WHERE v.post_id = community_posts.id AND v.value < 0)
+                """))
+                conn.execute(text("UPDATE community_posts SET score = vote_count - downvote_count"))
+
             if ensure_fts(conn):
                 print("[Migration] add_community: created community_posts_fts.")
 

routes/community_routes.py

@@ -6,6 +6,7 @@
 from __future__ import annotations
 
 import re
+import zlib
 from datetime import datetime
 
 from markupsafe import Markup, escape
@@ -61,6 +62,7 @@ def time_ago(iso) -> str:
 def register_community_routes(app, *, db=db, limiter=None):
     app.jinja_env.filters["cm_linkify"] = linkify
     app.jinja_env.filters["cm_ago"] = time_ago
+    app.jinja_env.filters["cm_hue"] = lambda name: zlib.crc32((name or "").encode()) % 360
 
     def limit(rule):
         if limiter is None:
@@ -81,10 +83,11 @@ def community_index():
             "q": (args.get("q") or "").strip()[:100] or None,
         }
         pinned, posts, next_cursor = cs.list_posts(current_user, cursor=args.get("cursor"), **filters)
+        votes = cs.my_votes(pinned + posts, current_user)
         return render_template(
             "community/index.html",
-            pinned=[cs.serialize_post(p, current_user) for p in pinned],
-            posts=[cs.serialize_post(p, current_user) for p in posts],
+            pinned=[cs.serialize_post(p, current_user, vote=votes.get(p.id, 0)) for p in pinned],
+            posts=[cs.serialize_post(p, current_user, vote=votes.get(p.id, 0)) for p in posts],
             next_cursor=next_cursor, filters=filters,
             flairs=cs.FLAIRS, statuses=cs.STATUSES,
             block=cs.posting_block_reason(current_user),
@@ -205,13 +208,17 @@ def community_api_delete(public_id):
     @login_required
     @limit("60 per minute")
     def community_api_vote(public_id):
+        try:
+            value = int(_json_body().get("value", 1))
+        except (TypeError, ValueError):
+            return jsonify({"error": "Vote must be up or down."}), 400
         try:
             post = cs.get_visible_post(public_id, current_user)
-            voted, count = cs.toggle_vote(post, current_user)
+            mine = cs.cast_vote(post, current_user, value)
         except cs.CommunityError as exc:
             db.session.rollback()
             return _error(exc)
-        return jsonify({"voted": voted, "vote_count": count})
+        return jsonify({"vote": mine, "up": post.vote_count, "down": post.downvote_count, "score": post.score})
 
     @app.route("/api/community/similar")
     @login_required

services/community_service.py

@@ -38,12 +38,18 @@
 
 # ── Vocabulary ────────────────────────────────────────────────────────────────
 
+# vote_label / down_label name what an upvote / downvote means for the flair.
 FLAIRS = {
-    "bug":          {"label": "Bug",             "vote_label": "Me too",        "icon": "fa-bug"},
-    "question":     {"label": "Question",        "vote_label": "Same question", "icon": "fa-circle-question"},
-    "feature":      {"label": "Feature request", "vote_label": "I want this",   "icon": "fa-lightbulb"},
-    "feedback":     {"label": "Feedback",        "vote_label": "Agree",         "icon": "fa-comment-dots"},
-    "announcement": {"label": "Announcement",    "vote_label": "Noted",         "icon": "fa-bullhorn", "admin_only": True},
+    "bug":          {"label": "Bug",             "vote_label": "Me too",   "down_label": "Can't reproduce",
+                     "icon": "fa-bug", "hint": "Something is broken or behaves wrongly"},
+    "question":     {"label": "Question",        "vote_label": "Upvote",   "down_label": "Downvote",
+                     "icon": "fa-circle-question", "hint": "Ask how something works"},
+    "feature":      {"label": "Feature request", "vote_label": "Upvote",   "down_label": "Downvote",
+                     "icon": "fa-lightbulb", "hint": "Suggest something new or better"},
+    "feedback":     {"label": "Feedback",        "vote_label": "Upvote",   "down_label": "Downvote",
+                     "icon": "fa-comment-dots", "hint": "Share what you like or don't"},
+    "announcement": {"label": "Announcement",    "vote_label": "Upvote",   "down_label": "Downvote",
+                     "icon": "fa-bullhorn", "hint": "News from the team", "admin_only": True},
 }
 
 STATUSES = {
@@ -405,11 +411,19 @@ def restore_post(post: CommunityPost) -> None:
 # ── Votes ─────────────────────────────────────────────────────────────────────
 
 def _recount_votes(post: CommunityPost) -> int:
-    post.vote_count = db.session.query(func.count(CommunityVote.id)).filter_by(post_id=post.id).scalar() or 0
-    return post.vote_count
-
-
-def toggle_vote(post: CommunityPost, user) -> tuple[bool, int]:
+    rows = dict(db.session.query(CommunityVote.value, func.count(CommunityVote.id))
+                .filter_by(post_id=post.id).group_by(CommunityVote.value).all())
+    post.vote_count = rows.get(1, 0)
+    post.downvote_count = rows.get(-1, 0)
+    post.score = post.vote_count - post.downvote_count
+    return post.score
+
+
+def cast_vote(post: CommunityPost, user, value: int = 1) -> int:
+    """Reddit-style: +1 / -1; repeating your current vote clears it, the
+    opposite vote switches it. Returns the user's vote afterwards (1, -1, 0)."""
+    if value not in (1, -1):
+        raise CommunityError("Vote must be up or down.")
     require_can_write(user, voting=True)
     if post.author_id == user.id:
         raise CommunityError("You can't vote on your own post.", code="own_post")
@@ -418,24 +432,37 @@ def toggle_vote(post: CommunityPost, user) -> tuple[bool, int]:
     if post.deleted_at is not None or post.status == "duplicate":
         raise CommunityError("Voting is closed on this post.", code="closed")
     existing = CommunityVote.query.filter_by(post_id=post.id, user_id=user.id).first()
-    if existing:
+    if existing is not None and existing.value == value:
         db.session.delete(existing)
-        voted = False
+        mine = 0
+    elif existing is not None:
+        existing.value = value
+        mine = value
     else:
-        db.session.add(CommunityVote(post_id=post.id, user_id=user.id))
-        voted = True
+        db.session.add(CommunityVote(post_id=post.id, user_id=user.id, value=value))
+        mine = value
     try:
         db.session.flush()
     except IntegrityError:  # double-click race: the other request won
         db.session.rollback()
-        voted = True
-    count = _recount_votes(post)
+        mine = my_vote(post, user)
+    _recount_votes(post)
     db.session.commit()
-    return voted, count
+    return mine
 
 
-def has_voted(post: CommunityPost, user) -> bool:
-    return CommunityVote.query.filter_by(post_id=post.id, user_id=user.id).first() is not None
+def my_vote(post: CommunityPost, user) -> int:
+    vote = CommunityVote.query.filter_by(post_id=post.id, user_id=user.id).first()
+    return vote.value if vote is not None else 0
+
+
+def my_votes(posts, user) -> dict[int, int]:
+    """post id -> the user's vote, for a list page in one query."""
+    ids = [p.id for p in posts]
+    if not ids:
+        return {}
+    return dict(db.session.query(CommunityVote.post_id, CommunityVote.value)
+                .filter(CommunityVote.user_id == user.id, CommunityVote.post_id.in_(ids)).all())
 
 
 # ── Comments ──────────────────────────────────────────────────────────────────
@@ -571,7 +598,7 @@ def set_status(post: CommunityPost, admin, status: str) -> None:
     label = STATUSES[status]
     _notify(post.author_id, "status_change", post, actor=admin, detail=label)
     if status == "fixed":
-        voter_ids = [v.user_id for v in CommunityVote.query.filter_by(post_id=post.id).all()]
+        voter_ids = [v.user_id for v in CommunityVote.query.filter_by(post_id=post.id, value=1).all()]
         for uid in voter_ids:
             if uid != post.author_id:
                 _notify(uid, "status_change", post, actor=admin, detail=label)
@@ -602,15 +629,16 @@ def mark_duplicate(post: CommunityPost, admin, target_public_id: str) -> Communi
     if target.duplicate_of_id == post.id:
         raise CommunityError("That post is already a duplicate of this one.")
     # Move votes (and the duplicate's author, who clearly has the issue too).
-    carriers = {v.user_id for v in CommunityVote.query.filter_by(post_id=post.id).all()}
+    # Upvotes ("me too") carry over; downvotes on the duplicate don't.
+    carriers = {v.user_id for v in CommunityVote.query.filter_by(post_id=post.id, value=1).all()}
     if post.author_id:
         carriers.add(post.author_id)
     already = {v.user_id for v in CommunityVote.query.filter_by(post_id=target.id).all()}
     for uid in carriers - already - {target.author_id}:
-        db.session.add(CommunityVote(post_id=target.id, user_id=uid))
+        db.session.add(CommunityVote(post_id=target.id, user_id=uid, value=1))
     CommunityVote.query.filter_by(post_id=post.id).delete()
     post.duplicate_of_id = target.id
-    post.vote_count = 0
+    post.vote_count = post.downvote_count = post.score = 0
     db.session.flush()
     _recount_votes(target)
     set_status(post, admin, "duplicate")  # commits
@@ -667,7 +695,7 @@ def resolve_report(report: CommunityReport, admin, resolution: str) -> None:
 
 # ── Listing ───────────────────────────────────────────────────────────────────
 
-SORTS = {"active": CommunityPost.last_activity_at, "new": CommunityPost.created_at, "top": CommunityPost.vote_count}
+SORTS = {"active": CommunityPost.last_activity_at, "new": CommunityPost.created_at, "top": CommunityPost.score}
 
 
 def _visible_query(viewer, *, include_deleted=False):
@@ -821,13 +849,24 @@ def image_urls(img: CommunityImage) -> dict:
     }
 
 
-def serialize_post(post: CommunityPost, viewer, *, detail=False) -> dict:
+def can_vote(post: CommunityPost, viewer) -> bool:
+    return (post.author_id != viewer.id and post.deleted_at is None and post.status != "duplicate"
+            and post.visibility == "public")
+
+
+def serialize_post(post: CommunityPost, viewer, *, detail=False, vote=None) -> dict:
+    """``vote`` is the viewer's vote when the caller already knows it (list
+    pages batch it via my_votes); otherwise it is looked up for detail views."""
     flair = FLAIRS.get(post.flair, FLAIRS["question"])
     admin = is_admin(viewer)
+    if vote is None and detail:
+        vote = my_vote(post, viewer)
     data = {
         "id": post.public_id,
         "flair": post.flair, "flair_label": flair["label"], "flair_icon": flair["icon"],
-        "vote_label": flair["vote_label"],
+        "vote_label": flair["vote_label"], "down_label": flair["down_label"],
+        "downvote_count": post.downvote_count, "score": post.score,
+        "my_vote": vote or 0, "can_vote": can_vote(post, viewer),
         "title": post.title,
         "status": post.status, "status_label": STATUSES.get(post.status, post.status),
         "visibility": post.visibility,
@@ -848,14 +887,13 @@ def serialize_post(post: CommunityPost, viewer, *, detail=False) -> dict:
             "match_format": post.match_format,
             "match_format_label": BUG_FORMATS.get(post.match_format or "", None),
             "images": [image_urls(i) for i in post.images if i.purged_at is None or admin],
-            "voted": has_voted(post, viewer),
+            "voted": vote == 1,
             "duplicate_of": None,
             "can": {
                 "edit": can_edit_post(post, viewer),
                 "delete": admin or post.author_id == viewer.id,
                 "comment": can_comment(post, viewer),
-                "vote": (post.author_id != viewer.id and post.deleted_at is None and post.status != "duplicate"
-                         and post.visibility == "public"),
+                "vote": can_vote(post, viewer),
                 "moderate": admin,
             },
         })
@@ -924,7 +962,7 @@ def admin_queues(limit=50) -> dict:
         "private": live.filter(CommunityPost.visibility == "private", CommunityPost.needs_admin.is_(True))
                        .order_by(CommunityPost.last_activity_at.asc()).limit(limit).all(),
         "unanswered": live.filter(CommunityPost.visibility == "public", CommunityPost.needs_admin.is_(True))
-                          .order_by(CommunityPost.vote_count.desc(), CommunityPost.created_at.asc()).limit(limit).all(),
+                          .order_by(CommunityPost.score.desc(), CommunityPost.created_at.asc()).limit(limit).all(),
         "reports": CommunityReport.query.filter(CommunityReport.resolved_at.is_(None))
                                         .order_by(CommunityReport.created_at.asc()).limit(limit).all(),
         "deleted": CommunityPost.query.filter(CommunityPost.deleted_at.isnot(None))