hap-cli 0.9.1__tar.gz → 0.9.2__tar.gz

{hap_cli-0.9.1 → hap_cli-0.9.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hap-cli
-Version: 0.9.1
+Version: 0.9.2
 Summary: CLI harness for Mingdao HAP - Enterprise no-code platform
 Author: hap-cli
 License: Apache-2.0

{hap_cli-0.9.1 → hap_cli-0.9.2}/app_live_tests/smoke.py

@@ -226,6 +226,146 @@ def case_custom_action(app_id: str, section_id: str) -> None:
     hap(["worksheet", "delete", ws_id, "-a", app_id, "-y"], check=False)
 
 
+def case_custom_action_update(app_id: str, section_id: str) -> None:
+    """bug #455751: --action-spec with --btn-id edits the action in place."""
+    print("scenario: custom-action update by id")
+    ws_id = _make_worksheet(app_id, section_id, "LT-action-update")
+    try:
+        ok, res = _try(["worksheet", "create-custom-action", ws_id, "-a",
+                        app_id, "--action-spec", json.dumps(
+                            {"name": "ORIGINAL", "type": "triggerWorkflow",
+                             "color": "#2196F3"})])
+        check("update: workflow action created", ok, str(res)[:160])
+        btn_id = res.get("actionId") if ok else ""
+        proc_id = res.get("processId") if ok else ""
+        ok, res = _try(["worksheet", "create-custom-action", ws_id, "-a",
+                        app_id, "--btn-id", btn_id, "--action-spec",
+                        json.dumps({"name": "UPDATED"})])
+        check("update: edit succeeds", ok, str(res)[:160])
+        check("update: the id is unchanged",
+              ok and res.get("actionId") == btn_id, str(res)[:160])
+        check("update: the same workflow is reported",
+              ok and res.get("processId") == proc_id, str(res)[:160])
+        acts = _actions(ws_id)
+        check("update: still one action", len(acts) == 1,
+              str([(a.get("btnId"), a.get("name")) for a in acts]))
+        got = acts[0] if acts else {}
+        check("update: renamed in place",
+              got.get("btnId") == btn_id and got.get("name") == "UPDATED",
+              str((got.get("btnId"), got.get("name"))))
+        check("update: unnamed settings kept",
+              got.get("color") == "#2196F3" and got.get("clickType") == 1,
+              str((got.get("color"), got.get("clickType"))))
+        wf = [r for r in _workflow_rows(app_id)
+              if r.get("id") == proc_id or r.get("processId") == proc_id]
+        check("update: the action's workflow survives", bool(wf),
+              proc_id)
+
+        # A fill action edited by id stays a fill action and keeps its fields.
+        title = next((c["controlId"] for c in _fields(ws_id)
+                      if c.get("attribute") == 1), "")
+        ok, res = _try(["worksheet", "create-custom-action", ws_id, "-a",
+                        app_id, "--action-spec", json.dumps(
+                            {"name": "FILL", "type": "updateCurrentRecord",
+                             "updateFields": [title]})])
+        fill_id = res.get("actionId") if ok else ""
+        ok, res = _try(["worksheet", "create-custom-action", ws_id, "-a",
+                        app_id, "--btn-id", fill_id, "--action-spec",
+                        json.dumps({"name": "FILL2"})])
+        check("update: fill action edit succeeds", ok, str(res)[:160])
+        acts = _actions(ws_id)
+        fill = next((a for a in acts if a.get("btnId") == fill_id), {})
+        check("update: two actions after editing the second", len(acts) == 2,
+              str([(a.get("btnId"), a.get("name")) for a in acts]))
+        check("update: fill action keeps its kind and field",
+              fill.get("name") == "FILL2" and fill.get("clickType") == 3
+              and [w.get("controlId") for w in fill.get("writeControls")
+                   or []] == [title],
+              str((fill.get("name"), fill.get("clickType"),
+                   fill.get("writeControls"))))
+
+        ok, res = _try(["worksheet", "create-custom-action", ws_id, "-a",
+                        app_id, "--btn-id", "000000000000000000000000",
+                        "--action-spec", json.dumps({"name": "GHOST"})])
+        check("update: unknown id is refused", not ok, str(res)[:160])
+        check("update: nothing created for an unknown id",
+              len(_actions(ws_id)) == 2, str(len(_actions(ws_id))))
+    finally:
+        hap(["worksheet", "delete", ws_id, "-a", app_id, "-y"], check=False)
+
+
+def case_hidden_defaults(app_id: str, section_id: str) -> None:
+    """bug #455757: a hidden field's default goes in with a new record.
+
+    The form submits every non-empty cell on create, hidden ones included,
+    so the defaults the CLI fills in must not be judged as the caller
+    writing a hidden field. Writing one yourself is still refused.
+    """
+    print("scenario: hidden defaults on create")
+    ws_id = _make_worksheet(app_id, section_id, "LT-hidden-defaults")
+
+    def static(value):
+        return {"defsource": json.dumps(
+            [{"cid": "", "rcid": "", "staticValue": value}])}
+    try:
+        ok, res = _try(["worksheet", "add-fields", ws_id, "--controls",
+                        json.dumps([
+                            {"type": 2, "controlName": "Stage",
+                             "fieldPermission": "110",
+                             "advancedSetting": static("Draft")},
+                            {"type": 2, "controlName": "Status",
+                             "fieldPermission": "110",
+                             "advancedSetting": static("Open")}])])
+        check("hidden: fields added", ok, str(res)[:160])
+        ids = {c.get("controlName"): c.get("controlId")
+               for c in _fields(ws_id)}
+        name_id = next((c["controlId"] for c in _fields(ws_id)
+                        if c.get("attribute") == 1), "")
+        stage, status = ids.get("Stage"), ids.get("Status")
+
+        ok, res = _try(["worksheet", "record", "create", ws_id, "-a", app_id,
+                        "--fields-json", json.dumps(
+                            [{"id": name_id, "value": "visible-only"}])])
+        check("hidden: create with only the visible field succeeds", ok,
+              str(res)[:200])
+        row_id = ((res.get("data") or {}).get("rowid")
+                  if ok and isinstance(res, dict) else "")
+        got = (hap(["worksheet", "record", "get", ws_id, row_id, "-a",
+                    app_id]) or {}) if row_id else {}
+        got = got.get("data", got) if isinstance(got, dict) else {}
+        check("hidden: the hidden defaults were stored",
+              got.get(stage) == "Draft" and got.get(status) == "Open",
+              str({k: got.get(k) for k in (name_id, stage, status)}))
+
+        ok, res = _try(["worksheet", "record", "create", ws_id, "-a", app_id,
+                        "--fields-json", json.dumps(
+                            [{"id": name_id, "value": "sneaky"},
+                             {"id": stage, "value": "Won"}])])
+        check("hidden: writing a hidden field yourself is refused",
+              not ok and "Stage" in str(res) and "Status" not in str(res),
+              str(res)[:240])
+
+        rows = json.dumps([{name_id: "batch-1"}, {name_id: "batch-2"}])
+        ok, res = _try(["worksheet", "record", "batch-create", ws_id,
+                        "-a", app_id, "--rows", rows])
+        check("hidden: batch create with only visible fields succeeds", ok,
+              str(res)[:200])
+        rows = json.dumps([{name_id: "batch-3"},
+                           {name_id: "batch-4", stage: "Won"}])
+        ok, res = _try(["worksheet", "record", "batch-create", ws_id,
+                        "-a", app_id, "--rows", rows])
+        check("hidden: batch writing a hidden field is refused on its row",
+              not ok and "row 2" in str(res) and "row 1" not in str(res),
+              str(res)[:240])
+        listed = (hap(["worksheet", "record", "list", ws_id, "-a", app_id])
+                  or {}).get("rows") or []
+        blob = json.dumps(listed, ensure_ascii=False)
+        check("hidden: the refused batch wrote nothing",
+              "batch-3" not in blob and "batch-1" in blob, blob[:200])
+    finally:
+        hap(["worksheet", "delete", ws_id, "-a", app_id, "-y"], check=False)
+
+
 def _items(app_id: str) -> dict[str, str]:
     """All sidebar items (worksheets, pages, chatbots) name -> id."""
     detail = hap(["app", "info", "-a", app_id])
@@ -3397,6 +3537,71 @@ def case_fb_subtable_read(app_id: str, section_id: str) -> None:
         hap(["worksheet", "delete", parent, "--yes"], check=False)
 
 
+def case_editor_inline_subtable(app_id: str, section_id: str) -> None:
+    """Bug #455768: edit-spec field ops on an inline sub-table's own sheet."""
+    print("\nscenario: editor field ops on an inline sub-table (#455768)")
+    import json as _json
+    name = "BUG455768-sub-parent"
+    parent = _make_worksheet(app_id, section_id, name)
+    check("inline-subtable: a throwaway parent was created", bool(parent))
+    if not parent:
+        return
+    try:
+        hap(["worksheet", "update-fields", parent, "--title-name", "名称",
+             "--no-verify", "--fields", _json.dumps([
+                 {"type": "TEXT", "name": "名称"},
+                 {"type": "SUB_LIST", "name": "内嵌明细", "child_fields": [
+                     {"type": "TEXT", "name": "行名称"},
+                     {"type": "NUMBER", "name": "行数量"}]},
+             ], ensure_ascii=False)], check=False)
+        child = next((c.get("dataSource") for c in _fields(parent)
+                      if c.get("type") == 34), "")
+        check("inline-subtable: the parent names its child sheet",
+              bool(child), str(child))
+        if not child:
+            return
+
+        def _child_cols() -> list[dict]:
+            got = hap(["worksheet", "fields", child, "--raw",
+                       "--parent", parent], check=False)
+            return [c for c in got if len(c.get("controlId") or "") == 24] \
+                if isinstance(got, list) else []
+
+        rc, out, err = editor_apply({"app": app_id, "ops": [
+            {"type": "field.update", "worksheet": child, "field": "行名称",
+             "set": {"hint": "按id改"}}]})
+        check("inline-subtable: field.update by sheet id applies", rc == 0,
+              (err or out)[-300:])
+        cols = {c["controlName"]: c for c in _child_cols()}
+        check("inline-subtable: the hint reads back",
+              (cols.get("行名称") or {}).get("hint") == "按id改",
+              str(cols.get("行名称"))[:200])
+
+        rc, out, err = editor_apply({"app": app_id, "ops": [
+            {"type": "field.update", "worksheet": f"{name}/内嵌明细",
+             "field": "行数量", "rename": "数量", "set": {}},
+            {"type": "field.add", "worksheet": child,
+             "field": {"name": "行备注", "type": "Text"}},
+            {"type": "field.reorder", "worksheet": child,
+             "order": ["行备注", "数量"]},
+            {"type": "field.delete", "worksheet": child, "field": "行名称",
+             "confirm": True}]})
+        check("inline-subtable: add / reorder / delete apply", rc == 0,
+              (err or out)[-300:])
+        names = [c["controlName"] for c in
+                 sorted(_child_cols(), key=lambda c: c.get("row", 0))]
+        check("inline-subtable: columns read back renamed, added, "
+              "reordered and deleted", names == ["行备注", "数量"],
+              str(names))
+        sub = next((c for c in _fields(parent) if c.get("type") == 34), {})
+        shown = {c["controlId"]: c["controlName"] for c in _child_cols()}
+        check("inline-subtable: the new column is shown in the sub-table",
+              [shown.get(i) for i in sub.get("showControls") or []]
+              == ["行备注", "数量"], str(sub.get("showControls")))
+    finally:
+        hap(["worksheet", "delete", parent, "-a", app_id, "-y"], check=False)
+
+
 def case_fb_subgroups(app_id: str, section_id: str) -> None:
     """WO-FB 3.1: the editor can see worksheets in second-level groups."""
     print("\nscenario: sub-group visibility (WO-FB 3.1)")
@@ -4546,6 +4751,8 @@ _CASES = {
     "view": case_view,
     "role": case_role,
     "custom-action": case_custom_action,
+    "custom-action-update": case_custom_action_update,
+    "hidden-defaults": case_hidden_defaults,
     "chatbot": case_chatbot,
     "custom-page": case_custom_page,
     "component": case_component,
@@ -4585,6 +4792,7 @@ _CASES = {
     "fb-layout-check": case_fb_layout_check,
     "fb-pair-relation": case_fb_pair_relation,
     "fb-subtable-read": case_fb_subtable_read,
+    "editor-inline-subtable": case_editor_inline_subtable,
     "fb-subgroups": case_fb_subgroups,
     "fb-button-target": case_fb_button_target,
     "g6-advanced-fields": case_g6_advanced_fields,

{hap_cli-0.9.1 → hap_cli-0.9.2}/hap_cli/__init__.py

@@ -3,7 +3,7 @@
 import sys as _sys
 import types as _types
 
-__version__ = "0.9.1"
+__version__ = "0.9.2"
 
 # The command tree used to live in hap_cli/hap_cli.py. A module named
 # after the package it sits in shadows that package: run python with the

{hap_cli-0.9.1 → hap_cli-0.9.2}/hap_cli/commands/worksheet_cmd.py

@@ -1299,7 +1299,7 @@ def worksheet_save_button(ctx, worksheet_id, btn_config, action_spec,
             eff_app = app_id or getattr(session, "default_app_id", "") or ""
             data = ws_mod.create_custom_action(
                 session, worksheet_id, json.loads(action_spec),
-                app_id=eff_app,
+                app_id=eff_app, btn_id=btn_id,
             )
         else:
             btn_data = json.loads(btn_config)

{hap_cli-0.9.1 → hap_cli-0.9.2}/hap_cli/core/editor/ops.py

@@ -15,6 +15,8 @@ the plain CLI commands — see ``editspec.RETIRED_OPS``.
 """
 from __future__ import annotations
 
+import json
+import uuid
 from typing import Any, Callable
 
 from hap_cli.core import page as page_mod
@@ -31,6 +33,61 @@ def _ws_field_save(s, ws_id, controls):
     return ws_mod.save_controls(s, ws_id, controls)
 
 
+# ── inline sub-table sheets: written through the parent (bug #455768) ───
+# Such a sheet cannot be saved on its own; the product edits its columns
+# as the parent's sub-table column ``relationControls`` and saves the
+# parent. See ``AppIndex._subtable_map`` for the evidence.
+def _subtable_columns(idx: AppIndex, ws_ref: str):
+    """``(parent_id, parent controls, host column)`` copies, or None.
+
+    The host column and its ``relationControls`` are copied so the
+    mutation never leaks into the index cache.
+    """
+    host = idx.subtable_host(ws_ref)
+    if host is None:
+        return None
+    parent_id, column_id = host
+    controls = [dict(c) for c in idx.controls(parent_id)]
+    column = next((c for c in controls if c.get("controlId") == column_id),
+                  None)
+    if column is None:
+        raise ResolveError(
+            f"the sub-table column hosting worksheet {ws_ref!r} is gone")
+    column["relationControls"] = [dict(r) for r in
+                                  column.get("relationControls") or []]
+    return parent_id, controls, column
+
+
+def _sorts_of(column: dict) -> tuple[dict, list]:
+    adv = column.get("advancedSetting")
+    if isinstance(adv, str):
+        try:
+            adv = json.loads(adv) if adv else {}
+        except ValueError:
+            adv = {}
+    adv = dict(adv or {})
+    try:
+        sorts = json.loads(adv.get("controlssorts") or "[]")
+    except (TypeError, ValueError):
+        sorts = []
+    return adv, sorts if isinstance(sorts, list) else []
+
+
+def _set_display(column: dict, show: list, sorts: list) -> None:
+    """Keep ``showControls`` and ``controlssorts`` in step with the
+    columns — the product updates both on every add/delete/reorder, or
+    the sub-table renders its columns out of order (MDPublic
+    ConfigureControls.jsx ``updateControlsWithSorts``)."""
+    adv, _ = _sorts_of(column)
+    adv["controlssorts"] = json.dumps(sorts)
+    column["advancedSetting"] = adv
+    column["showControls"] = show
+
+
+def _sub_label(ws_ref: str) -> str:
+    return f"'{ws_ref}' (sub-table, saved through its parent)"
+
+
 def _far_worksheet_of(controls: list[dict], bridge_id: str) -> str:
     """The worksheet a bridge column reaches, from its own dataSource."""
     for c in controls:
@@ -144,6 +201,27 @@ def _field_add(op: dict[str, Any], idx: AppIndex) -> list[Action]:
     # place.
     control = lower_field(field)
 
+    sub = _subtable_columns(idx, op["worksheet"])
+    if sub is not None:
+        if control.get("type") == 34:
+            raise ResolveError(
+                f"cannot add sub-table {field.get('name')!r} inside the "
+                f"sub-table {op['worksheet']!r}")
+        parent_id, controls, column = sub
+        control = dict(control)
+        # A dashed placeholder: the server mints the real id and rewrites
+        # it in showControls too (verified live 2026-10-08).
+        control["controlId"] = str(uuid.uuid4())
+        column["relationControls"].append(control)
+        _, sorts = _sorts_of(column)
+        _set_display(column,
+                     list(column.get("showControls") or [])
+                     + [control["controlId"]],
+                     sorts + [control["controlId"]])
+        return [Action(f"add field '{op['field']['name']}' to "
+                       f"{_sub_label(op['worksheet'])}",
+                       lambda s: _ws_field_save(s, parent_id, controls))]
+
     # Mounting an existing worksheet is a two-step handshake — build the
     # SUB_LIST, then wire the child side's back-relation — and
     # `mount_existing_subtable` is the composite that already does both.
@@ -179,11 +257,20 @@ def _match_control(controls: list, ref: str) -> dict:
 
 def _field_update(op: dict[str, Any], idx: AppIndex) -> list[Action]:
     ws_id = idx.worksheet_id(op["worksheet"])
-    controls = [dict(c) for c in idx.controls(op["worksheet"])]
-    target = _match_control(controls, op["field"])
+    sub = _subtable_columns(idx, op["worksheet"])
+    if sub is not None:
+        parent_id, controls, column = sub
+        target = _match_control(column["relationControls"], op["field"])
+    else:
+        controls = [dict(c) for c in idx.controls(op["worksheet"])]
+        target = _match_control(controls, op["field"])
     if op.get("rename"):
         target["controlName"] = op["rename"]
     target.update(op.get("set", {}))
+    if sub is not None:
+        return [Action(f"update field '{op['field']}' on "
+                       f"{_sub_label(op['worksheet'])}",
+                       lambda s: _ws_field_save(s, parent_id, controls))]
     return [Action(f"update field '{op['field']}' on '{op['worksheet']}' "
                    f"(write-back {len(controls)} controls)",
                    lambda s: _ws_field_save(s, ws_id, controls))]
@@ -191,6 +278,21 @@ def _field_update(op: dict[str, Any], idx: AppIndex) -> list[Action]:
 
 def _field_delete(op: dict[str, Any], idx: AppIndex) -> list[Action]:
     ws_id = idx.worksheet_id(op["worksheet"])
+    sub = _subtable_columns(idx, op["worksheet"])
+    if sub is not None:
+        parent_id, controls, column = sub
+        gone = _match_control(column["relationControls"],
+                              op["field"]).get("controlId")
+        column["relationControls"] = [r for r in column["relationControls"]
+                                      if r.get("controlId") != gone]
+        _, sorts = _sorts_of(column)
+        _set_display(column,
+                     [i for i in column.get("showControls") or []
+                      if i != gone],
+                     [i for i in sorts if i != gone])
+        return [Action(f"delete field '{op['field']}' from "
+                       f"{_sub_label(op['worksheet'])}",
+                       lambda s: _ws_field_save(s, parent_id, controls))]
     controls = idx.controls(op["worksheet"])
     target = _match_control(controls, op["field"])
     remaining = [c for c in controls
@@ -202,7 +304,12 @@ def _field_delete(op: dict[str, Any], idx: AppIndex) -> list[Action]:
 
 def _field_reorder(op: dict[str, Any], idx: AppIndex) -> list[Action]:
     ws_id = idx.worksheet_id(op["worksheet"])
-    controls = [dict(c) for c in idx.controls(op["worksheet"])]
+    sub = _subtable_columns(idx, op["worksheet"])
+    if sub is not None:
+        parent_id, parent_controls, column = sub
+        controls = column["relationControls"]
+    else:
+        controls = [dict(c) for c in idx.controls(op["worksheet"])]
     by_ref: dict[str, dict] = {}
     for c in controls:
         for k in (c.get("controlId"), c.get("controlName"), c.get("alias")):
@@ -225,6 +332,15 @@ def _field_reorder(op: dict[str, Any], idx: AppIndex) -> list[Action]:
     for i, c in enumerate(ordered):
         c["row"] = i
         c["col"] = 0
+    if sub is not None:
+        column["relationControls"] = ordered
+        ids = [c.get("controlId") for c in ordered]
+        shown = set(column.get("showControls") or [])
+        _set_display(column, [i for i in ids if i in shown], ids)
+        return [Action(f"reorder {len(op['order'])} field(s) on "
+                       f"{_sub_label(op['worksheet'])}",
+                       lambda s: _ws_field_save(s, parent_id,
+                                                parent_controls))]
     return [Action(f"reorder {len(op['order'])} field(s) on '{op['worksheet']}'",
                    lambda s: _ws_field_save(s, ws_id, ordered))]
 

{hap_cli-0.9.1 → hap_cli-0.9.2}/hap_cli/core/editor/reader.py

@@ -13,6 +13,7 @@ reference an element a previous op just created (intra-spec chaining).
 """
 from __future__ import annotations
 
+import logging
 from typing import Any, Optional
 
 from hap_cli.core import app as app_mod
@@ -24,6 +25,8 @@ from hap_cli.core import workflow as wf_mod
 from hap_cli.core.editor.errors import ResolveError
 from hap_cli.core.session import Session
 
+logger = logging.getLogger("hap_cli.editor")
+
 
 class AppIndex:
     def __init__(self, session: Session, app_id: str, org_id: str = "",
@@ -35,6 +38,8 @@ class AppIndex:
         self._sections: list[dict] = []
         self._ws_controls: dict[str, list] = {}
         self._ws_views: dict[str, list] = {}
+        self._subtables: Optional[dict[str, dict]] = None
+        self._subtable_kind: dict[str, Any] = {}
         if app_detail:
             self._index_sections(app_detail)
 
@@ -115,6 +120,8 @@ class AppIndex:
             self._index_sections(detail)
         self._ws_controls.clear()
         self._ws_views.clear()
+        self._subtables = None
+        self._subtable_kind.clear()
         for attr in ("_roles_cache", "_btn_cache", "_wf_cache"):
             if hasattr(self, attr):
                 delattr(self, attr)
@@ -145,8 +152,133 @@ class AppIndex:
         for _sid, item in self._ws_items():
             if item.get("id") == ref or item.get("name") == ref:
                 return item.get("id")
+        child = self._subtable_sheet(ref)
+        if child:
+            return child
         raise ResolveError(f"worksheet {ref!r} not found in app {self.app_id}")
 
+    # ── inline sub-table sheets (not in navigation) ─────────────────
+    #
+    # An inline sub-table keeps its rows in a worksheet of its own, named
+    # by the sub-table column's ``dataSource``. That sheet never appears
+    # among the app's navigation items, so resolving only those left it
+    # unreachable (bug #455768: field.update on it -> "worksheet not
+    # found"). It is found here instead by scanning the type-34 columns
+    # of the navigation worksheets — only after a navigation miss, so an
+    # ordinary reference costs no extra request.
+    #
+    # The product edits such a sheet's columns through the parent: they
+    # ride in the parent column's ``relationControls`` and the parent's
+    # SaveWorksheetControls stores them (MDPublic src/pages/widgetConfig/
+    # widgetSetting/components/sublist/ConfigureControls.jsx
+    # handleControlDataChange / addControl / handleDeleteWidget; identical
+    # in pd-openweb). Reading or saving the child sheet directly is
+    # refused (verified live 2026-10-08: GetWorksheetControls -> 权限不足,
+    # SaveWorksheetControls sourceId=<child> -> code 16). So the index
+    # records which parent column hosts each child; field ops write
+    # through it (see ``ops._subtable_write``).
+    def _subtable_map(self) -> dict[str, dict]:
+        if self._subtables is not None:
+            return self._subtables
+        nav_ids = {item.get("id") for _sid, item in self._ws_items()}
+        found: dict[str, dict] = {}
+        for _sid, item in self._ws_items():
+            parent_id = item.get("id")
+            try:
+                controls = self.controls(parent_id)
+            except Exception as exc:  # noqa: BLE001 — one unreadable sheet
+                logger.warning("could not read controls of %s while looking "
+                               "for sub-table sheets: %s", parent_id, exc)
+                continue
+            for c in controls:
+                if c.get("type") != 34:
+                    continue
+                child = (c.get("dataSource") or "").strip("$")
+                # A sub-table showing a worksheet that is itself in
+                # navigation resolves there; a placeholder (dashed uuid)
+                # has no sheet yet.
+                if not child or child in nav_ids or "-" in child:
+                    continue
+                found.setdefault(child, {
+                    "parent": parent_id,
+                    "parent_name": item.get("name") or "",
+                    "column": c.get("controlId") or "",
+                    "column_name": c.get("controlName") or "",
+                })
+        self._subtables = found
+        return found
+
+    def _subtable_sheet(self, ref: str) -> str:
+        """Resolve ``ref`` to an inline sub-table sheet id, or "".
+
+        Accepts the sheet id, ``<parent>/<sub-table column>`` (each side
+        by name or id), or the bare column name when only one parent has
+        a sub-table column of that name.
+        """
+        subs = self._subtable_map()
+        if not subs:
+            return ""
+        hit = ""
+        if ref in subs:
+            hit = ref
+        elif "/" in ref:
+            parent_ref, col_ref = ref.rsplit("/", 1)
+            for child, h in subs.items():
+                if parent_ref in (h["parent"], h["parent_name"]) \
+                        and col_ref in (h["column"], h["column_name"]):
+                    hit = child
+                    break
+        else:
+            named = [child for child, h in subs.items()
+                     if ref == h["column_name"]]
+            if len(named) > 1:
+                where = ", ".join(f"'{subs[c]['parent_name']}/{ref}'"
+                                  for c in named)
+                raise ResolveError(
+                    f"worksheet {ref!r} is ambiguous: more than one "
+                    f"sub-table has that name — write {where}")
+            hit = named[0] if named else ""
+        if hit:
+            self._check_inline(hit)
+        return hit
+
+    def _check_inline(self, child: str) -> None:
+        """Refuse a sub-table that shows a worksheet from another app.
+
+        Its columns belong to that worksheet, which the parent's
+        write-back cannot change — the product only edits a sub-table's
+        columns when the sheet was created for it (GetWorksheetInfo
+        ``type`` 2; MDPublic sub_list.jsx: ``res.type === 2 ? 'new' :
+        'relate'``).
+        """
+        if child not in self._subtable_kind:
+            try:
+                info = ws_mod.get_worksheet_info(self.session, child)
+            except Exception as exc:  # noqa: BLE001
+                logger.warning("could not read sub-table sheet %s: %s",
+                               child, exc)
+                info = {}
+            payload = info.get("data") if isinstance(info, dict) \
+                and isinstance(info.get("data"), dict) else info
+            self._subtable_kind[child] = (payload or {}).get("type") \
+                if isinstance(payload, dict) else None
+        if self._subtable_kind[child] != ws_mod.SUBTABLE_WORKSHEET_TYPE:
+            h = self._subtables[child]
+            raise ResolveError(
+                f"worksheet {child!r} is shown by the sub-table "
+                f"'{h['parent_name']}/{h['column_name']}' but belongs to "
+                f"another app; edit its fields in that app")
+
+    def subtable_host(self, ref: str) -> Optional[tuple[str, str]]:
+        """``(parent worksheet id, sub-table column id)`` when ``ref`` is
+        an inline sub-table sheet, else ``None``."""
+        ws_id = self.worksheet_id(ref)
+        for _sid, item in self._ws_items():
+            if item.get("id") == ws_id:
+                return None
+        h = self._subtable_map().get(ws_id)
+        return (h["parent"], h["column"]) if h else None
+
     def worksheet_exists(self, ref: str) -> bool:
         try:
             self.worksheet_id(ref)
@@ -165,7 +297,11 @@ class AppIndex:
     def controls(self, ws_ref: str) -> list[dict]:
         ws_id = self.worksheet_id(ws_ref)
         if ws_id not in self._ws_controls:
-            data = ws_mod.get_worksheet_controls(self.session, ws_id, self.app_id)
+            host = self.subtable_host(ws_id)
+            # A sub-table's sheet is only readable with its parent named.
+            data = ws_mod.get_worksheet_controls(
+                self.session, ws_id, self.app_id,
+                parent_worksheet_id=host[0] if host else "")
             self._ws_controls[ws_id] = data if isinstance(data, list) else []
         return self._ws_controls[ws_id]
 

{hap_cli-0.9.1 → hap_cli-0.9.2}/hap_cli/core/record.py

@@ -1141,8 +1141,11 @@ def _enforce_rules(
         return None
     # Read-only / required are the form's own checks, not business rules;
     # they live in their own module so the two can be worked on apart.
+    # The cells filled in above are the form's, not the caller's: they
+    # go in even when hidden, so only what the caller wrote is judged.
     record_form_checks.check_form(session, worksheet_id, controls,
-                                  row_id=row_id, app_id=app_id)
+                                  row_id=row_id, app_id=app_id,
+                                  defaulted_ids=defaulted)
     check = record_rules.check_pending_write(
         session, worksheet_id, controls, row_id=row_id, app_id=app_id,
         defaulted_ids=defaulted)
@@ -1179,7 +1182,8 @@ def _enforce_rules_for_batch(
     # Same form checks as the single-row path, judged before any row is
     # written — see _enforce_rules.
     record_form_checks.check_form_batch(session, worksheet_id, items,
-                                        app_id=app_id)
+                                        app_id=app_id,
+                                        defaulted_ids=defaulted)
     rules, controls = record_rules.load_rules_and_fields(
         session, worksheet_id, app_id)
     merged = record_rules.RuleCheck()