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})