Simple comments feed

comments/constants.py

@@ -4,3 +4,10 @@
 class CommentReportType(models.TextChoices):
     SPAM = "spam"
     VIOLATION = "violation"
+
+
+class TimeWindow(models.TextChoices):
+    ALL_TIME = "all_time"
+    PAST_WEEK = "past_week"
+    PAST_MONTH = "past_month"
+    PAST_YEAR = "past_year"

comments/migrations/0024_add_denormalized_fields.py

@@ -3,7 +3,50 @@
 import django.contrib.postgres.indexes
 import django.contrib.postgres.search
 from django.conf import settings
-from django.db import migrations, models
+from django.db import connection, migrations, models
+
+
+def backfill_vote_score(apps, schema_editor):
+    with connection.cursor() as cursor:
+        cursor.execute("""
+            UPDATE comments_comment c
+            SET vote_score = COALESCE(sub.score, 0)
+            FROM (
+                SELECT comment_id, SUM(direction) AS score
+                FROM comments_commentvote
+                GROUP BY comment_id
+            ) sub
+            WHERE c.id = sub.comment_id
+        """)
+        print(f"\n  vote_score: {cursor.rowcount} rows updated")
+
+
+def backfill_cmm_count(apps, schema_editor):
+    with connection.cursor() as cursor:
+        cursor.execute("""
+            UPDATE comments_comment c
+            SET cmm_count = sub.cnt
+            FROM (
+                SELECT comment_id, COUNT(*) AS cnt
+                FROM comments_changedmymindentry
+                GROUP BY comment_id
+            ) sub
+            WHERE c.id = sub.comment_id
+        """)
+        print(f"\n  cmm_count: {cursor.rowcount} rows updated")
+
+
+def backfill_text_original_search_vector(apps, schema_editor):
+    with connection.cursor() as cursor:
+        cursor.execute("""
+                       UPDATE comments_comment
+                       SET text_original_search_vector = to_tsvector('english', COALESCE(text_original, ''))
+                       WHERE text_original IS NOT NULL
+                         AND text_original != ''
+                         AND is_private = false
+                         AND is_soft_deleted = false
+                       """)
+        print(f"\n  text_original_search_vector: {cursor.rowcount} rows updated")
 
 
 class Migration(migrations.Migration):
@@ -45,4 +88,9 @@ class Migration(migrations.Migration):
                 name="comment_text_search_vector_idx",
             ),
         ),
+        migrations.RunPython(backfill_vote_score, migrations.RunPython.noop),
+        migrations.RunPython(backfill_cmm_count, migrations.RunPython.noop),
+        migrations.RunPython(
+            backfill_text_original_search_vector, migrations.RunPython.noop
+        ),
     ]

comments/models.py

@@ -18,7 +18,6 @@
 from django.db.models.functions import Coalesce
 from django.db.models.lookups import Exact
 from django.utils import timezone
-from sql_util.aggregates import SubqueryAggregate
 
 from posts.models import Post
 from projects.models import Project
@@ -28,15 +27,6 @@
 
 
 class CommentQuerySet(models.QuerySet):
-    def annotate_vote_score(self):
-        return self.annotate(
-            annotated_vote_score=Coalesce(
-                SubqueryAggregate("comment_votes__direction", aggregate=Sum),
-                0,
-                output_field=IntegerField(),
-            )
-        )
-
     def annotate_user_vote(self, user: User):
         """
         Annotates queryset with the user's vote option
@@ -180,12 +170,14 @@ def update_vote_score(self):
         ]
         self.vote_score = score
         self.save(update_fields=["vote_score"])
+
         return score
 
     def update_cmm_count(self):
         count = self.changedmymindentry_set.count()
         self.cmm_count = count
         self.save(update_fields=["cmm_count"])
+
         return count
 
 

comments/serializers/common.py

@@ -5,6 +5,7 @@
 from rest_framework import serializers
 from rest_framework.exceptions import ValidationError
 
+from comments.constants import TimeWindow
 from comments.models import Comment, KeyFactor, CommentsOfTheWeekEntry
 from comments.utils import comments_extract_user_mentions_mapping
 from posts.models import Post
@@ -27,13 +28,33 @@ class CommentFilterSerializer(serializers.Serializer):
     is_private = serializers.BooleanField(required=False, allow_null=True)
     include_deleted = serializers.BooleanField(required=False, allow_null=True)
     last_viewed_at = serializers.DateTimeField(required=False, allow_null=True)
+    time_window = serializers.ChoiceField(
+        choices=TimeWindow.choices,
+        required=False,
+        allow_null=True,
+    )
+    search = serializers.CharField(required=False, allow_null=True, min_length=3)
+    exclude_bots = serializers.BooleanField(required=False, default=False)
+    post_status = serializers.ChoiceField(
+        choices=Post.CurationStatus.choices,
+        required=False,
+        allow_null=True,
+    )
 
     def validate_post(self, value: int):
         try:
             return Post.objects.get(pk=value)
         except Post.DoesNotExist:
             raise ValidationError("Post Does not exist")
 
+    def validate(self, attrs):
+        sort = attrs.get("sort")
+        search = attrs.get("search")
+        if sort == "relevance" and not search:
+            raise ValidationError({"sort": "Relevance sort requires a search query."})
+
+        return attrs
+
 
 class CommentSerializer(serializers.ModelSerializer):
     author = BaseUserSerializer()
@@ -196,8 +217,6 @@ def serialize_comment_many(
     qs = qs.select_related(
         "included_forecast__question", "author", "on_post"
     ).prefetch_related("key_factors")
-    qs = qs.annotate_vote_score()
-
     if current_user:
         qs = qs.annotate_user_vote(current_user)
 

comments/services/common.py

@@ -1,7 +1,7 @@
 import datetime
 import difflib
 
-from django.db import transaction
+from django.db import IntegrityError, transaction
 from django.db.models import (
     F,
     Sum,
@@ -267,6 +267,40 @@ def compute_comment_score(
     return score
 
 
+def vote_comment(comment: Comment, user: User, direction: int | None) -> int:
+    try:
+        with transaction.atomic():
+            CommentVote.objects.filter(user=user, comment=comment).delete()
+
+            if direction:
+                CommentVote.objects.create(
+                    user=user, comment=comment, direction=direction
+                )
+    except IntegrityError:
+        pass
+
+    return comment.update_vote_score()
+
+
+def toggle_cmm(comment: Comment, user: User, enabled: bool) -> bool | None:
+    """Returns True if created, False if deleted, None if no-op."""
+    try:
+        with transaction.atomic():
+            cmm = ChangedMyMindEntry.objects.filter(user=user, comment=comment)
+
+            if not enabled and cmm.exists():
+                cmm.delete()
+                comment.update_cmm_count()
+                return False
+
+            if enabled and not cmm.exists():
+                ChangedMyMindEntry.objects.create(user=user, comment=comment)
+                comment.update_cmm_count()
+                return True
+    except IntegrityError:
+        pass
+
+
 def set_comment_excluded_from_week_top(comment: Comment, excluded: bool = True):
     entry = comment.comments_of_the_week_entry
     if entry:

comments/services/feed.py

@@ -1,8 +1,18 @@
-from datetime import datetime
+from datetime import datetime, timedelta
 
-from django.db.models import Q, Case, When, Value, IntegerField, Exists, OuterRef
+from django.contrib.postgres.search import SearchQuery, SearchRank
+from django.db.models import F, Q, Case, When, Value, IntegerField, Exists, OuterRef
+from django.utils import timezone
 
+from comments.constants import TimeWindow
 from comments.models import Comment
+from posts.models import Post
+
+TIME_WINDOW_DELTAS = {
+    TimeWindow.PAST_WEEK: timedelta(days=7),
+    TimeWindow.PAST_MONTH: timedelta(days=30),
+    TimeWindow.PAST_YEAR: timedelta(days=365),
+}
 
 
 def get_comments_feed(
@@ -15,16 +25,19 @@ def get_comments_feed(
     sort=None,
     is_private=None,
     focus_comment_id: int = None,
-    include_deleted=False,
+    include_deleted: bool | None = None,
     last_viewed_at: datetime = None,
+    time_window: str = None,
+    search: str = None,
+    exclude_bots: bool = False,
+    post_status: Post.CurationStatus | None = None,
 ):
     user = user if user and user.is_authenticated else None
     sort = sort or "-created_at"
     order_by_args = []
 
-    # Require at least one filter
-    if not post and not author and not (is_private and user):
-        return qs.none()
+    if post_status:
+        qs = qs.filter(on_post__curation_status=post_status)
 
     if parent_isnull is not None:
         qs = qs.filter(parent=None)
@@ -83,14 +96,34 @@ def get_comments_feed(
     else:
         qs = qs.filter(is_private=False)
 
-    if not include_deleted:
+    if exclude_bots:
+        qs = qs.filter(author__is_bot=False)
+
+    if include_deleted is None:
         qs = qs.filter(
             Q(is_soft_deleted=False)
             | Exists(
                 Comment.objects.filter(parent_id=OuterRef("pk"), is_soft_deleted=False)
             )
         )
 
+    if include_deleted is False:
+        qs = qs.filter(is_soft_deleted=False)
+
+    # Time window filter
+    if time_window and time_window in TIME_WINDOW_DELTAS:
+        cutoff = timezone.now() - TIME_WINDOW_DELTAS[time_window]
+        qs = qs.filter(created_at__gte=cutoff)
+
+    # Full-text search using stored search vector
+    if search:
+        query = SearchQuery(search, search_type="websearch", config="english")
+        qs = qs.filter(text_original_search_vector=query)
+        if sort == "relevance":
+            qs = qs.annotate(
+                search_rank=SearchRank(F("text_original_search_vector"), query)
+            )
+
     # Filter comments located under Posts current user is allowed to see
     qs = qs.filter_by_user_permission(user=user)
 
@@ -124,11 +157,10 @@ def get_comments_feed(
             order_by_args.insert(pinned_idx, "-is_focused_comment")
 
     if sort:
-        if "vote_score" in sort:
-            qs = qs.annotate_vote_score()
-            sort = sort.replace("vote_score", "annotated_vote_score")
-
-        order_by_args.append(sort)
+        if sort == "relevance":
+            order_by_args.append("-search_rank")
+        else:
+            order_by_args.append(sort)
 
     if order_by_args:
         qs = qs.order_by(*order_by_args)