File size: 12,287 Bytes
1ad1eea 868b75a 1ad1eea b2aa446 1ad1eea b2aa446 1ad1eea b2aa446 1ad1eea | 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 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 | """The workspace directory tool: the people of the caller's own workspace and their access.
R84: the list never crosses tenants. `users._tenant_accounts` is the one tenant wall.
R92: each entry carries role, modules, databases, row limits and hidden fields.
R108(c): a field or database the CALLER cannot see is never named.
Every entry is a whitelist projection: no password hash, salt, MFA secret, recovery code,
session epoch, phone, email or avatar leaves this module.
"""
import logging
from core import perm_scope, perms, users
_LOG = logging.getLogger(__name__)
HIDDEN_FIELD = "a hidden field"
LIMITED = "Limited by your access"
REFUSAL = "The directory of your workspace could not be read. Try again in a moment."
NOT_FOUND = "No one by that name uses Loopable in your workspace."
# Shell.tsx opens these workspace modules for every signed-in account.
_WORKSPACE_MODULES = ("Sheet", "Table", "App")
_OPS = {
"eq": "is", "neq": "is not", "contains": "contains", "doesNotContain": "does not contain",
"gt": "is more than", "gte": "is at least", "lt": "is less than", "lte": "is at most",
"within": "is within", "isAnyOf": "is one of", "isNoneOf": "is none of",
"hasAnyOf": "has any of", "hasAllOf": "has all of", "hasNoneOf": "has none of",
}
SCHEMA = {
"type": "object",
"description": ("List the people of your own workspace, with each person's role, what they "
"can open, their row limits and hidden fields."),
"properties": {"username": {"type": "string"}},
"additionalProperties": False,
}
_ADMITTED = {"who uses loopable here", "who uses loopable", "who uses loopable in my workspace",
"who is in my workspace", "who are the people in my workspace"}
def admits(question):
"""True for a directory question, so the router can skip its database match."""
import re
return " ".join(re.findall(r"\w+", str(question).casefold())) in _ADMITTED
class DirectoryUnavailable(ValueError):
"""The registry or the caller's own account could not be read. Fail closed."""
def _tenant(session):
want = str(getattr(session, "tenant", "") or "").strip().lower()
own = str((getattr(session, "user", None) or {}).get("tenant") or "").strip().lower()
if not want or (own and own != want):
raise DirectoryUnavailable(REFUSAL)
return want
def _accounts(session):
"""`[(username, record)]` of the caller's tenant. Refuses when the caller is not among them."""
tenant = _tenant(session)
accounts = users._tenant_accounts(tenant)
me = str(getattr(session, "uname", "") or "").strip().lower()
if not me or me not in {str(n).strip().lower() for n, _ in accounts}:
# An empty list is a failed read or a revoked caller. Never an answer.
raise DirectoryUnavailable(REFUSAL)
return sorted(accounts, key=lambda pair: str(pair[0]).lower())
def _lend(session):
from core import user_tables
return user_tables.lend_defs(session.runtime)
def _databases(session, st):
"""`[{key, label}]`: every database this tenant governs, topics and its own `ut_*` tables."""
from core import registry, user_tables
ut = user_tables.nav_entries(viewer=session.uname, is_admin=True, st=st)
topics = list(registry.governable_modules().values())
return perms.tenant_governable_modules(session.runtime, topics, ut_entries=ut)
def _modules(session):
"""`[{key, label}]`: the app surfaces this tenant is provisioned for."""
return [m for m in perms.governable_surface_modules()
if perms.tenant_has_module(session.runtime, m["key"])]
def _fields(principal, key, st):
"""`{field_key: label}` this principal may see on `key`, or None when unreadable."""
try:
rows = perm_scope.scoped_fields(principal, key, st=st)
except Exception: # noqa: BLE001
return None
return {str(f["key"]): str(f.get("label") or f["key"])
for f in rows or () if isinstance(f, dict) and f.get("key")}
def _name_field(seen, key):
"""The label of `key` when the caller can see it, else the hidden placeholder."""
return (seen or {}).get(str(key)) or HIDDEN_FIELD
def _value(leaf):
if isinstance(leaf.get("values"), list):
return ", ".join(str(v) for v in leaf["values"])
if leaf.get("op") == "between":
return f"{leaf.get('value')} and {leaf.get('value2')}"
return str(leaf.get("value") if leaf.get("value") is not None else "")
def _leaf_sentence(leaf, seen):
"""One plain sentence for a filter leaf, or None when it names a field the caller cannot see."""
col = str(leaf.get("colId") or "")
if col not in (seen or {}):
return None
rhs = leaf.get("rhs")
if isinstance(rhs, dict):
if str(rhs.get("colId") or "") not in seen:
return None
target = seen[str(rhs["colId"])]
else:
target = _value(leaf)
op = str(leaf.get("op") or "")
label = seen[col]
if op == "isEmpty":
return f"{label} is empty"
if op == "isNotEmpty":
return f"{label} is not empty"
if op == "between":
return f"{label} is between {target}"
if op in _OPS:
return f"{label} {_OPS[op]} {target}".rstrip()
return f"{label} has a ranking condition"
def _node_sentence(node, seen):
if not isinstance(node, dict):
return None
if isinstance(node.get("children"), list):
parts = [_node_sentence(child, seen) for child in node["children"]]
if not parts or any(p is None for p in parts):
return None
joiner = " or " if node.get("conj") == "or" else " and "
return "(" + joiner.join(parts) + ")" if len(parts) > 1 else parts[0]
return _leaf_sentence(node, seen)
def _filter_sentences(tree, seen, label):
"""Plain sentences for one stored filter tree. A leaf the caller cannot see reads LIMITED."""
if isinstance(tree, dict):
nodes = tree.get("nodes") if isinstance(tree.get("nodes"), list) else []
conj = "or" if tree.get("conj") == "or" else "and"
else:
nodes, conj = (tree if isinstance(tree, list) else []), "and"
parts = [_node_sentence(n, seen) for n in nodes]
if not parts:
return []
prefix = f"{label}: " if label else ""
if conj == "or":
if any(p is None for p in parts):
return [LIMITED]
return [prefix + " or ".join(parts)]
return [LIMITED if p is None else prefix + p for p in parts]
#: The Odoo field a legacy team scope narrows, and Odoo's own name for it (R66).
_TEAM_TABLE, _TEAM_FIELD, _TEAM_LABEL = "ut_odoo_orders", "team", "Sales team"
def _team_label(st, caller):
"""The caller-visible team label, with Odoo's name for an absent field."""
try:
from core import user_tables
fields = (user_tables.get_one(_TEAM_TABLE, st) or {}).get("fields") or ()
field = next((f for f in fields if isinstance(f, dict) and f.get("key") == _TEAM_FIELD), {})
if field:
return _name_field(_fields(caller, _TEAM_TABLE, st), _TEAM_FIELD)
return _TEAM_LABEL
except Exception: # noqa: BLE001
return _TEAM_LABEL
def _legacy_limits(rec, st=None, caller=None):
out = []
labels = users.allowed_bus_labels(rec)
if "All" not in labels and labels:
out.append(f"{_team_label(st, caller)} is " + " or ".join(labels))
agent = perms.scope_agent(rec)
if agent:
out.append(f"Sales agent is {agent}")
return out
def _entry(session, uname, rec, ctx):
"""The whitelist projection of one colleague, as the caller is allowed to see it."""
principal = users._public(uname, rec)
st, caller = ctx["st"], session.user
admin = perms.is_admin(principal)
modules = list(_WORKSPACE_MODULES) + [m["label"] for m in ctx["modules"]
if admin or perm_scope.nav_may_open(principal, m["key"], st=st)]
named, unnamed, limits, hidden = [], 0, [], []
for db in ctx["databases"]:
key = db["key"]
if not (admin or perm_scope.may_read(principal, key, st=st)):
continue
seen = ctx["seen"].get(key)
if seen is None:
# The caller cannot read this database: never name it, count it.
unnamed += 1
seen = {}
else:
named.append(db["label"])
if admin:
continue
stored = perm_scope.entry(principal, key) or {}
if perm_scope.is_migrated(principal) and stored.get("filter"):
limits.extend(_filter_sentences(stored["filter"], seen,
db["label"] if key in ctx["seen"] else ""))
theirs = _fields(principal, key, st)
keys = [str(k) for k in (stored.get("hiddenFields") or ()) if k]
if theirs is not None:
keys += [k for k in seen if k not in theirs and k not in keys]
hidden.extend(_name_field(seen, k) for k in keys)
if unnamed:
named.append(f"{unnamed} database{'' if unnamed == 1 else 's'} you cannot open")
if not admin and not perm_scope.is_migrated(principal):
limits = _legacy_limits(rec, st, caller) + limits
return {"username": str(rec.get("username_original") or uname),
"name": str(rec.get("name") or uname),
"role": "Administrator" if admin else "Member",
"modules": modules, "databases": named,
"rowLimits": limits, "hiddenFields": hidden}
def _context(session):
st = _lend(session)
databases = [d for d in _databases(session, st) if isinstance(d, dict) and d.get("key")]
caller = session.user
seen = {}
for db in databases:
if perm_scope.may_read(caller, db["key"], st=st):
seen[db["key"]] = _fields(caller, db["key"], st) or {}
return {"st": st, "databases": databases, "modules": _modules(session), "seen": seen}
def people(session):
"""Every active account of the caller's own workspace. Raises DirectoryUnavailable."""
try:
accounts = _accounts(session)
ctx = _context(session)
return [_entry(session, n, rec, ctx) for n, rec in accounts]
except DirectoryUnavailable:
raise
except Exception as exc: # noqa: BLE001
_LOG.warning("Workspace directory read failed (%s)", type(exc).__name__)
raise DirectoryUnavailable(REFUSAL) from exc
def _colleague(session, username):
"""One same-tenant account, or None when nobody matches. Raises DirectoryUnavailable."""
want = str(username or "").strip().casefold()
if not want:
return None
try:
accounts = _accounts(session)
match = [(n, rec) for n, rec in accounts
if want in {str(n).casefold(), str(rec.get("username_original") or "").casefold(),
str(rec.get("name") or "").strip().casefold()}]
if not match:
return None
return _entry(session, match[0][0], match[0][1], _context(session))
except DirectoryUnavailable:
raise
except Exception as exc: # noqa: BLE001
_LOG.warning("Workspace directory lookup failed (%s)", type(exc).__name__)
raise DirectoryUnavailable(REFUSAL) from exc
def colleague(session, username):
"""One same-tenant active account by username or name, or None. Never crosses tenants."""
try:
return _colleague(session, username)
except DirectoryUnavailable:
return None
def workspace_people(session, args):
"""The `workspace_people` tool: the caller's workspace roster, or one person in it."""
args = args if isinstance(args, dict) else {}
want = str(args.get("username") or "").strip()
try:
if want:
one = _colleague(session, want)
if one is None:
return {"people": [], "note": NOT_FOUND}
return {"people": [one]}
return {"people": people(session)}
except DirectoryUnavailable:
return {"ok": False, "refused": REFUSAL}
TOOLS = ({"name": "workspace_people", "schema": SCHEMA, "fn": workspace_people, "effect": "read"},)
|