Private
Public Access
apps.core.context_processors.sidebar runs on every authenticated page
render and called unread_counts_by_feed, a join/group-by over the
user's whole article corpus, every single time — cost grew with the
archive's size regardless of which page was being viewed.
unread_counts_by_feed now caches its {feed_id: count} result per user
for 30 seconds (apps.core.cache_utils). The reader views that change
the current user's own read state (toggle_read, mark_all_read, viewing
an article) invalidate it immediately so the sidebar never visibly lags
behind the action that just caused it; other paths (rule-driven state
changes during background ingestion) aren't explicitly invalidated and
simply self-heal within the TTL, which is an acceptable tradeoff
already made elsewhere in this app (the stream's own "new articles"
banner polls on the same 30s cadence).
Also adds a global cache.clear() autouse fixture (conftest.py) — the
test CACHES backend (LocMemCache) lives in process memory and survives
Django's per-test DB rollback, so a cached count keyed by a user's pk
could otherwise leak into an unrelated later test reusing that pk.
Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
332 lines
12 KiB
Python
332 lines
12 KiB
Python
from itertools import groupby
|
|
from urllib.parse import urlencode
|
|
|
|
from django.contrib.auth.decorators import login_required
|
|
from django.db.models import Max, 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.core.cache_utils import invalidate_sidebar_unread_cache
|
|
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)
|
|
]
|
|
|
|
|
|
def _resolve_active_filter(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
|
|
return active_filter
|
|
|
|
|
|
def _filtered_queryset(request, active_filter):
|
|
"""The stream's fully-scoped queryset (filter tab + tag/feed scope),
|
|
unpaginated — shared by stream() and check_new_articles() so the "any
|
|
new articles?" check always matches exactly what the stream itself
|
|
would show."""
|
|
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,
|
|
)
|
|
return _apply_scope(request, queryset)
|
|
|
|
|
|
@login_required
|
|
def stream(request):
|
|
active_filter = _resolve_active_filter(request)
|
|
queryset, active_tag, active_feed = _filtered_queryset(request, active_filter)
|
|
|
|
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)
|
|
|
|
scope_params = {"filter": active_filter}
|
|
if active_tag:
|
|
scope_params["tag"] = active_tag.pk
|
|
if active_feed:
|
|
scope_params["feed"] = active_feed.pk
|
|
|
|
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,
|
|
# Lets the "new articles" banner ask, on this exact same scope,
|
|
# whether anything with a higher id has shown up since this page
|
|
# was rendered — id (not published_at) because it's monotonic
|
|
# regardless of how a feed backdates an entry's published date.
|
|
"latest_article_id": queryset.aggregate(Max("id"))["id__max"] or 0,
|
|
"new_check_qs": urlencode(scope_params),
|
|
}
|
|
return render(request, "reader/stream.html", context)
|
|
|
|
|
|
@login_required
|
|
def check_new_articles(request):
|
|
active_filter = _resolve_active_filter(request)
|
|
queryset, _active_tag, _active_feed = _filtered_queryset(request, active_filter)
|
|
|
|
try:
|
|
since_id = int(request.GET.get("since", 0))
|
|
except ValueError:
|
|
since_id = 0
|
|
|
|
new_count = queryset.filter(id__gt=since_id).count()
|
|
return render(request, "reader/_new_articles_banner.html", {"new_count": new_count})
|
|
|
|
|
|
@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
|
|
]
|
|
)
|
|
invalidate_sidebar_unread_cache(request.user.pk)
|
|
|
|
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"])
|
|
invalidate_sidebar_unread_cache(user.pk)
|
|
|
|
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"])
|
|
invalidate_sidebar_unread_cache(request.user.pk)
|
|
|
|
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})
|