Translate the whole site to English: English routes with 301 redirects from the Dutch paths, English UI, docs, seeds and captions, one-time live content migration

molodetz/routers/admin/audit.py

@@ -14,4 +14,4 @@ router = APIRouter()
 async def audit_index(request: Request):
     require_admin(request)
     category = request.query_params.get("category") or None
-    return respond(request, "admin/audit.html", {"rows": list_audit(200, category), "category": category, "seo": admin_seo(request, "Auditlog")}, model=AuditOut)
+    return respond(request, "admin/audit.html", {"rows": list_audit(200, category), "category": category, "seo": admin_seo(request, "Audit log")}, model=AuditOut)

molodetz/routers/admin/backups.py

@@ -21,7 +21,7 @@ router = APIRouter()
 async def backups_index(request: Request):
     user = require_admin(request)
     rows = [{**row, "size_label": format_size(row.get("size_bytes"))} for row in list_backups()]
-    ctx = {"backups": rows, "can_download": is_primary_admin(user), "seo": admin_seo(request, "Back-ups")}
+    ctx = {"backups": rows, "can_download": is_primary_admin(user), "seo": admin_seo(request, "Backups")}
     return respond(request, "admin/backups.html", ctx, model=BackupsOut)
 
 
@@ -39,13 +39,13 @@ async def backups_download(request: Request, uid: str):
     user = require_admin(request)
     if not is_primary_admin(user):
         record(request, "backup.download", result="denied", targets=[("backup", uid)], user=user)
-        raise HTTPException(403, "Alleen de primaire beheerder")
+        raise HTTPException(403, "Primary administrator only")
     row = get_backup(uid)
     if row is None or row.get("status") != "done":
-        not_found("Back-up niet gevonden")
+        not_found("Backup not found")
     path = backup_path(row)
     if not path.exists():
-        not_found("Archief ontbreekt")
+        not_found("Archive missing")
     record(request, "backup.download", targets=[("backup", uid)], user=user)
     return StreamingResponse(
         _stream_file(path),

molodetz/routers/admin/index.py

@@ -19,6 +19,6 @@ async def admin_index(request: Request):
         "open_joins": count_open_join_requests(),
         "user_count": count_users(),
         "deleted_count": sum(count_deleted(name) for name in SOFT_DELETE_TABLES),
-        "seo": admin_seo(request, "Beheer"),
+        "seo": admin_seo(request, "Admin"),
     }
     return respond(request, "admin/index.html", ctx, model=AdminIndexOut)

molodetz/routers/admin/joins.py

@@ -17,7 +17,7 @@ router = APIRouter()
 @router.get("/joins")
 async def joins_index(request: Request):
     require_admin(request)
-    return respond(request, "admin/joins.html", {"requests": list_join_requests(), "seo": admin_seo(request, "Aanmeldingen")}, model=JoinListOut)
+    return respond(request, "admin/joins.html", {"requests": list_join_requests(), "seo": admin_seo(request, "Join requests")}, model=JoinListOut)
 
 
 @router.post("/joins/{uid}/status")
@@ -25,7 +25,7 @@ async def joins_status(request: Request, uid: str):
     user = require_admin(request)
     row = get_join_request(uid)
     if row is None:
-        not_found("Aanmelding niet gevonden")
+        not_found("Join request not found")
     data = await json_or_form(request, JoinStatusForm)
     update_join_request(uid, status=data.status)
     record(request, "join.request.status", payload={"status": data.status}, targets=[("join_request", uid)], user=user)
@@ -37,7 +37,7 @@ async def joins_check(request: Request, uid: str):
     user = require_admin(request)
     row = get_join_request(uid)
     if row is None:
-        not_found("Aanmelding niet gevonden")
+        not_found("Join request not found")
     result = await check_repo_link(row)
     record(request, "join.request.check", payload=result, targets=[("join_request", uid)], user=user)
     return action_result(request, "/admin/joins", data=result)

molodetz/routers/admin/posts.py

@@ -19,13 +19,13 @@ router = APIRouter()
 @router.get("/posts")
 async def posts_index(request: Request):
     require_admin(request)
-    return respond(request, "admin/posts.html", {"posts": all_posts(), "seo": admin_seo(request, "Berichten")}, model=AdminPostsOut)
+    return respond(request, "admin/posts.html", {"posts": all_posts(), "seo": admin_seo(request, "Posts")}, model=AdminPostsOut)
 
 
 @router.get("/posts/new")
 async def posts_new(request: Request):
     require_admin(request)
-    ctx = {"post": None, "topics": TOPICS, "errors": [], "seo": admin_seo(request, "Nieuw bericht")}
+    ctx = {"post": None, "topics": TOPICS, "errors": [], "seo": admin_seo(request, "New post")}
     return respond(request, "admin/post_form.html", ctx, model=PostDetailOut)
 
 
@@ -42,18 +42,18 @@ async def posts_edit(request: Request, uid: str):
     require_admin(request)
     post = get_post(uid)
     if post is None:
-        not_found("Bericht niet gevonden")
-    ctx = {"post": post, "topics": TOPICS, "errors": [], "seo": admin_seo(request, "Bericht bewerken")}
+        not_found("Post not found")
+    ctx = {"post": post, "topics": TOPICS, "errors": [], "seo": admin_seo(request, "Edit post")}
     return respond(request, "admin/post_form.html", ctx, model=PostDetailOut)
 
 
 def _owned_post(request, user, uid):
     post = get_post(uid)
     if post is None:
-        not_found("Bericht niet gevonden")
+        not_found("Post not found")
     if not is_owner(post, user):
         record(request, "post.edit.denied", result="denied", targets=[("post", uid)], user=user)
-        raise HTTPException(403, "Alleen de auteur mag dit bericht bewerken")
+        raise HTTPException(403, "Only the author may edit this post")
     return post
 
 
@@ -80,9 +80,9 @@ async def posts_delete(request: Request, uid: str):
     user = require_admin(request)
     post = get_post(uid)
     if post is None:
-        not_found("Bericht niet gevonden")
+        not_found("Post not found")
     if not (is_owner(post, user) or is_admin(user)):
         record(request, "post.delete.denied", result="denied", targets=[("post", uid)], user=user)
-        raise HTTPException(403, "Niet toegestaan")
+        raise HTTPException(403, "Not allowed")
     stamp = delete_post(post, user, request=request)
     return action_result(request, "/admin/posts", data={"uid": uid, "stamp": stamp})

molodetz/routers/admin/services.py

@@ -15,7 +15,7 @@ VERBS = ("start", "stop", "run", "clear")
 def _service(name):
     service = manager.get(name)
     if service is None:
-        not_found("Onbekende service")
+        not_found("Unknown service")
     return service
 
 
@@ -47,7 +47,7 @@ async def services_command(request: Request, name: str):
     service = _service(name)
     verb = (await _payload(request)).get("verb", "")
     if verb not in VERBS:
-        raise HTTPException(400, "Onbekend commando")
+        raise HTTPException(400, "Unknown command")
     if verb in ("start", "stop"):
         manager.set_enabled(service.name, verb == "start")
     else:

molodetz/routers/admin/settings.py

@@ -18,7 +18,7 @@ BOOLEAN = ("maintenance_mode", "friendly_404")
 @router.get("/settings")
 async def settings_index(request: Request):
     require_admin(request)
-    return respond(request, "admin/settings.html", {"settings": all_settings(), "seo": admin_seo(request, "Instellingen")}, model=SettingsOut)
+    return respond(request, "admin/settings.html", {"settings": all_settings(), "seo": admin_seo(request, "Settings")}, model=SettingsOut)
 
 
 @router.post("/settings")

molodetz/routers/admin/stats.py

@@ -13,5 +13,5 @@ router = APIRouter()
 @router.get("/stats")
 async def stats_index(request: Request):
     require_admin(request)
-    ctx = {"top_paths": [dict(row) for row in top_paths()], "daily": [dict(row) for row in daily_totals()], "seo": admin_seo(request, "Statistieken")}
+    ctx = {"top_paths": [dict(row) for row in top_paths()], "daily": [dict(row) for row in daily_totals()], "seo": admin_seo(request, "Statistics")}
     return respond(request, "admin/stats.html", ctx, model=StatsOut)

molodetz/routers/admin/trash.py

@@ -30,7 +30,7 @@ async def trash_index(request: Request):
         for row in list_deleted(table):
             items.append({"table": table, "uid": row.get("uid"), "label": _label(row), "deleted_at": row.get("deleted_at"), "deleted_by": row.get("deleted_by")})
     items.sort(key=lambda item: item["deleted_at"] or "", reverse=True)
-    return respond(request, "admin/trash.html", {"items": items, "seo": admin_seo(request, "Prullenbak")}, model=TrashOut)
+    return respond(request, "admin/trash.html", {"items": items, "seo": admin_seo(request, "Trash")}, model=TrashOut)
 
 
 async def _stamp(request):
@@ -40,7 +40,7 @@ async def _stamp(request):
     else:
         stamp = (await request.form()).get("stamp")
     if not stamp:
-        raise HTTPException(400, "stamp ontbreekt")
+        raise HTTPException(400, "stamp missing")
     return str(stamp)
 
 

molodetz/routers/admin/users.py

@@ -24,11 +24,11 @@ async def users_role(request: Request, uid: str):
     actor = require_admin(request)
     target = get_user(uid)
     if target is None:
-        not_found("Account niet gevonden")
+        not_found("Account not found")
     data = await json_or_form(request, RoleForm)
     if is_senior_admin(actor, target) or (target["uid"] == actor["uid"] and data.role != "Admin"):
         record(request, "admin.user.role", result="denied", targets=[("user", uid)], user=actor)
-        raise HTTPException(403, "Je kunt een senior beheerder niet beheren")
+        raise HTTPException(403, "You cannot manage a more senior administrator")
     set_role(uid, data.role)
     invalidate_user_cache(propagate=True)
     record(request, "admin.user.role", payload={"role": data.role}, targets=[("user", uid)], user=actor)

molodetz/routers/auth.py

@@ -16,7 +16,7 @@ router = APIRouter()
 
 
 def _seo(request):
-    return base_seo_context(request, "Inloggen", robots="noindex,nofollow")
+    return base_seo_context(request, "Log in", robots="noindex,nofollow")
 
 
 @router.get("/login")
@@ -33,7 +33,7 @@ async def login_submit(request: Request):
     if not valid:
         record(request, "auth.login.failed", result="denied", payload={"username": data.username[:64]})
         ctx = {
-            "errors": ["Onbekende combinatie van naam en wachtwoord."],
+            "errors": ["Unknown combination of name and password."],
             "form": {"username": data.username},
             "next": data.next,
             "seo": _seo(request),

molodetz/routers/docs.py

@@ -17,14 +17,14 @@ router = APIRouter()
 def _ctx(request, title, **extra):
     viewer = get_current_user(request)
     viewer_is_admin = is_admin(viewer)
-    groups = [group for group in ordered_groups() if viewer_is_admin or group["slug"] != "beheer"]
+    groups = [group for group in ordered_groups() if viewer_is_admin or group["slug"] != "admin"]
     seo = base_seo_context(request, title, breadcrumbs=[("Molodetz", "/"), ("Docs", "/docs")])
     return {"sidebar": sidebar(viewer_is_admin), "api_groups": groups, "viewer_is_admin": viewer_is_admin, "seo": seo, "doc_title": title, **extra}
 
 
 @router.get("/docs")
 async def docs_index(request: Request):
-    return templates.TemplateResponse(request, "docs/index.html", _ctx(request, "Documentatie", body=render_page("welkom")))
+    return templates.TemplateResponse(request, "docs/index.html", _ctx(request, "Documentation", body=render_page("welcome")))
 
 
 @router.get("/docs/search")
@@ -32,7 +32,7 @@ async def docs_search(request: Request):
     query = request.query_params.get("q", "")[:200]
     viewer_is_admin = is_admin(get_current_user(request))
     results = search(query, viewer_is_admin)
-    return templates.TemplateResponse(request, "docs/search.html", _ctx(request, "Zoeken", query=query, results=results))
+    return templates.TemplateResponse(request, "docs/search.html", _ctx(request, "Search", query=query, results=results))
 
 
 @router.get("/docs/download.md")
@@ -51,11 +51,11 @@ async def docs_download_html(request: Request):
 async def docs_api_group(request: Request, group_slug: str):
     group = group_by_slug(group_slug)
     viewer = get_current_user(request)
-    if group is None or (group["slug"] == "beheer" and not is_admin(viewer)):
-        not_found("Onbekende API-groep")
+    if group is None or (group["slug"] == "admin" and not is_admin(viewer)):
+        not_found("Unknown API group")
     base = base_url(request)
     username = viewer["username"] if viewer else "retoor"
-    api_key = viewer["api_key"] if viewer else "JOUW_API_SLEUTEL"
+    api_key = viewer["api_key"] if viewer else "YOUR_API_KEY"
     endpoints = []
     for item in group["endpoints"]:
         example = substitute(f"curl -H 'Accept: application/json' -H 'X-API-KEY: {{{{api_key}}}}' {{{{base}}}}{item['path']}", base, username, api_key)
@@ -63,7 +63,7 @@ async def docs_api_group(request: Request, group_slug: str):
     return templates.TemplateResponse(
         request,
         "docs/api.html",
-        _ctx(request, f"API: {group['title']}", group=group, endpoints=endpoints, viewer=viewer, services=live_services() if group["slug"] == "beheer" else []),
+        _ctx(request, f"API: {group['title']}", group=group, endpoints=endpoints, viewer=viewer, services=live_services() if group["slug"] == "admin" else []),
     )
 
 
@@ -72,5 +72,5 @@ async def docs_page(request: Request, slug: str):
     page = page_by_slug(slug)
     viewer_is_admin = is_admin(get_current_user(request))
     if page is None or (page.get("admin") and not viewer_is_admin):
-        not_found("Pagina niet gevonden")
+        not_found("Page not found")
     return templates.TemplateResponse(request, "docs/page.html", _ctx(request, page["title"], body=render_page(slug), page=page))

molodetz/routers/join.py

@@ -19,13 +19,13 @@ router = APIRouter()
 
 
 def _seo(request):
-    return base_seo_context(request, "Binnen", description_for("binnen"), breadcrumbs=[("Molodetz", "/"), ("Binnen", "/binnen")])
+    return base_seo_context(request, "Join", description_for("join"), breadcrumbs=[("Molodetz", "/"), ("Join", "/join")])
 
 
 @router.get("")
 async def join_page(request: Request):
     submitted = request.query_params.get("ok") == "1"
-    return respond(request, "binnen.html", {"submitted": submitted, "errors": [], "form": {}, "seo": _seo(request)}, model=JoinPageOut)
+    return respond(request, "join.html", {"submitted": submitted, "errors": [], "form": {}, "seo": _seo(request)}, model=JoinPageOut)
 
 
 @router.post("")
@@ -33,10 +33,10 @@ async def join_submit(request: Request):
     data = await json_or_form(request, JoinForm)
     if data.website:
         record(request, "join.request.honeypot", result="denied")
-        return action_result(request, "/binnen?ok=1")
+        return action_result(request, "/join?ok=1")
     ip_hash = hashlib.sha256(f"{config.SECRET_KEY}:{client_ip(request)}".encode()).hexdigest()[:24]
     row = insert_join_request(data.name, data.contact, data.repo_url, data.message, ip_hash)
     record(request, "join.request.create", payload={"uid": row["uid"]}, targets=[("join_request", row["uid"])])
     for uid in admin_uids_ordered():
-        create_notification(uid, "join.request", f"{data.name} wil meeschrijven", "/admin/joins")
-    return action_result(request, "/binnen?ok=1", data={"uid": row["uid"]})
+        create_notification(uid, "join.request", f"{data.name} wants to write along", "/admin/joins")
+    return action_result(request, "/join?ok=1", data={"uid": row["uid"]})

molodetz/routers/legacy.py

@@ -0,0 +1,58 @@
+# retoor <retoor@molodetz.nl>
+from fastapi import APIRouter, Request
+from fastapi.responses import RedirectResponse
+
+router = APIRouter(include_in_schema=False)
+
+LEGACY_PATHS = {
+    "/rol": "/roll",
+    "/standaard": "/standard",
+    "/mensen": "/people",
+    "/binnen": "/join",
+    "/voorwaarden": "/terms",
+    "/docs/welkom": "/docs/welcome",
+    "/docs/schrijven": "/docs/writing",
+    "/docs/binnen": "/docs/join",
+    "/docs/juridisch": "/docs/legal",
+    "/docs/architectuur": "/docs/architecture",
+    "/docs/beheer": "/docs/admin",
+    "/docs/api/inhoud": "/docs/api/content",
+    "/docs/api/binnen": "/docs/api/join",
+    "/docs/api/beheer": "/docs/api/admin",
+}
+
+
+def _target(request, path):
+    query = request.url.query
+    return f"{path}?{query}" if query else path
+
+
+def _redirect(request, path):
+    status = 301 if request.method in ("GET", "HEAD") else 308
+    return RedirectResponse(_target(request, path), status_code=status)
+
+
+@router.get("/mensen/{username}")
+async def legacy_person(request: Request, username: str):
+    return _redirect(request, f"/people/{username}")
+
+
+@router.post("/binnen")
+async def legacy_join_post(request: Request):
+    return _redirect(request, "/join")
+
+
+@router.post("/voorwaarden/accept")
+async def legacy_terms_accept(request: Request):
+    return _redirect(request, "/terms/accept")
+
+
+def _make_handler(target):
+    async def handler(request: Request):
+        return _redirect(request, target)
+
+    return handler
+
+
+for _old, _new in LEGACY_PATHS.items():
+    router.add_api_route(_old, _make_handler(_new), methods=["GET"])

molodetz/routers/notifications.py

@@ -14,7 +14,7 @@ router = APIRouter()
 async def notifications_page(request: Request):
     user = require_user(request)
     rows = list_notifications(user["uid"])
-    seo = base_seo_context(request, "Meldingen", robots="noindex,nofollow")
+    seo = base_seo_context(request, "Notifications", robots="noindex,nofollow")
     ctx = {"notifications": rows, "unread": unread_count(user["uid"]), "seo": seo}
     return respond(request, "notifications.html", ctx, model=NotificationsOut)
 

molodetz/routers/people.py

@@ -19,24 +19,24 @@ def _with_counts(people):
 @router.get("")
 async def people(request: Request):
     persons = _with_counts(public_people())
-    seo = base_seo_context(request, "Mensen", description_for("mensen"), breadcrumbs=[("Molodetz", "/"), ("Mensen", "/mensen")])
-    return respond(request, "mensen.html", {"people": persons, "seo": seo}, model=PeopleOut)
+    seo = base_seo_context(request, "People", description_for("people"), breadcrumbs=[("Molodetz", "/"), ("People", "/people")])
+    return respond(request, "people.html", {"people": persons, "seo": seo}, model=PeopleOut)
 
 
 @router.get("/{username}")
 async def person(request: Request, username: str):
     row = get_user_by_username(username)
     if row is None:
-        not_found("Persoon niet gevonden")
+        not_found("Person not found")
     person_row = _with_counts([row])[0]
     own, _ = published_posts(limit=50, user_uid=row["uid"])
     seo = base_seo_context(
         request,
         row["username"],
-        row.get("bio") or description_for("mensen"),
+        row.get("bio") or description_for("people"),
         og_type="profile",
         robots="index,follow" if person_row["post_count"] > 0 else "noindex,follow",
-        breadcrumbs=[("Molodetz", "/"), ("Mensen", "/mensen"), (row["username"], f"/mensen/{row['username']}")],
+        breadcrumbs=[("Molodetz", "/"), ("People", "/people"), (row["username"], f"/people/{row['username']}")],
         schemas=[profile_schema(request, row)],
     )
     return respond(request, "person.html", {"person": person_row, "posts": own, "seo": seo}, model=ProfileOut)

molodetz/routers/posts.py

@@ -3,7 +3,7 @@ from fastapi import APIRouter, Request
 from fastapi.responses import RedirectResponse
 
 from molodetz.constants import TOPICS
-from molodetz.database import get_post_by_slug, get_user
+from molodetz.database import get_post_by_slug, get_post_by_slug_tail, get_user
 from molodetz.rendering import content_preview, plain_title
 from molodetz.responses import respond
 from molodetz.schemas.posts import PostDetailOut
@@ -15,10 +15,10 @@ router = APIRouter()
 
 @router.get("/{slug}")
 async def post_detail(request: Request, slug: str):
-    post = get_post_by_slug(slug)
+    post = get_post_by_slug(slug) or get_post_by_slug_tail(slug)
     viewer = get_current_user(request)
     if post is None or (post["status"] != "published" and not is_admin(viewer)):
-        not_found("Bericht niet gevonden")
+        not_found("Post not found")
     if slug != post["slug"]:
         return RedirectResponse(f"/posts/{post['slug']}", status_code=301)
     author = get_user(post["user_uid"])

molodetz/routers/profile.py

@@ -15,7 +15,7 @@ router = APIRouter()
 @router.get("/api-key")
 async def api_key_page(request: Request):
     user = require_user(request)
-    seo = base_seo_context(request, "API-sleutel", robots="noindex,nofollow")
+    seo = base_seo_context(request, "API key", robots="noindex,nofollow")
     return respond(request, "profile/api_key.html", {"api_key": user["api_key"], "seo": seo}, model=ApiKeyOut)
 
 
@@ -26,7 +26,7 @@ async def api_key_regenerate(request: Request):
     update_user(user["uid"], api_key=key)
     invalidate_user_cache(propagate=True)
     record(request, "profile.apikey.regenerate", targets=[("user", user["uid"])], user=user)
-    create_notification(user["uid"], "auth.apikey", "Je API-sleutel is vernieuwd.", "/profile/api-key")
+    create_notification(user["uid"], "auth.apikey", "Your API key was renewed.", "/profile/api-key")
     return action_result(request, "/profile/api-key", data={"api_key": key})
 
 
@@ -36,4 +36,4 @@ async def avatar_regenerate(request: Request):
     update_user(user["uid"], avatar_seed=generate_uid())
     invalidate_user_cache(propagate=True)
     record(request, "profile.avatar.regenerate", targets=[("user", user["uid"])], user=user)
-    return action_result(request, f"/mensen/{user['username']}")
+    return action_result(request, f"/people/{user['username']}")

molodetz/routers/roll.py

@@ -7,5 +7,5 @@ router = APIRouter()
 
 
 @router.get("")
-async def rol(request: Request):
-    return topic_listing(request, "rol")
+async def roll(request: Request):
+    return topic_listing(request, "roll")

molodetz/routers/seo.py

@@ -17,7 +17,7 @@ router = APIRouter()
 logger = logging.getLogger(__name__)
 _sitemap_cache = TTLCache(ttl=config.SITEMAP_TTL, max_size=4)
 PER_TABLE_CAP = 5000
-STATIC_PATHS = ("/", "/flyers", "/memes", "/mensen", "/binnen", "/voorwaarden", "/privacy", "/docs")
+STATIC_PATHS = ("/", "/flyers", "/memes", "/people", "/join", "/terms", "/privacy", "/docs")
 
 
 @router.get("/robots.txt")
@@ -47,7 +47,7 @@ def build_sitemap(base):
             logger.warning("sitemap truncated posts at %d", PER_TABLE_CAP)
             rows = rows[:PER_TABLE_CAP]
         urls += [(f"/posts/{row['slug']}", row.get("updated_at")) for row in rows]
-    urls += [(f"/mensen/{person['username']}", None) for person in public_people()[:PER_TABLE_CAP]]
+    urls += [(f"/people/{person['username']}", None) for person in public_people()[:PER_TABLE_CAP]]
     urls += [(f"/docs/{page['slug']}", None) for page in DOCS_PAGES if not page.get("admin")]
     parts = ['<?xml version="1.0" encoding="UTF-8"?>', '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">']
     for path, modified in urls:

molodetz/routers/standard.py

@@ -7,5 +7,5 @@ router = APIRouter()
 
 
 @router.get("")
-async def standaard(request: Request):
-    return topic_listing(request, "standaard")
+async def standard(request: Request):
+    return topic_listing(request, "standard")

molodetz/routers/terms.py

@@ -14,9 +14,9 @@ router = APIRouter()
 
 @router.get("")
 async def terms(request: Request):
-    seo = base_seo_context(request, "Voorwaarden", breadcrumbs=[("Molodetz", "/"), ("Voorwaarden", "/voorwaarden")])
-    ctx = {"title": "Voorwaarden", "terms_version": get_setting("terms_version", "1"), "next": safe_next(request.query_params.get("next"), "/"), "seo": seo}
-    return respond(request, "voorwaarden.html", ctx, model=PageOut)
+    seo = base_seo_context(request, "Terms", breadcrumbs=[("Molodetz", "/"), ("Terms", "/terms")])
+    ctx = {"title": "Terms", "terms_version": get_setting("terms_version", "1"), "next": safe_next(request.query_params.get("next"), "/"), "seo": seo}
+    return respond(request, "terms.html", ctx, model=PageOut)
 
 
 @router.post("/accept")