113 lines
4.0 KiB
Python
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("case", ("off", "case", "case_matters", "case_tree")),
|
|
}
|
|
|
|
|
|
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)
|