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