"""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"},)