import logging from django.core.cache import cache from django.db.models import Count from apps.core.cache_utils import SIDEBAR_UNREAD_CACHE_TTL_SECONDS, sidebar_unread_cache_key from .models import SAVED_TAG_NAME, STARRED_TAG_NAME, Article, ArticleTag, UserArticleState logger = logging.getLogger(__name__) def with_user_state(articles, user): """Annotates an iterable of Article instances with is_read/is_starred/ is_saved_for_later booleans for the given user, in two queries total regardless of how many articles there are (no N+1). Starred/saved come from ArticleTag against the pre-configured system tags, not a field on UserArticleState — see Tag.is_system. Accepts either a queryset or a plain list (search backends return plain lists already ordered by relevance), materializing it either way. """ articles = list(articles) if not articles: return articles article_ids = [a.pk for a in articles] states = { state.article_id: state for state in UserArticleState.objects.filter(user=user, article_id__in=article_ids) } starred_ids = set() saved_ids = set() tag_rows = ArticleTag.objects.filter( user=user, article_id__in=article_ids, tag__is_system=True, tag__name__in=[STARRED_TAG_NAME, SAVED_TAG_NAME], ).values_list("article_id", "tag__name") for article_id, tag_name in tag_rows: (starred_ids if tag_name == STARRED_TAG_NAME else saved_ids).add(article_id) for article in articles: state = states.get(article.pk) article.is_read = state.is_read if state else False article.is_starred = article.pk in starred_ids article.is_saved_for_later = article.pk in saved_ids return articles def unread_counts_by_feed(user): """{feed_id: unread_count} for every feed the user subscribes to — used by the sidebar's context processor, which runs on every authenticated page render, so the underlying join/group-by over the user's whole article corpus is cached for a short TTL rather than recomputed on every single page view (C3). apps.core.cache_utils. invalidate_sidebar_unread_cache is called wherever a request changes the current user's own read state, so this is rarely visibly stale. """ cache_key = sidebar_unread_cache_key(user.pk) # The cache is an optimization here, never a dependency: every # authenticated page render goes through this, so a Redis outage must # degrade to recomputing the count, not to a 500 on every page. try: counts = cache.get(cache_key) except Exception: logger.warning("Sidebar cache unavailable; computing unread counts directly") counts = None if counts is not None: return counts rows = ( Article.objects.filter(feed__subscriptions__user=user) .exclude(user_states__user=user, user_states__is_read=True) .exclude(user_states__user=user, user_states__is_hidden=True) .values("feed_id") .annotate(unread=Count("id")) ) counts = {row["feed_id"]: row["unread"] for row in rows} try: cache.set(cache_key, counts, SIDEBAR_UNREAD_CACHE_TTL_SECONDS) except Exception: logger.warning("Sidebar cache unavailable; skipping cache write") return counts