lukas
3fd02bbcf9
Add filter_url(), a reverse()-style helper that builds a URL to a filtered list view from a filter object (target inferred from the filter type). Add OperatorFilter.where(**lookups), a Django-.filter()-style ergonomic constructor that resolves each field's criterion class from its annotation (shared with from_json via _criterion_class_for, removing duplication). Make SessionFilter.timestamp_start/timestamp_end DateCriterion applied via the __date lookup, so date ranges over the timestamp columns are expressible. Wire the navbar 'today' / 'last 7 days' totals as links to the matching filtered session lists, and align the 'last 7 days' total to the same calendar-day window so the number matches the list it links to. Stats-table and game-detail links remain a follow-up (see spec). Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01RF5L4HtbcykTfY9YUYGds3
116 lines
4.1 KiB
Python
116 lines
4.1 KiB
Python
from datetime import datetime, timedelta
|
|
from typing import Any, Callable
|
|
|
|
from django.contrib.auth.decorators import login_required
|
|
from django.db.models import (
|
|
F,
|
|
Sum,
|
|
)
|
|
|
|
from django.http import HttpRequest, HttpResponse, HttpResponseRedirect
|
|
from django.shortcuts import redirect
|
|
from django.urls import reverse
|
|
from django.utils.timezone import localtime
|
|
from django.utils.timezone import now as timezone_now
|
|
|
|
from common.layout import render_page
|
|
from common.time import format_duration
|
|
from games.filters import SessionFilter, filter_url
|
|
from games.models import Game, Platform, Purchase, Session
|
|
from games.views.stats_content import stats_content
|
|
from games.views.stats_data import compute_stats
|
|
|
|
# The Flowbite-datepicker UMD bundle is declared as media on the YearPicker
|
|
# component, so Page() loads it automatically on the stats pages.
|
|
|
|
|
|
def model_counts(request: HttpRequest) -> dict[str, Any]:
|
|
now = timezone_now()
|
|
# Use a contiguous [midnight, next midnight) range in the active timezone
|
|
# instead of day/month/year extracts: a range filter can use an index on
|
|
# timestamp_start, whereas the extracts force a per-row datetime function.
|
|
today = localtime(now).date()
|
|
start_of_today = localtime(now).replace(hour=0, minute=0, second=0, microsecond=0)
|
|
start_of_tomorrow = start_of_today + timedelta(days=1)
|
|
# "Last 7 days" is a calendar-day window (today plus the previous six) so the
|
|
# displayed total matches the list its navbar link points to.
|
|
start_of_window = start_of_today - timedelta(days=6)
|
|
today_played = Session.objects.filter(
|
|
timestamp_start__gte=start_of_today,
|
|
timestamp_start__lt=start_of_tomorrow,
|
|
).aggregate(time=Sum(F("duration_total")))["time"]
|
|
last_7_played = Session.objects.filter(
|
|
timestamp_start__gte=start_of_window,
|
|
timestamp_start__lt=start_of_tomorrow,
|
|
).aggregate(time=Sum(F("duration_total")))["time"]
|
|
|
|
today_iso = today.isoformat()
|
|
today_url = filter_url(SessionFilter.where(timestamp_start=today_iso))
|
|
last_7_url = filter_url(
|
|
SessionFilter.where(
|
|
timestamp_start__between=(
|
|
(today - timedelta(days=6)).isoformat(),
|
|
today_iso,
|
|
)
|
|
)
|
|
)
|
|
|
|
return {
|
|
"game_available": Game.objects.exists(),
|
|
"platform_available": Platform.objects.exists(),
|
|
"purchase_available": Purchase.objects.exists(),
|
|
"session_count": Session.objects.exists(),
|
|
"today_played": format_duration(today_played, "%H h %m m"),
|
|
"last_7_played": format_duration(last_7_played, "%H h %m m"),
|
|
"today_url": today_url,
|
|
"last_7_url": last_7_url,
|
|
}
|
|
|
|
|
|
def global_current_year(request: HttpRequest) -> dict[str, int]:
|
|
return {"global_current_year": datetime.now().year}
|
|
|
|
|
|
def use_custom_redirect(
|
|
func: Callable[..., HttpResponse],
|
|
) -> Callable[..., HttpResponse]:
|
|
"""
|
|
Will redirect to "return_path" session variable if set.
|
|
"""
|
|
|
|
def wrapper(request: HttpRequest, *args: Any, **kwargs: Any) -> HttpResponse:
|
|
response = func(request, *args, **kwargs)
|
|
if isinstance(response, HttpResponseRedirect) and (
|
|
next_url := request.session.get("return_path")
|
|
):
|
|
return HttpResponseRedirect(next_url)
|
|
return response
|
|
|
|
return wrapper
|
|
|
|
|
|
@login_required
|
|
def stats_alltime(request: HttpRequest) -> HttpResponse:
|
|
request.session["return_path"] = request.path
|
|
data = compute_stats(None)
|
|
return render_page(request, stats_content(data), title=data["title"])
|
|
|
|
|
|
@login_required
|
|
def stats(request: HttpRequest, year: int = 0) -> HttpResponse:
|
|
selected_year = request.GET.get("year")
|
|
if selected_year:
|
|
return HttpResponseRedirect(
|
|
reverse("games:stats_by_year", args=[selected_year])
|
|
)
|
|
if year == 0:
|
|
return HttpResponseRedirect(reverse("games:stats_alltime"))
|
|
request.session["return_path"] = request.path
|
|
data = compute_stats(year)
|
|
return render_page(request, stats_content(data), title=data["title"])
|
|
|
|
|
|
@login_required
|
|
def index(request: HttpRequest) -> HttpResponse:
|
|
return redirect("games:list_sessions")
|