Block incomplete profiles from commenting on events

Gate the shared Threads.PostReply RPC on event threads with
has_completed_profile (mirroring the CreateDiscussion/CreateEvent
precondition pattern), and surface ProfileIncompleteDialog on the event
comment box via an opt-in attemptedAction prop threaded EventPage ->
CommentTree -> CommentForm. Scoped to events only: discussions, groups,
and pages share the same comment components/RPC and are unaffected.

Also remove a negative top margin on the community/discussion PageHeader
that let the full-bleed map cover the push-notification banner.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: kevinortiz43

app/backend/src/couchers/i18n/locales/en.json

@@ -95,6 +95,7 @@
     "host_request_too_short2_one": "Host request cannot be shorter than {{count}} character.",
     "host_request_too_short2_other": "Host request cannot be shorter than {{count}} characters.",
     "hosting_status_required": "Hosting status is required.",
+    "incomplete_profile_comment_on_event": "You have to complete your profile before you can comment on an event.",
     "incomplete_profile_create_discussion": "You have to complete your profile before you can start a discussion.",
     "incomplete_profile_create_event": "You have to complete your profile before you can create an event.",
     "incomplete_profile_create_public_trip": "You have to complete your profile before you can create a public trip.",

app/backend/src/couchers/servicers/threads.py

@@ -9,6 +9,7 @@
 
 from couchers.context import CouchersContext, make_background_user_context, make_notification_user_context
 from couchers.db import session_scope
+from couchers.helpers.completed_profile import has_completed_profile
 from couchers.jobs.enqueue import queue_job
 from couchers.models import (
     Comment,
@@ -48,6 +49,18 @@ def unpack_thread_id(thread_id: int) -> tuple[int, int]:
     return divmod(thread_id, 10)
 
 
+def _is_event_thread(session: Session, database_id: int, depth: int) -> bool:
+    """Returns whether the given (database_id, depth) thread location belongs to an Event's thread."""
+    thread_db_id = (
+        database_id
+        if depth == 0
+        else session.execute(select(Comment.thread_id).where(Comment.id == database_id)).scalar_one_or_none()
+    )
+    if thread_db_id is None:
+        return False
+    return bool(session.execute(select(exists().where(Event.thread_id == thread_db_id))).scalar())
+
+
 def total_num_responses(session: Session, context: CouchersContext, database_id: int) -> int:
     """Return the total number of visible, non-deleted comments and replies to the thread with
     database id database_id.
@@ -385,6 +398,13 @@ def PostReply(
         if depth not in (0, 1):
             context.abort_with_error_code(grpc.StatusCode.NOT_FOUND, "thread_not_found")
 
+        if _is_event_thread(session, database_id, depth):
+            user = session.execute(select(User).where(User.id == context.user_id)).scalar_one()
+            if not has_completed_profile(session, user):
+                context.abort_with_error_code(
+                    grpc.StatusCode.FAILED_PRECONDITION, "incomplete_profile_comment_on_event"
+                )
+
         object_to_add: Comment | Reply | None = None
 
         def create_object(moderation_state_id: int) -> int:

app/backend/src/tests/test_threads.py

@@ -1,5 +1,6 @@
 import string
 import textwrap
+from datetime import timedelta
 
 import grpc
 import pytest
@@ -17,11 +18,12 @@
     User,
 )
 from couchers.models.discussions import CommentVersion, ContentChangeType, ReplyVersion
-from couchers.proto import moderation_pb2, threads_pb2
+from couchers.proto import discussions_pb2, events_pb2, moderation_pb2, threads_pb2
 from couchers.servicers.threads import pack_thread_id
-from couchers.utils import now
+from couchers.utils import Timestamp_from_datetime, now
 from tests.fixtures.db import generate_user
-from tests.fixtures.sessions import real_moderation_session, threads_session
+from tests.fixtures.sessions import discussions_session, events_session, real_moderation_session, threads_session
+from tests.test_communities import create_community
 
 
 @pytest.fixture(autouse=True)
@@ -539,6 +541,103 @@ def test_delete_reply_creates_version_record(db):
         assert v.editor_user_id == user.id
 
 
+def _create_event_and_get_thread_id(organizer, organizer_token: str) -> int:
+    """Helper: create an Event via the API, return its (packed) thread_id."""
+    with session_scope() as session:
+        create_community(session, 0, 2, "Testing Community", [organizer], [], None)
+
+    start_time = now() + timedelta(hours=2)
+    end_time = start_time + timedelta(hours=3)
+    with events_session(organizer_token) as api:
+        res = api.CreateEvent(
+            events_pb2.CreateEventReq(
+                title="Dummy event",
+                content="Dummy content.",
+                location=events_pb2.EventLocation(
+                    address="Near Null Island",
+                    lat=0.1,
+                    lng=0.2,
+                ),
+                start_time=Timestamp_from_datetime(start_time),
+                end_time=Timestamp_from_datetime(end_time),
+                timezone="UTC",
+            )
+        )
+    return int(res.thread.thread_id)
+
+
+def test_post_reply_incomplete_profile_blocked_on_event_comment(db):
+    """An incomplete-profile user cannot post a top-level comment on an event's thread."""
+    organizer, organizer_token = generate_user()
+    _commenter, commenter_token = generate_user(complete_profile=False)
+
+    event_thread_id = _create_event_and_get_thread_id(organizer, organizer_token)
+
+    with threads_session(commenter_token) as api:
+        with pytest.raises(grpc.RpcError) as e:
+            api.PostReply(threads_pb2.PostReplyReq(thread_id=event_thread_id, content="hello"))
+        assert e.value.code() == grpc.StatusCode.FAILED_PRECONDITION
+
+
+def test_post_reply_incomplete_profile_blocked_on_event_reply(db):
+    """An incomplete-profile user cannot post a nested reply within an event's thread."""
+    organizer, organizer_token = generate_user()
+    _commenter, commenter_token = generate_user()
+    _replier, replier_token = generate_user(complete_profile=False)
+
+    event_thread_id = _create_event_and_get_thread_id(organizer, organizer_token)
+
+    with threads_session(commenter_token) as api:
+        comment_thread_id = api.PostReply(
+            threads_pb2.PostReplyReq(thread_id=event_thread_id, content="top-level comment")
+        ).thread_id
+
+    with threads_session(replier_token) as api:
+        with pytest.raises(grpc.RpcError) as e:
+            api.PostReply(threads_pb2.PostReplyReq(thread_id=comment_thread_id, content="a reply"))
+        assert e.value.code() == grpc.StatusCode.FAILED_PRECONDITION
+
+
+def test_post_reply_complete_profile_allowed_on_event_comment(db):
+    """A complete-profile user can post a comment on an event's thread."""
+    organizer, organizer_token = generate_user()
+    _commenter, commenter_token = generate_user()
+
+    event_thread_id = _create_event_and_get_thread_id(organizer, organizer_token)
+
+    with threads_session(commenter_token) as api:
+        comment_thread_id = api.PostReply(
+            threads_pb2.PostReplyReq(thread_id=event_thread_id, content="hello")
+        ).thread_id
+    assert comment_thread_id
+
+
+def test_post_reply_incomplete_profile_allowed_on_non_event_thread(db):
+    """An incomplete-profile user can still comment on a non-event thread (e.g. a discussion's thread),
+    proving the gate is scoped to events only."""
+    admin, admin_token = generate_user()
+    _commenter, commenter_token = generate_user(complete_profile=False)
+
+    with session_scope() as session:
+        community_id = create_community(session, 0, 1, "Testing Community", [admin], [], None).id
+
+    with discussions_session(admin_token) as api:
+        discussion = api.CreateDiscussion(
+            discussions_pb2.CreateDiscussionReq(
+                title="A discussion",
+                content="Content",
+                owner_community_id=community_id,
+            )
+        )
+        discussion_thread_id = discussion.thread.thread_id
+
+    with threads_session(commenter_token) as api:
+        comment_thread_id = api.PostReply(
+            threads_pb2.PostReplyReq(thread_id=discussion_thread_id, content="hello")
+        ).thread_id
+    assert comment_thread_id
+
+
 def test_edit_comment_multiple_edits_creates_multiple_version_records(db):
     user, token = generate_user()
     _, comment_thread_id = _make_thread_and_comment(token, content="v1")

app/web/components/ProfileIncompleteDialog/ProfileIncompleteDialog.tsx

@@ -13,16 +13,19 @@ import Link from "next/link";
 import React from "react";
 import { howToCompleteProfileUrl, routeToEditProfile } from "routes";
 
+export type ProfileIncompleteAction =
+  | "create_event"
+  | "send_message"
+  | "send_request"
+  | "create_public_trip"
+  | "send_friend_request"
+  | "create_discussion"
+  | "comment_on_event";
+
 interface ProfileIncompleteDialogProps {
   open: boolean;
   onClose: () => void;
-  attempted_action:
-    | "create_event"
-    | "send_message"
-    | "send_request"
-    | "create_public_trip"
-    | "send_friend_request"
-    | "create_discussion";
+  attempted_action: ProfileIncompleteAction;
 }
 
 export default function ProfileIncompleteDialog({

app/web/features/communities/PageHeader.tsx

@@ -21,7 +21,6 @@ const StyledWrapper = styled("div")(({ theme }) => ({
   },
   [theme.breakpoints.up("md")]: {
     height: "16rem",
-    marginTop: theme.spacing(-2),
   },
 }));
 

app/web/features/communities/discussions/CommentForm.test.tsx

@@ -1,10 +1,12 @@
 import { render, screen, waitFor } from "@testing-library/react";
 import userEvent from "@testing-library/user-event";
 import mockRouter from "next-router-mock";
+import type { ComponentProps } from "react";
 import { discussionBaseRoute } from "routes";
 import { service } from "service";
 import wrapper from "test/hookWrapper";
 import i18n from "test/i18n";
+import { getAccountInfo } from "test/serviceMockDefaults";
 import { MockedService } from "test/utils";
 
 import CommentForm from "./CommentForm";
@@ -16,14 +18,26 @@ jest.mock("components/MarkdownInput");
 const postReplyMock = service.threads.postReply as MockedService<
   typeof service.threads.postReply
 >;
+const getAccountInfoMock = service.account.getAccountInfo as MockedService<
+  typeof service.account.getAccountInfo
+>;
 
-function renderCommentForm() {
+function renderCommentForm(
+  props: Partial<ComponentProps<typeof CommentForm>> = {},
+) {
   mockRouter.setCurrentUrl(
     `${discussionBaseRoute}/1/what-is-there-to-do-in-amsterdam`,
   );
-  render(<CommentForm threadId={999} shown={true} />, { wrapper });
+  render(<CommentForm threadId={999} shown={true} {...props} />, { wrapper });
 }
 
+beforeEach(() => {
+  // CommentForm always reads accountInfo (to gate submission when an
+  // attemptedAction is set); give it a default so tests that don't care
+  // about the gate don't hit an unmocked query.
+  getAccountInfoMock.mockImplementation(getAccountInfo);
+});
+
 describe("Comment form", () => {
   beforeAll(() => {
     jest.useFakeTimers();
@@ -96,3 +110,59 @@ describe("Comment form", () => {
     expect(postReplyMock).not.toHaveBeenCalled();
   });
 });
+
+describe("Comment form with attemptedAction (event comment gate)", () => {
+  beforeAll(() => {
+    // The "Comment form" describe above leaves fake timers active; restore
+    // real timers so `await user.type`/`user.click` resolve normally here.
+    jest.useRealTimers();
+  });
+
+  beforeEach(() => {
+    postReplyMock.mockClear();
+  });
+
+  it("shows the profile incomplete dialog instead of posting when the profile is incomplete", async () => {
+    getAccountInfoMock.mockImplementation(async () => ({
+      ...(await getAccountInfo()),
+      profileComplete: false,
+    }));
+    renderCommentForm({ attemptedAction: "comment_on_event" });
+
+    const user = userEvent.setup();
+
+    const commentInput = (await screen.findByLabelText(
+      t("communities:write_comment_a11y_label"),
+    )) as HTMLInputElement;
+    await user.type(commentInput, "This is a valid comment");
+
+    await user.click(
+      screen.getByRole("button", { name: t("communities:comment") }),
+    );
+
+    expect(
+      await screen.findByLabelText(t("profile:complete_profile_dialog.title")),
+    ).toBeVisible();
+    expect(postReplyMock).not.toHaveBeenCalled();
+  });
+
+  it("posts the comment as usual when the profile is complete", async () => {
+    renderCommentForm({ attemptedAction: "comment_on_event" });
+
+    const user = userEvent.setup();
+
+    const commentInput = (await screen.findByLabelText(
+      t("communities:write_comment_a11y_label"),
+    )) as HTMLInputElement;
+    await user.type(commentInput, "This is a valid comment");
+
+    await user.click(
+      screen.getByRole("button", { name: t("communities:comment") }),
+    );
+
+    await waitFor(() => expect(postReplyMock).toHaveBeenCalledTimes(1));
+    expect(
+      screen.queryByLabelText(t("profile:complete_profile_dialog.title")),
+    ).not.toBeInTheDocument();
+  });
+});

app/web/features/communities/discussions/CommentForm.tsx

@@ -4,10 +4,14 @@ import { useMutation, useQueryClient } from "@tanstack/react-query";
 import Alert from "components/Alert";
 import Button from "components/Button";
 import MarkdownInput, { MarkdownInputProps } from "components/MarkdownInput";
+import ProfileIncompleteDialog, {
+  ProfileIncompleteAction,
+} from "components/ProfileIncompleteDialog/ProfileIncompleteDialog";
+import useAccountInfo from "features/auth/useAccountInfo";
 import { RpcError } from "grpc-web";
 import { useTranslation } from "i18n";
 import { COMMUNITIES, GLOBAL } from "i18n/namespaces";
-import React, { useRef } from "react";
+import React, { useRef, useState } from "react";
 import { useForm } from "react-hook-form";
 import { service } from "service";
 import { theme } from "theme";
@@ -33,6 +37,7 @@ const StyledButtonsContainer = styled("div")(() => ({
 }));
 
 interface CommentFormProps {
+  attemptedAction?: ProfileIncompleteAction;
   hideable?: boolean;
   onClose?(): void;
   shown?: boolean;
@@ -44,10 +49,23 @@ interface CommentData {
 }
 
 function InternalCommentForm(
-  { hideable = false, onClose, shown = false, threadId }: CommentFormProps,
+  {
+    attemptedAction,
+    hideable = false,
+    onClose,
+    shown = false,
+    threadId,
+  }: CommentFormProps,
   ref: React.ForwardedRef<HTMLFormElement>,
 ) {
   const { t } = useTranslation([GLOBAL, COMMUNITIES]);
+  const { data: accountInfo } = useAccountInfo();
+  const [profileDialogOpen, setProfileDialogOpen] = useState(false);
+  // Opt-in gate: only enforced when a caller passes attemptedAction (currently
+  // only the event comment box). Discussions/groups/pages leave it undefined
+  // and are unaffected.
+  const profileIncomplete =
+    attemptedAction !== undefined && accountInfo?.profileComplete === false;
   const {
     control,
     handleSubmit,
@@ -75,6 +93,11 @@ function InternalCommentForm(
   });
 
   const onSubmit = handleSubmit((data) => {
+    if (profileIncomplete) {
+      setProfileDialogOpen(true);
+      return;
+    }
+
     const trimmedValue = data.content.trim();
     const newData = {
       content: trimmedValue,
@@ -85,6 +108,13 @@ function InternalCommentForm(
 
   return (
     <Collapse data-testid={`comment-${threadId}-comment-form`} in={shown}>
+      {attemptedAction && (
+        <ProfileIncompleteDialog
+          open={profileDialogOpen}
+          onClose={() => setProfileDialogOpen(false)}
+          attempted_action={attemptedAction}
+        />
+      )}
       <StyledForm onSubmit={onSubmit} ref={ref}>
         {error && <Alert severity="error">{error.message}</Alert>}
         <span style={visuallyHidden} id={`comment-${threadId}-reply-label`}>