devplacepy/customization.py at 0ee6915fc582ebd4364bf92eea62b824b937d40a

 # retoor <retoor@molodetz.nl>
 from .core import TTLCache, bump_cache_version, datetime, db, get_table, sync_local_cache, timezone
 from .soft_delete import soft_delete
 CUSTOMIZATION_GLOBAL_SCOPE = "global"
 CUSTOMIZATION_LANGS = ("css", "js")
 _customizations_cache = TTLCache(ttl=300, max_size=100)
 def _customization_key(owner_kind: str, owner_id: str, page_type: str) -> str:
     return f"{owner_kind}\x1f{owner_id}\x1f{page_type}"
 CUSTOMIZATION_PREF_COLUMNS = {
     "global": "cust_disable_global",
     "pagetype": "cust_disable_pagetype",
 }
 def get_customization_prefs(owner_kind: str, owner_id: str) -> dict:
     if owner_kind != "user" or "users" not in db.tables:
         return {"disable_global": False, "disable_pagetype": False}
     user = db["users"].find_one(uid=owner_id)
     if user is None:
         return {"disable_global": False, "disable_pagetype": False}
     return {
         "disable_global": bool(user.get("cust_disable_global", 0)),
         "disable_pagetype": bool(user.get("cust_disable_pagetype", 0)),
     }
 def set_customization_pref(owner_id: str, category: str, disabled: bool) -> None:
     column = CUSTOMIZATION_PREF_COLUMNS.get(category)
     if column is None:
         raise ValueError(f"Unknown customization category: {category}")
     from devplacepy.utils import clear_user_cache
     get_table("users").update(
         {"uid": owner_id, column: 1 if disabled else 0}, ["uid"]
     )
     clear_user_cache(owner_id)
     bump_cache_version("customizations")
 def get_custom_overrides(owner_kind: str, owner_id: str, page_type: str) -> dict:
     sync_local_cache("customizations", _customizations_cache)
     key = _customization_key(owner_kind, owner_id, page_type)
     cached = _customizations_cache.get(key)
     if cached is not None:
         return cached
     result = {"css": "", "js": ""}
     if "user_customizations" in db.tables:
         prefs = get_customization_prefs(owner_kind, owner_id)
         scopes = (CUSTOMIZATION_GLOBAL_SCOPE, page_type)
         rows = db["user_customizations"].find(
             owner_kind=owner_kind,
             owner_id=owner_id,
             enabled=1,
             deleted_at=None,
         )
         pieces: dict[str, dict[str, str]] = {lang: {} for lang in CUSTOMIZATION_LANGS}
         for row in rows:
             lang = row.get("lang")
             scope = row.get("scope")
             if lang not in pieces or scope not in scopes:
                 continue
             if scope == CUSTOMIZATION_GLOBAL_SCOPE and prefs["disable_global"]:
                 continue
             if scope != CUSTOMIZATION_GLOBAL_SCOPE and prefs["disable_pagetype"]:
                 continue
             pieces[lang][scope] = row.get("code") or ""
         for lang in CUSTOMIZATION_LANGS:
             ordered = [pieces[lang][scope] for scope in scopes if scope in pieces[lang]]
             result[lang] = "\n".join(part for part in ordered if part.strip())
     _customizations_cache.set(key, result)
     return result
 def get_custom_override(
     owner_kind: str, owner_id: str, scope: str, lang: str
 ) -> dict | None:
     if "user_customizations" not in db.tables:
         return None
     return db["user_customizations"].find_one(
         owner_kind=owner_kind,
         owner_id=owner_id,
         scope=scope,
         lang=lang,
         deleted_at=None,
     )
 def list_custom_overrides(owner_kind: str, owner_id: str) -> list:
     if "user_customizations" not in db.tables:
         return []
     return list(
         db["user_customizations"].find(
             owner_kind=owner_kind, owner_id=owner_id, deleted_at=None
         )
     )
 def set_custom_override(
     owner_kind: str, owner_id: str, scope: str, lang: str, code: str
 ) -> dict:
     from devplacepy.utils import generate_uid
     table = get_table("user_customizations")
     now = datetime.now(timezone.utc).isoformat()
     existing = table.find_one(
         owner_kind=owner_kind, owner_id=owner_id, scope=scope, lang=lang
     )
     if existing:
         record = {
             "id": existing["id"],
             "code": code,
             "enabled": 1,
             "updated_at": now,
             "deleted_at": None,
             "deleted_by": None,
         }
         table.update(record, ["id"])
         result = {**existing, **record}
     else:
         result = {
             "uid": generate_uid(),
             "owner_kind": owner_kind,
             "owner_id": owner_id,
             "scope": scope,
             "lang": lang,
             "code": code,
             "enabled": 1,
             "created_at": now,
             "updated_at": now,
             "deleted_at": None,
             "deleted_by": None,
         }
         table.insert(result)
     bump_cache_version("customizations")
     return result
 def delete_custom_override(
     owner_kind: str,
     owner_id: str,
     scope: str | None = None,
     lang: str | None = None,
     deleted_by: str | None = None,
 ) -> int:
     if "user_customizations" not in db.tables:
         return 0
     criteria: dict = {"owner_kind": owner_kind, "owner_id": owner_id}
     if scope is not None:
         criteria["scope"] = scope
     if lang is not None:
         criteria["lang"] = lang
     count = soft_delete(
         "user_customizations", deleted_by or f"{owner_kind}:{owner_id}", **criteria
     )
     bump_cache_version("customizations")
     return int(count)