loopable / api /tool_groups /views.py
fsanyoto's picture
Deploy AIOS web (React glide grid + FastAPI slice)
cf09724 verified
Raw History Blame
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},
},
}