loopable / api /tool_groups /views.py
fsanyoto's picture
Deploy AIOS web (React glide grid + FastAPI slice)
cf09724 verified
Raw History Blame Contribute Delete
13.6 kB
"""Saved View actions through the existing permission checks."""
import copy
import re
from fastapi import HTTPException
from core import external_tools
from . import legacy_action
# One line per refusal: why it was refused, then the call that would succeed.
SHARE_REFUSALS = {
"not_owner": "You cannot change who sees this View, so ask its owner or an Administrator to share it.",
"audience_not_allowed": ("Sharing with everyone is a choice a person makes on screen, "
"so name each person in entries instead."),
"blank_user": "An entry has an empty user, so set user to the username of an active person in this workspace.",
"grants_changed": ("This View's audience changed after it was read, "
"so call views share again without expect and confirm the new preview."),
"grant_exceeds_role": ("Can edit is above your own access to this View, "
"so set role to view for each new editor or ask its owner to grant edit."),
"grant_exceeds_audience": ("Only this View's owner or an Administrator can share it with everyone, "
"so name each person in entries instead."),
"revoke_not_yours": ("You can remove only people you added to this View, "
"so keep everyone else in entries and share again."),
"field_not_shared": ("This View shows a field that is still private to its creator, "
"so hide that field in the View or ask its creator to share it, then share again."),
"unknown_people": ("A person in entries has no active account in this workspace, "
"so set user to a username, not a display name or email."),
"forbidden": "Your account cannot share this View, so ask its owner or an Administrator to share it.",
"view_share_failed": "This View's access could not be saved, so send the same share call again.",
}
_SHARE_FIELDS = ("database", "view_id", "entries", "expect")
_CALL_FIELDS = ("action", "arguments", "intent", "about", "purpose")
def _share_refusal(code, status=403):
"""Raise the one-line refusal for a share code."""
import routes_shares
raise routes_shares.err(status, code, SHARE_REFUSALS[code])
def _listed(names):
names = list(names)
if len(names) < 2:
return "".join(names)
return ", ".join(names[:-1]) + " and " + names[-1]
def share_arguments_fix(call):
"""Name the first wrong part of a views share call and the shape that succeeds."""
shape = "each entry is user (a username) and role (view or edit)"
if not isinstance(call, dict):
return "The call is not an object, so send action share with arguments database, view_id and entries."
stray = [str(key) for key in call if key not in _CALL_FIELDS]
if stray:
return (_listed(stray) + (" sit" if len(stray) > 1 else " sits") + " beside action, so move "
+ ("them" if len(stray) > 1 else "it") + " inside arguments, which holds database, view_id, entries and optional expect.")
args = call.get("arguments")
if not isinstance(args, dict):
return "arguments is missing or not an object, so send arguments with database, view_id and entries."
unknown = [key for key in args if key not in _SHARE_FIELDS]
if unknown:
return (_listed(map(str, unknown)) + (" are not share arguments" if len(unknown) > 1 else " is not a share argument") + ", so send only database, view_id, "
"entries and optional expect, where " + shape + ".")
missing = [key for key in ("database", "view_id", "entries") if key not in args]
if missing:
return ("arguments has no " + " or ".join(missing) + ", so add " + ("them" if len(missing) > 1 else "it") + ": database and view_id are text, "
"and entries is a list where " + shape + ".")
for key in ("database", "view_id"):
if not isinstance(args[key], str) or not args[key].strip() or key == "view_id" and len(args[key]) > 120:
return key + " is not a usable id, so set it to the text id that the View list returns."
for key in ("entries", "expect"):
rows = args.get(key)
if key not in args:
continue
if not isinstance(rows, list):
return key + " is not a list, so send a list where " + shape + ", or [] to make the View private."
if len(rows) > 200:
return key + " names more than 200 people, so share with at most 200 people in one call."
for row in rows:
if not isinstance(row, dict):
return key + " holds a plain value, so send objects where " + shape + "."
extra = [name for name in row if name not in ("user", "role")]
if extra or "user" not in row or "role" not in row:
return (key + " has an entry with " + (_listed(map(str, extra)) or "a missing field")
+ ", so give every entry exactly user (a username) and role (view or edit).")
if not isinstance(row["user"], str) or not 1 <= len(row["user"]) <= 120:
return key + " has a user that is not a username, so set user to a username of 1 to 120 characters."
if row["role"] not in ("view", "edit"):
return key + " has a role other than view or edit, so set role to view for Can view or edit for Can edit."
return "The share arguments do not match, so send database, view_id and entries, where " + shape + "."
def _share_source(session, args):
"""Resolve source ownership on a detached canonical workspace before revealing the audience."""
import routes_external
import routes_shares
from core import shares
routes_external._assert_database_scope(session, args["database"])
snapshot = routes_shares._FieldReadSnapshot(session.runtime)
topic, source_owner, view = routes_shares._find_view_record(
session, args["view_id"], _snapshot=snapshot)
workspace = routes_shares._field_storage_keys(args["database"])[0]
# A missing View and another person's View read the same, so the refusal reveals nothing.
if not view or not source_owner or f"{topic}_table_workspace" != workspace:
_share_refusal("not_owner")
rec = shares.grants("view", args["view_id"], st=session.runtime)
if rec["owner"]:
allowed = shares.may_administer(
"view", args["view_id"], session.uname, is_admin=session.admin, st=session.runtime)
else:
allowed = session.admin or source_owner == session.uname
if not allowed:
_share_refusal("not_owner")
return snapshot, topic, source_owner, view, rec
def _receipt_access(ctx, args):
"""Check current source ownership and share authority without consuming workspace corrections."""
_share_source(ctx.session, args)
return True
def _unknown_people_refusal(unknown, people):
"""Name each unknown username and, for an exact display name match, the username to use."""
import routes_shares
names = {}
for username, row in people.items():
label = str(row.get("name") or "").strip().lower()
if label:
names.setdefault(label, []).append(username)
hints = [names[who][0] + " for " + str(people[names[who][0]].get("name"))
for who in unknown if len(names.get(who, ())) == 1]
fix = ("set user to " + ", ".join(hints)
+ (", and to a username for the rest" if len(hints) < len(unknown) else "")
if hints else "set user to a username, not a display name or email")
raise routes_shares.err(400, "unknown_people", "No active person in this workspace has the username "
+ ", ".join(unknown) + ", so " + fix + ".")
def share(ctx, args):
"""Replace a named audience through the on-screen share writer and its permission ceiling."""
import routes_external
import routes_shares
try:
return _share(ctx, args)
except HTTPException as exc:
error = (exc.detail.get("error") or {}) if isinstance(exc.detail, dict) else {}
code = error.get("code")
# A 403 without a published code reaches the AI as forbidden. It names the share fix.
if code == "forbidden" or (exc.status_code == 403 and code not in SHARE_REFUSALS
and code not in routes_external.MCP_RESULT_CODES):
raise routes_shares.err(403, "forbidden", SHARE_REFUSALS["forbidden"]) from exc
raise
def _share(ctx, args):
import routes_external
import routes_shares
from core import shares
session = ctx.session
routes_external._assert_write_scope(session, "views", {"action": "share", "arguments": args})
snapshot, topic, source_owner, view, rec = _share_source(session, args)
entries = copy.deepcopy(args["entries"])
if any(row["user"].strip().lower() in {shares.EVERYONE, "everyone"} for row in entries):
_share_refusal("audience_not_allowed", 400)
if any(not row["user"].strip() for row in entries):
raise routes_shares.err(400, "unknown_people", SHARE_REFUSALS["blank_user"])
people = {row["username"].strip().lower(): row for row in routes_shares._people(session.tenant)}
unknown = sorted({row["user"].strip().lower() for row in entries} - people.keys())
if unknown:
_unknown_people_refusal(unknown, people)
keys = routes_shares._view_field_keys(view)
definitions = routes_shares._view_field_definitions(
session, f"{topic}_table_workspace", keys, _snapshot=snapshot)
defs = {key: row[0] or {"key": key, "label": key} for key, row in definitions.items()}
receivers = {row["user"].strip().lower(): row["user"].strip().lower() for row in entries}
blocked = routes_shares._admin_walled(
session, routes_shares._field_storage_keys(f"{topic}_table_workspace")[2], defs, receivers)
try:
out = routes_shares._put_share(
"view", args["view_id"], {"entries": entries}, session,
_view_snapshot=snapshot, _source_owner=source_owner, _expect=args.get("expect"),
_notify=False)
except HTTPException as exc:
code = (exc.detail.get("error") or {}).get("code")
if code == "view_share_failed":
reference = re.search(r"\bVS-[0-9A-F]{8}\b", str((exc.detail.get("error") or {}).get("message") or ""))
raise routes_shares.err(exc.status_code, code, SHARE_REFUSALS[code] + (
" If it fails again, report reference " + reference[0] + "." if reference else "")) from exc
if code in SHARE_REFUSALS:
raise routes_shares.err(exc.status_code, code, SHARE_REFUSALS[code]) from exc
raise
name = str(view.get("name") or "A View")
audience = [{"user": row["user"], "name": people[row["user"]].get("name") or row["user"],
"role": row["role"], "hiddenFields": [
{"key": key, "name": str(defs[key].get("label") or key)}
for key, who in blocked.items() if row["user"] in who]}
for row in out["entries"]]
warnings = []
for row in audience:
role = "Can edit" if row["role"] == "edit" else "Can view"
hidden = ", ".join(field["name"] for field in row["hiddenFields"])
warnings.append(f"{row['name']} will have {role} on {name}"
+ (f" with hidden fields {hidden}." if hidden else "."))
if not audience:
warnings.append(f"{name} will be private.")
return {"view_id": args["view_id"], "view": {"id": args["view_id"], "name": name,
"database": args["database"], "owner": out["owner"]}, "audience": audience,
"current_entries": rec["entries"], "entries": out["entries"], "warnings": warnings}
_ENTRIES = {"type": "array", "maxItems": 200, "items": {"type": "object", "properties": {
"user": {"type": "string", "minLength": 1, "maxLength": 120},
"role": {"type": "string", "enum": ["view", "edit"]}},
"required": ["user", "role"], "additionalProperties": False}}
GROUP = {
"name": "views", "title": "Views",
"guide": "Create, change, delete or share Views with named people. Share returns a preview, and confirm_change applies it. An empty audience makes a View private. A person chooses sharing with everyone on screen. "
"Upsert preserves config.filters groups using conj and nodes, or a list with conj and children groups. "
"Root filterConj selects and or or for a list. Unsupported or lossy filter shapes refuse before saving.",
"actions": {
"upsert": legacy_action("view_upsert"),
"delete": legacy_action("view_delete", destructive=True),
"share_preview": legacy_action("view_share_preview"),
"share": {"read": False, "destructive": False, "confirm": True,
"schema": {"type": "object", "properties": {
"database": {"type": "string", "minLength": 1},
"view_id": {"type": "string", "minLength": 1, "maxLength": 120},
"entries": _ENTRIES, "expect": _ENTRIES},
"required": ["database", "view_id", "entries"], "additionalProperties": False},
"handler": share, "receipt_access": _receipt_access},
**{"view." + action: legacy_action(
"view_object", action=action,
read=action in external_tools._OBJECT_READ_ACTIONS["view_object"],
destructive=action == "delete") for action in external_tools._VIEW_ACTIONS},
},
}