Private
Public Access
The previous UI was plain unstyled lists. Rebuilt around what FreshRSS actually looks like (per reference screenshots): a persistent left sidebar (folders/feeds with unread counts, favourites, tags) and a single main column with a date-grouped article list, where clicking a title expands the full article inline in place rather than navigating to a separate page. - apps/core/context_processors.py: feeds the sidebar's folder/feed tree, tags, and starred count to every authenticated page in one shared query set, so base.html can render it without each view wiring it up. - apps/reader/views.py: date-grouped stream (itertools.groupby over the already-ordered queryset), ?feed=/?folder= scoping alongside the existing ?tag=, a bulk mark-all-read endpoint (bulk_create/update, not one UserArticleState per article), and article_inline — the htmx endpoint behind the inline expand, sharing its mark-read logic with the full article_detail view via _load_article_and_mark_read. - templates/reader/_article_inline.html returns the article content plus an out-of-band swap of _article_actions.html, so the row's read/star icons update immediately when an article is expanded and marked read. - static/js/stream.js: the accordion toggle (one article open at a time), calling htmx.ajax() directly rather than hx-* attributes so a second click on an already-open row can collapse it without re-fetching. - static/css/base.css: full FreshRSS-like dark theme (with a light variant under prefers-color-scheme) replacing the previous unstyled pass — sidebar, topbar search, row/icon states, inline-expand styling. Verified end to end against a running dev server: folder/feed/tag scoping, mark-all-read, the inline-expand mark-read side effect and its icon update, and — against config.settings.prod specifically — that no inline <script> crept back in anywhere (would silently break under the CSP added in the previous commit) and the CSP header is still present on every page. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
249 lines
8.6 KiB
Python
249 lines
8.6 KiB
Python
from itertools import groupby
|
|
|
|
from django.contrib.auth.decorators import login_required
|
|
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 Article, Tag, UserArticleState
|
|
from apps.articles.queries import with_user_state
|
|
from apps.feeds.models import Feed, Folder
|
|
|
|
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 _apply_scope(request, queryset):
|
|
"""Narrows an already-base-scoped Article queryset by the optional
|
|
?tag=/?feed=/?folder= 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); folder_id must be combined with user in the
|
|
same .filter() call — Feed is shared across users, so a separate call
|
|
would match any user's subscription with that folder_id, not just this
|
|
user's, leaking other users' folder contents in.
|
|
"""
|
|
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:
|
|
queryset = queryset.filter(
|
|
article_tags__user=request.user, article_tags__tag=active_tag
|
|
)
|
|
|
|
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)
|
|
|
|
active_folder = None
|
|
folder_id = request.GET.get("folder")
|
|
if folder_id:
|
|
active_folder = Folder.objects.filter(user=request.user, pk=folder_id).first()
|
|
if active_folder:
|
|
queryset = queryset.filter(
|
|
feed__subscriptions__user=request.user,
|
|
feed__subscriptions__folder_id=active_folder.pk,
|
|
)
|
|
|
|
return queryset, active_tag, active_feed, active_folder
|
|
|
|
|
|
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):
|
|
active_filter = request.GET.get("filter", "unread")
|
|
if active_filter not in VALID_FILTERS:
|
|
active_filter = "unread"
|
|
|
|
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(user_states__user=request.user, user_states__is_starred=True)
|
|
elif active_filter == "saved":
|
|
queryset = queryset.filter(
|
|
user_states__user=request.user, user_states__is_saved_for_later=True
|
|
)
|
|
|
|
queryset, active_tag, active_feed, active_folder = _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,
|
|
"active_folder": active_folder,
|
|
"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, _active_folder = _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 = state.is_starred
|
|
article.is_saved_for_later = state.is_saved_for_later
|
|
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):
|
|
return _toggle(request, article_id, "is_read", "read_at")
|
|
|
|
|
|
@login_required
|
|
@require_POST
|
|
def toggle_star(request, article_id):
|
|
return _toggle(request, article_id, "is_starred", "starred_at")
|
|
|
|
|
|
@login_required
|
|
@require_POST
|
|
def toggle_saved(request, article_id):
|
|
return _toggle(request, article_id, "is_saved_for_later", None)
|
|
|
|
|
|
def _toggle(request, article_id, flag_field, timestamp_field):
|
|
try:
|
|
article = _base_queryset(request.user).get(pk=article_id)
|
|
except Article.DoesNotExist:
|
|
raise Http404
|
|
|
|
state = _get_or_create_state(request.user, article)
|
|
new_value = not getattr(state, flag_field)
|
|
setattr(state, flag_field, new_value)
|
|
update_fields = [flag_field]
|
|
if timestamp_field:
|
|
setattr(state, timestamp_field, timezone.now() if new_value else None)
|
|
update_fields.append(timestamp_field)
|
|
state.save(update_fields=update_fields)
|
|
|
|
article.is_read = state.is_read
|
|
article.is_starred = state.is_starred
|
|
article.is_saved_for_later = state.is_saved_for_later
|
|
|
|
return render(request, "reader/_article_actions.html", {"article": article})
|