Spaces:
Running on CPU Upgrade
Running on CPU Upgrade
File size: 8,552 Bytes
8133df9 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 | """Member data permissions for administrators, through the on-screen permission writer."""
import copy
from fastapi import HTTPException
FORBIDDEN = "Only an administrator can read or change a member's data permissions."
WIDENING_WARNING = ("This change removes the business unit restriction on {database}, "
"so confirm_change needs the confirmation phrase.")
def _require_admin(session):
"""Refuse a caller without the administrator role before any account is read."""
import routes_admin
from deps import err
try:
routes_admin.admin_gate(session)
except HTTPException as exc:
raise err(403, "forbidden", FORBIDDEN) from exc
def _account(session, username):
"""Read an active account strictly within this session's workspace."""
import routes_admin
from core import store
from deps import err
uname = str(username).strip().lower()
tenant = str(session.runtime.tenant.slug).strip().lower()
if routes_admin._tenant_of(session.user) != tenant:
raise err(403, "forbidden", FORBIDDEN)
rec = (store.get("users", fresh=True) or {}).get(uname)
if not isinstance(rec, dict) or not rec.get("active", True) or routes_admin._tenant_of(rec) != tenant:
raise err(404, "no_such_user", "That account is not active in this workspace.")
return uname, rec
def read_permissions(ctx, args):
"""Return the member's database blocks without running the editor's write-on-read cleanup."""
import routes_admin
import routes_external
from core import external_access, perm_scope, perms, users
from deps import err
session = ctx.session
_require_admin(session)
database = args.get("database")
uname, rec = _account(session, args["username"])
member = users._public(uname, rec)
is_admin = perms.is_admin(member)
scope = routes_external._key_scope(session)[1]
rows = []
for module in routes_admin._perm_modules(session):
key = module["key"]
if database not in (None, key) or not external_access.database_allowed(scope, key):
continue
entry = perm_scope.entry(member, key) or {}
rows.append({"database": key, "label": module.get("label") or key,
"access": perm_scope.may_read(member, key, st=session.runtime),
"filter": None if is_admin else copy.deepcopy(entry.get("filter")),
"hiddenFields": [] if is_admin else list(entry.get("hiddenFields") or [])})
if database is not None and not rows:
raise err(404, "no_database", "That database is not available in this workspace.")
return {"username": uname, "is_admin": is_admin,
"access_state": routes_admin.database_access_token(rec), "rows": rows, "count": len(rows)}
def _plan(session, args):
"""Validate one database block in the writer's order and diff it, writing nothing."""
import routes_admin
import routes_external
from core import users
from deps import err
uname, rec = _account(session, args["username"])
key = str(args["database"]).strip()
entry = args["entry"]
if uname == session.uname:
raise err(400, "self_perms", "Ask another administrator to change your access.")
governed = {row["key"] for row in routes_admin._perm_modules(session)}
if key not in governed:
raise err(404, "no_database", "That database is not available in this workspace.")
token = routes_admin.database_access_token(rec)
if args.get("expect") not in (None, token):
# The confirm replays this plan with the pinned expect, so a changed account reads as stale.
raise err(409, "confirmation_stale", "This member's access changed. Read it again and preview the change again.")
submitted = {field: copy.deepcopy(entry[field]) for field in users.DATABASE_ENTRY_KEYS if field in entry}
cleaned = routes_admin._clean_perms({key: submitted}, governed_keys=governed, session=session,
stored=rec.get("perms"))
folded = routes_admin._fold_legacy_scope(rec, cleaned)
try:
routes_admin._guard_bu_widening(rec, folded, False)
widening = False
except HTTPException as exc:
if ((exc.detail or {}).get("error") or {}).get("code") != "bu_widening":
raise
widening = True
candidate = {field: copy.deepcopy(folded[key][field]) for field in users.DATABASE_ENTRY_KEYS}
stored = (rec.get("perms") or {}).get(key)
before = copy.deepcopy(stored) if isinstance(stored, dict) else None
after = {**(before or {}), **candidate}
diff, _ = routes_external._diff_documents(
{f"members/{uname}/perms/{key}": {"before": before, "after": after}}, limit=None)
return {"diff": diff, "warnings": [WIDENING_WARNING.format(database=key)] if widening else [],
"affected": {"ids": [uname, key], "count": len(diff), "ranges": []},
"revision": {"account": uname, "access_state": token},
"expect": token, "widening": widening,
"username": uname, "database": key, "before": before, "after": after}
def set_permissions(ctx, args):
"""Preview a database block, then apply it through the editor's compare-and-set on confirm."""
import routes_admin
import routes_external
session = ctx.session
_require_admin(session)
if isinstance(session.runtime, routes_external._PreviewRuntime):
return _plan(session, args)
out = routes_admin.set_database_block(
session, args["username"], args["database"], args["entry"],
expect=args.get("expect"), confirm_widen=bool(args.get("confirm_widen")))
return {**out, "revision": {"account": out["username"], "access_state": out["access_state"]}}
def _receipt_access(ctx, args):
"""A committed change stays readable to an administrator of this workspace."""
_require_admin(ctx.session)
_account(ctx.session, args["username"])
return True
_FILTER = {"type": ["object", "null"],
"description": "Row filter as conj and nodes, where each node is a colId, op and value leaf. null removes it."}
_ENTRY = {"type": "object", "properties": {
"access": {"type": "boolean"},
"filter": _FILTER,
"hiddenFields": {"type": "array", "maxItems": 500, "items": {"type": "string", "minLength": 1, "maxLength": 200}}},
"required": ["access"], "additionalProperties": False}
_USERNAME = {"type": "string", "minLength": 1, "maxLength": 120}
_DATABASE = {"type": "string", "minLength": 1, "maxLength": 200}
GROUP = {
"name": "members", "title": "Members",
"guide": "Administrators read and set a member's data permissions per database: access, row filter and hidden fields. "
"set_permissions returns a preview with the before and after block, and confirm_change applies it. "
"A change that removes a business unit restriction needs the confirmation phrase. "
"You cannot change your own permissions.",
"actions": {
"permissions": {"read": True, "destructive": False, "confirm": False,
"schema": {"type": "object", "properties": {
"username": _USERNAME, "database": _DATABASE},
"required": ["username"], "additionalProperties": False},
"handler": read_permissions,
"example": {"username": "<username>", "database": "<database>"}},
"set_permissions": {"read": False, "destructive": False, "confirm": True,
"schema": {"type": "object", "properties": {
"username": _USERNAME, "database": _DATABASE, "entry": _ENTRY,
"expect": {"type": "string", "minLength": 1, "maxLength": 128,
"description": "access_state from permissions. The preview sets it."},
"confirm_widen": {"type": "boolean",
"description": "The preview sets it when the change removes a business unit restriction."}},
"required": ["username", "database", "entry"], "additionalProperties": False},
"handler": set_permissions, "receipt_access": _receipt_access,
"example": {"username": "<username>", "database": "<database>",
"entry": {"access": True, "filter": None, "hiddenFields": []}}},
},
}
|