Files
Evection/apps/reader/views.py
T
ksmithandClaude Sonnet 5 753ae9efc7 Make Starred and Saved-for-later pre-configured system tags
UserArticleState.is_starred/is_saved_for_later/starred_at are gone —
starring and saving now add/remove an ArticleTag against a per-user
"Starred" / "Saved for later" Tag, created lazily on first use and marked
Tag.is_system=True. is_read/is_hidden stay on UserArticleState since
they're genuine reading state, not categorization, which is what made
these two candidates for unifying into the general tag mechanism.

System tags are excluded from the Manage Tags page and from delete_tag
(get_object_or_404 now requires is_system=False, so attempting to delete
one 404s) and from the subscription-tag autocomplete, since they
categorize articles, not feeds. The star/save icons are still exactly
where they were — this only changes what powers them.

apps.rules.engine's star action now does get_system_tag + ArticleTag.
get_or_create instead of setting a boolean field. A data migration
converts every existing is_starred=True/is_saved_for_later=True row into
its ArticleTag equivalent before the fields are dropped — verified by
seeding the pre-removal schema directly (including a row with both flags
set) and confirming the migration produces the right tags.

apps.articles.queries.with_user_state gained one more query (tag lookup
for the current page's articles) to stay in the same "fixed number of
queries regardless of article count" shape it already had.

Verified end to end against a running dev server: toggling star/saved,
the starred/saved filters, the sidebar's Favourites count, and that the
Starred tag doesn't appear on the Manage Tags page.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-10-30 21:36:44 -06:00

290 lines
10 KiB
Python

from itertools import groupby
from django.contrib.auth.decorators import login_required
from django.db.models import Q
from django.http import Http404
from django.shortcuts import get_object_or_404, redirect, render
from django.urls import reverse
from django.utils import timezone
from django.views.decorators.http import require_POST
from apps.articles.models import (
SAVED_TAG_NAME,
STARRED_TAG_NAME,
Article,
ArticleTag,
Tag,
UserArticleState,
get_system_tag,
)
from apps.articles.queries import with_user_state
from apps.feeds.models import Feed
FILTER_CHOICES = [
("unread", "Unread"),
("all", "All"),
("starred", "Starred"),
("saved", "Saved"),
]
VALID_FILTERS = {key for key, _ in FILTER_CHOICES}
PAGE_SIZE = 30
def _base_queryset(user):
"""Articles from the user's subscriptions, with rule-hidden articles
excluded regardless of which filter tab is active."""
return (
Article.objects.filter(feed__subscriptions__user=user)
.exclude(user_states__user=user, user_states__is_hidden=True)
.select_related("feed")
)
def _get_or_create_state(user, article):
state, _ = UserArticleState.objects.get_or_create(user=user, article=article)
return state
def _article_tag_flags(user, article):
"""is_starred/is_saved_for_later for a single article — the toggle
views' equivalent of with_user_state's bulk version."""
tag_names = set(
ArticleTag.objects.filter(
user=user,
article=article,
tag__is_system=True,
tag__name__in=[STARRED_TAG_NAME, SAVED_TAG_NAME],
).values_list("tag__name", flat=True)
)
return STARRED_TAG_NAME in tag_names, SAVED_TAG_NAME in tag_names
def _apply_scope(request, queryset):
"""Narrows an already-base-scoped Article queryset by the optional
?tag=/?feed= params the sidebar links use. feed_id alone is enough to
scope by feed (the base queryset already restricts to the user's own
subscriptions)."""
active_tag = None
tag_id = request.GET.get("tag")
if tag_id:
active_tag = Tag.objects.filter(user=request.user, pk=tag_id).first()
if active_tag:
# A tag matches an article either directly (ArticleTag) or by
# the article's feed being tagged via the user's Subscription
# (SubscriptionTag) — tagging a whole feed surfaces all of its
# articles under that tag, not just individually-tagged ones.
queryset = queryset.filter(
Q(article_tags__user=request.user, article_tags__tag=active_tag)
| Q(
feed__subscriptions__user=request.user,
feed__subscriptions__subscription_tags__user=request.user,
feed__subscriptions__subscription_tags__tag=active_tag,
)
).distinct()
active_feed = None
feed_id = request.GET.get("feed")
if feed_id:
active_feed = Feed.objects.filter(pk=feed_id, subscriptions__user=request.user).first()
if active_feed:
queryset = queryset.filter(feed_id=active_feed.pk)
return queryset, active_tag, active_feed
def _date_label(day, today):
if day is None:
return "Undated"
diff = (today - day).days
if diff == 0:
return f"Received today — {day.strftime('%-d %B %Y')}"
if diff == 1:
return f"Received yesterday — {day.strftime('%-d %B %Y')}"
return f"Received {day.strftime('%-d %B %Y')}"
def _group_by_date(articles):
"""Articles are already ordered newest-first (Article.Meta.ordering),
so same-day articles are contiguous and groupby doesn't need a sort."""
today = timezone.localdate()
def day_of(article):
return timezone.localtime(article.published_at).date() if article.published_at else None
return [
{"label": _date_label(day, today), "articles": list(items)}
for day, items in groupby(articles, key=day_of)
]
@login_required
def stream(request):
requested_filter = request.GET.get("filter")
if requested_filter in VALID_FILTERS:
active_filter = requested_filter
else:
# No (valid) filter in the URL — e.g. a sidebar feed/folder/tag
# link, or just "/" — falls back to whatever the user last had
# selected, rather than always resetting to "unread".
active_filter = request.session.get("stream_filter", "unread")
request.session["stream_filter"] = active_filter
queryset = _base_queryset(request.user)
if active_filter == "unread":
queryset = queryset.exclude(user_states__user=request.user, user_states__is_read=True)
elif active_filter == "starred":
queryset = queryset.filter(
article_tags__user=request.user,
article_tags__tag__user=request.user,
article_tags__tag__name=STARRED_TAG_NAME,
article_tags__tag__is_system=True,
)
elif active_filter == "saved":
queryset = queryset.filter(
article_tags__user=request.user,
article_tags__tag__user=request.user,
article_tags__tag__name=SAVED_TAG_NAME,
article_tags__tag__is_system=True,
)
queryset, active_tag, active_feed = _apply_scope(request, queryset)
try:
page = max(int(request.GET.get("page", 1)), 1)
except ValueError:
page = 1
start, end = (page - 1) * PAGE_SIZE, page * PAGE_SIZE
total_count = queryset.count()
articles = with_user_state(queryset[start:end], request.user)
context = {
"date_groups": _group_by_date(articles),
"active_filter": active_filter,
"filters": FILTER_CHOICES,
"active_tag": active_tag,
"active_feed": active_feed,
"user_tags": Tag.objects.filter(user=request.user),
"page": page,
"has_next_page": end < total_count,
"has_previous_page": page > 1,
}
return render(request, "reader/stream.html", context)
@login_required
@require_POST
def mark_all_read(request):
"""Marks every unread article currently matching the stream's filter
scope (tag included, "unread"/"all" filter excluded since it's a no-op
choice here) as read — bulk, not one UserArticleState per article."""
queryset = _base_queryset(request.user)
queryset, _active_tag, _active_feed = _apply_scope(request, queryset)
unread_articles = queryset.exclude(user_states__user=request.user, user_states__is_read=True)
unread_ids = list(unread_articles.values_list("id", flat=True))
if unread_ids:
now = timezone.now()
existing_state_article_ids = set(
UserArticleState.objects.filter(
user=request.user, article_id__in=unread_ids
).values_list("article_id", flat=True)
)
UserArticleState.objects.filter(
user=request.user, article_id__in=existing_state_article_ids
).update(is_read=True, read_at=now)
new_article_ids = [aid for aid in unread_ids if aid not in existing_state_article_ids]
UserArticleState.objects.bulk_create(
[
UserArticleState(user=request.user, article_id=aid, is_read=True, read_at=now)
for aid in new_article_ids
]
)
stream_url = reverse("reader:stream")
query = request.GET.urlencode()
return redirect(f"{stream_url}?{query}" if query else stream_url)
def _load_article_and_mark_read(user, article_id):
article = get_object_or_404(_base_queryset(user), pk=article_id)
state = _get_or_create_state(user, article)
if not state.is_read:
state.is_read = True
state.read_at = timezone.now()
state.save(update_fields=["is_read", "read_at"])
article.is_read = state.is_read
article.is_starred, article.is_saved_for_later = _article_tag_flags(user, article)
return article
@login_required
def article_detail(request, article_id):
article = _load_article_and_mark_read(request.user, article_id)
return render(request, "reader/article_detail.html", {"article": article})
@login_required
def article_inline(request, article_id):
"""Fetched via htmx when a row in the stream is expanded in place —
mirrors article_detail's mark-read side effect, but renders just the
content fragment plus an out-of-band update of the row's own read/star
icons (see templates/reader/_article_inline.html)."""
article = _load_article_and_mark_read(request.user, article_id)
return render(request, "reader/_article_inline.html", {"article": article})
@login_required
@require_POST
def toggle_read(request, article_id):
article = _owned_article(request.user, article_id)
state = _get_or_create_state(request.user, article)
state.is_read = not state.is_read
state.read_at = timezone.now() if state.is_read else None
state.save(update_fields=["is_read", "read_at"])
article.is_read = state.is_read
article.is_starred, article.is_saved_for_later = _article_tag_flags(request.user, article)
return render(request, "reader/_article_actions.html", {"article": article})
@login_required
@require_POST
def toggle_star(request, article_id):
return _toggle_system_tag(request, article_id, STARRED_TAG_NAME)
@login_required
@require_POST
def toggle_saved(request, article_id):
return _toggle_system_tag(request, article_id, SAVED_TAG_NAME)
def _owned_article(user, article_id):
try:
return _base_queryset(user).get(pk=article_id)
except Article.DoesNotExist:
raise Http404
def _toggle_system_tag(request, article_id, tag_name):
article = _owned_article(request.user, article_id)
tag = get_system_tag(request.user, tag_name)
existing = ArticleTag.objects.filter(user=request.user, article=article, tag=tag)
if existing.exists():
existing.delete()
else:
ArticleTag.objects.create(user=request.user, article=article, tag=tag)
state = UserArticleState.objects.filter(user=request.user, article=article).first()
article.is_read = state.is_read if state else False
article.is_starred, article.is_saved_for_later = _article_tag_flags(request.user, article)
return render(request, "reader/_article_actions.html", {"article": article})