Files
StommerandClaude Sonnet 5.5 f925661937
Deploy Development / deploy (push) Successful in 44s
Warne vor bereits eingefügten Quelldokumenten und biete Nicht einfügen, erneut einfügen oder zusätzliches Einbinden an.
Prüfstufen hier, darin, Umfeld stehen als Kontoeinstellung bereit. Der Server antwortet bei einem sicheren Treffer mit 409 und bindet auf Wunsch das vorhandene Element zusätzlich ein.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-25 10:06:52 +01:00

113 lines
4.0 KiB
Python

"""Account preferences with inheritance.
An employee inherits the value of the main user who sponsors the account and may change it,
unless the main user made the preference binding for the team. A binding value overrides an own
value without deleting it: it applies again once the binding is lifted.
Allowed values, default and lockability of each key are fixed here.
"""
from __future__ import annotations
from dataclasses import dataclass
from uuid import UUID
from psycopg.types.json import Json
from app.core.errors import forbidden, not_found, unprocessable
@dataclass(frozen=True)
class Preference:
default: str
allowed: tuple[str, ...]
team_lockable: bool = True
PREFERENCES: dict[str, Preference] = {
# Where an element that is inserted again counts as already present.
"duplicate_check": Preference("here", ("off", "here", "inside", "around")),
}
def spec(key: str) -> Preference:
found = PREFERENCES.get(key)
if found is None:
raise not_found()
return found
def _valid(wanted: Preference, value) -> str | None:
return value if isinstance(value, str) and value in wanted.allowed else None
def preference_state(conn, account_id: UUID, key: str) -> dict:
"""The effective value and where it comes from: locked, own, team or default."""
wanted = spec(key)
row = conn.execute(
"""
SELECT a.account_kind,
own.value AS own_value, own.team_mode AS own_mode,
sp.value AS team_value, sp.team_mode AS team_mode
FROM auth_accounts a
LEFT JOIN account_preferences own ON own.account_id = a.id AND own.key = %s
LEFT JOIN account_preferences sp ON sp.account_id = a.sponsor_id AND sp.key = %s
WHERE a.id = %s
""",
(key, key, account_id),
).fetchone()
if row is None:
raise not_found()
employee = row["account_kind"] == "employee"
own = _valid(wanted, row["own_value"])
team = _valid(wanted, row["team_value"]) if employee else None
locked = employee and wanted.team_lockable and row["team_mode"] == "locked"
inherited = team or wanted.default
if locked:
value, source = inherited, "locked"
elif own is not None:
value, source = own, "own"
elif team is not None:
value, source = team, "team"
else:
value, source = wanted.default, "default"
return {
"key": key,
"value": value,
"source": source,
"own": own,
"inherited": inherited,
"locked": locked,
"allowed": list(wanted.allowed),
"default": wanted.default,
"can_lock": row["account_kind"] == "main" and wanted.team_lockable,
"team_mode": row["own_mode"] if row["own_mode"] and not employee else "free",
}
def effective_preference(conn, account_id: UUID, key: str) -> str:
return preference_state(conn, account_id, key)["value"]
def store_preference(conn, account_id: UUID, key: str, value: str | None, team_mode: str | None) -> dict:
"""Own value (None: inherit) and, for a main user, the binding for the team."""
wanted = spec(key)
state = preference_state(conn, account_id, key)
if value is not None and value not in wanted.allowed:
raise unprocessable("Dieser Wert ist für die Einstellung nicht vorgesehen.")
if team_mode is not None and not state["can_lock"]:
raise forbidden("Nur der Hauptnutzer kann eine Einstellung für das Team verbindlich setzen.")
if state["locked"]:
raise forbidden("Der Hauptnutzer hat diese Einstellung für das Team vorgegeben.")
conn.execute(
"""
INSERT INTO account_preferences (account_id, key, value, team_mode)
VALUES (%s, %s, %s, COALESCE(%s, 'free'))
ON CONFLICT (account_id, key) DO UPDATE
SET value = EXCLUDED.value,
team_mode = COALESCE(%s, account_preferences.team_mode),
updated_at = now()
""",
(account_id, key, Json(value) if value is not None else None, team_mode, team_mode),
)
return preference_state(conn, account_id, key)