dwf-platform-cli 0.2.0__py3-none-any.whl

dwf_cli/cli/formmodel.py

@@ -0,0 +1,1007 @@
+from __future__ import annotations
+
+import json as json_mod
+from enum import Enum
+from pathlib import Path
+from typing import Annotated, Any
+
+import typer
+from rich.table import Table
+
+from dwf_cli.api import formmodel as formmodel_api
+from dwf_cli.cli._common import (
+    get_client,
+    get_console,
+    handle_error,
+    is_tty,
+    resolve_format,
+    validate_path,
+)
+from dwf_cli.core.errors import ConflictError, DWFError
+from dwf_cli.core.output import OutputFormat
+
+_HELP_CONTEXT_SETTINGS = {"help_option_names": ["-h", "--help"]}
+
+app = typer.Typer(
+    help="Form model management.\n\n"
+    "Examples:\n"
+    "  dwf-cli formmodel view list -c User\n"
+    "  dwf-cli formmodel view list -t standalone\n"
+    "  dwf-cli formmodel view create -c User -n create --v3-content '{}'",
+    context_settings=_HELP_CONTEXT_SETTINGS,
+)
+
+_view_sub = typer.Typer(
+    help="View management.", context_settings=_HELP_CONTEXT_SETTINGS
+)
+
+app.add_typer(_view_sub, name="view")
+
+DRY_RUN_EXIT_CODE = 10
+
+
+class ViewType(str, Enum):
+    class_ = "class"
+    standalone = "standalone"
+
+
+class FormDeviceType(str, Enum):
+    pc = "actPc"
+    ipad = "actIpad"
+    ipad_h = "actIpadH"
+    phone = "actPhone"
+    phone_h = "actPhoneH"
+    mobile = "actMobile"
+
+
+class FormType(str, Enum):
+    PC = "PC"
+    Mobile = "Mobile"
+
+
+_STANDALONE_CLASS_NAME = "DWFDesign"
+
+
+def _extract_items(result: Any) -> list[dict[str, Any]]:
+    if isinstance(result, list):
+        return result
+    if isinstance(result, dict):
+        payload = result.get("data", result)
+        if isinstance(payload, dict):
+            items = payload.get("data", payload.get("items", []))
+            return items if isinstance(items, list) else []
+        if isinstance(payload, list):
+            return payload
+    return []
+
+
+def _print_views_table(
+    items: list[dict[str, Any]],
+    class_name: str,
+) -> None:
+    console = get_console()
+    cols = list(items[0].keys()) if items else []
+    table = Table(
+        title=f"Views of [bold]{class_name}[/bold]",
+        show_header=True,
+        header_style="bold cyan",
+    )
+    table.add_column("#", style="dim", width=4)
+    for col in cols:
+        table.add_column(col)
+    for idx, item in enumerate(items, 1):
+        row = [str(idx)] + [str(item.get(col, "")) for col in cols]
+        table.add_row(*row)
+    console.print(table)
+    console.print(f"[dim]Total {len(items)} views[/dim]")
+
+
+def _read_payload(data: str, file: Path | None) -> Any:
+    if file:
+        file = validate_path(file)
+        return json_mod.loads(file.read_text(encoding="utf-8"))
+    if data:
+        return json_mod.loads(data)
+    raise DWFError("Provide --data or --file")
+
+
+def _build_view_payload(
+    class_name: str,
+    view_name: str,
+    is_relation: bool,
+    v3_content: str,
+    display_name: str,
+    note: str,
+    device_type: str,
+    form_type: str,
+    basic_info: str,
+    has_thumbnail: bool,
+    widget_annotation: str,
+) -> dict[str, Any]:
+    return {
+        "className": class_name,
+        "viewName": view_name,
+        "isRelation": is_relation,
+        "v3Content": v3_content,
+        "displayName": display_name,
+        "note": note,
+        "deviceType": device_type,
+        "formType": form_type,
+        "basicInfo": basic_info,
+        "hasThumbnail": has_thumbnail,
+        "widgetAnnotation": widget_annotation,
+    }
+
+
+@_view_sub.command(name="list")
+def list_views(
+    ctx: typer.Context,
+    view_type: Annotated[
+        ViewType,
+        typer.Option(
+            "--type",
+            "-t",
+            help="View type: class (entity/relation), standalone",
+            case_sensitive=False,
+        ),
+    ] = ViewType.class_,
+    class_name: Annotated[
+        str | None,
+        typer.Option(
+            "--class-name", "-c", help="Class name (required when type is 'class')"
+        ),
+    ] = None,
+    need_v3_content: Annotated[
+        bool,
+        typer.Option("--need-v3-content", help="Return form JSON content"),
+    ] = False,
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        if view_type == ViewType.standalone:
+            target_class = _STANDALONE_CLASS_NAME
+        elif class_name:
+            target_class = class_name
+        else:
+            raise DWFError("--class-name is required when --type is 'class'")
+
+        client = get_client(ctx)
+        result = formmodel_api.list_views(
+            client,
+            target_class,
+            need_v3_content=need_v3_content,
+        )
+        items = _extract_items(result)
+
+        if not items:
+            if is_tty():
+                get_console().print(f"[dim]No views found for '{target_class}'.[/dim]")
+            else:
+                typer.echo("[]")
+            return
+
+        fmt = resolve_format(fmt)
+
+        if fmt == OutputFormat.json:
+            typer.echo(json_mod.dumps(result, ensure_ascii=False, indent=2))
+            return
+
+        _print_views_table(items, target_class)
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_view_sub.command(name="create")
+def create_view(
+    ctx: typer.Context,
+    class_name: Annotated[str, typer.Option("--class-name", "-c", help="Class name")],
+    view_name: Annotated[
+        str, typer.Option("--view-name", "-n", help="View name (English)")
+    ],
+    v3_content: Annotated[
+        str | None,
+        typer.Option(
+            "--v3-content",
+            help="Form JSON content (string)",
+        ),
+    ] = None,
+    v3_content_file: Annotated[
+        Path | None,
+        typer.Option(
+            "--v3-content-file",
+            help="Path to file containing form JSON content",
+        ),
+    ] = None,
+    display_name: Annotated[
+        str, typer.Option("--display-name", help="Display name (Chinese)")
+    ] = "",
+    note: Annotated[str, typer.Option("--note", help="Note")] = "",
+    is_relation: Annotated[
+        bool,
+        typer.Option("--is-relation", help="Whether this is a relation form"),
+    ] = False,
+    device_type: Annotated[
+        FormDeviceType,
+        typer.Option("--device-type", help="Device type"),
+    ] = FormDeviceType.pc,
+    form_type: Annotated[
+        FormType,
+        typer.Option("--form-type", help="Form type"),
+    ] = FormType.PC,
+    basic_info: Annotated[str, typer.Option("--basic-info", help="Basic info")] = "",
+    has_thumbnail: Annotated[
+        bool,
+        typer.Option("--has-thumbnail", help="Has thumbnail"),
+    ] = False,
+    widget_annotation: Annotated[
+        str, typer.Option("--widget-annotation", help="Widget annotation")
+    ] = "",
+    if_not_exists: Annotated[
+        bool,
+        typer.Option("--if-not-exists", help="Skip if view already exists"),
+    ] = False,
+    dry_run: Annotated[
+        bool,
+        typer.Option("--dry-run", help="Preview without executing"),
+    ] = False,
+) -> None:
+    try:
+        content = ""
+        if v3_content_file:
+            v3_content_file = validate_path(v3_content_file)
+            content = v3_content_file.read_text(encoding="utf-8")
+        elif v3_content:
+            content = v3_content
+        else:
+            if is_tty():
+                content = typer.prompt("v3Content (form JSON)")
+            else:
+                raise DWFError("--v3-content or --v3-content-file is required")
+
+        payload = _build_view_payload(
+            class_name=class_name,
+            view_name=view_name,
+            is_relation=is_relation,
+            v3_content=content,
+            display_name=display_name,
+            note=note,
+            device_type=device_type.value,
+            form_type=form_type.value,
+            basic_info=basic_info,
+            has_thumbnail=has_thumbnail,
+            widget_annotation=widget_annotation,
+        )
+
+        if dry_run:
+            typer.echo(
+                json_mod.dumps(
+                    {
+                        "action": "create",
+                        "resource": "view",
+                        "data": [payload],
+                        "if_not_exists": if_not_exists,
+                        "reversible": False,
+                    },
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            )
+            raise typer.Exit(code=DRY_RUN_EXIT_CODE)
+
+        client = get_client(ctx)
+        result = None
+        try:
+            result = formmodel_api.create_views(client, [payload])
+            typer.echo(f"Created view: {view_name}", err=True)
+        except ConflictError:
+            if if_not_exists:
+                typer.echo(
+                    f"View already exists, skipped (--if-not-exists): {view_name}",
+                    err=True,
+                )
+            else:
+                raise
+        if isinstance(result, dict):
+            typer.echo(json_mod.dumps(result, ensure_ascii=False, indent=2))
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_view_sub.command(name="update")
+def update_view(
+    ctx: typer.Context,
+    oid: Annotated[str, typer.Argument(help="View OID to update")],
+    class_name: Annotated[str, typer.Option("--class-name", "-c", help="Class name")],
+    view_name: Annotated[
+        str, typer.Option("--view-name", "-n", help="View name (English)")
+    ],
+    is_relation: Annotated[
+        bool,
+        typer.Option("--is-relation", help="Whether this is a relation form"),
+    ] = False,
+    v3_content: Annotated[
+        str | None,
+        typer.Option("--v3-content", help="Form JSON content (string)"),
+    ] = None,
+    v3_content_file: Annotated[
+        Path | None,
+        typer.Option("--v3-content-file", help="Path to form JSON content file"),
+    ] = None,
+    display_name: Annotated[
+        str, typer.Option("--display-name", help="Display name (Chinese)")
+    ] = "",
+    note: Annotated[str, typer.Option("--note", help="Note")] = "",
+    device_type: Annotated[
+        FormDeviceType,
+        typer.Option("--device-type", help="Device type"),
+    ] = FormDeviceType.pc,
+    form_type: Annotated[
+        FormType,
+        typer.Option("--form-type", help="Form type"),
+    ] = FormType.PC,
+    basic_info: Annotated[str, typer.Option("--basic-info", help="Basic info")] = "",
+    has_thumbnail: Annotated[
+        bool,
+        typer.Option("--has-thumbnail", help="Has thumbnail"),
+    ] = False,
+    widget_annotation: Annotated[
+        str, typer.Option("--widget-annotation", help="Widget annotation")
+    ] = "",
+    addin_hide_rule: Annotated[
+        str, typer.Option("--addin-hide-rule", help="Addin hide rule (JSON)")
+    ] = "[]",
+    force_update: Annotated[
+        bool,
+        typer.Option("--force-update", help="Force overwrite"),
+    ] = True,
+    dry_run: Annotated[
+        bool,
+        typer.Option("--dry-run", help="Preview without executing"),
+    ] = False,
+) -> None:
+    try:
+        content = ""
+        if v3_content_file:
+            v3_content_file = validate_path(v3_content_file)
+            content = v3_content_file.read_text(encoding="utf-8")
+        elif v3_content:
+            content = v3_content
+        else:
+            if is_tty():
+                content = typer.prompt("v3Content (form JSON)")
+            else:
+                raise DWFError("--v3-content or --v3-content-file is required")
+
+        import time
+
+        payload = _build_view_payload(
+            class_name=class_name,
+            view_name=view_name,
+            is_relation=is_relation,
+            v3_content=content,
+            display_name=display_name,
+            note=note,
+            device_type=device_type.value,
+            form_type=form_type.value,
+            basic_info=basic_info,
+            has_thumbnail=has_thumbnail,
+            widget_annotation=widget_annotation,
+        )
+        payload["oid"] = oid
+        payload["addinHideRule"] = addin_hide_rule
+        payload["lastModifyTime"] = int(time.time() * 1000)
+
+        if dry_run:
+            typer.echo(
+                json_mod.dumps(
+                    {
+                        "action": "update",
+                        "resource": "view",
+                        "target": oid,
+                        "data": payload,
+                        "reversible": True,
+                    },
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            )
+            raise typer.Exit(code=DRY_RUN_EXIT_CODE)
+
+        client = get_client(ctx)
+        result = formmodel_api.update_view(
+            client,
+            payload,
+            force_update=force_update,
+        )
+        typer.echo(f"Updated view: {oid}", err=True)
+        if isinstance(result, dict):
+            typer.echo(json_mod.dumps(result, ensure_ascii=False, indent=2))
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_view_sub.command(name="copy")
+def copy_view(
+    ctx: typer.Context,
+    oid: Annotated[str, typer.Argument(help="View OID to copy")],
+    new_class_name: Annotated[
+        str,
+        typer.Option("--new-class-name", help="Class name for the copied view"),
+    ] = "",
+    new_view_name: Annotated[
+        str,
+        typer.Option("--new-view-name", "-n", help="View name for the copy"),
+    ] = "",
+    new_device_type: Annotated[
+        FormDeviceType,
+        typer.Option("--new-device-type", help="Device type for the copy"),
+    ] = FormDeviceType.pc,
+    new_display_name: Annotated[
+        str,
+        typer.Option("--new-display-name", help="Display name for the copy"),
+    ] = "",
+    new_note: Annotated[
+        str,
+        typer.Option("--new-note", help="Note for the copy"),
+    ] = "",
+    new_form_type: Annotated[
+        FormType,
+        typer.Option("--new-form-type", help="Form type: PC or Mobile"),
+    ] = FormType.PC,
+    dry_run: Annotated[
+        bool,
+        typer.Option("--dry-run", help="Preview without executing"),
+    ] = False,
+) -> None:
+    try:
+        if dry_run:
+            typer.echo(
+                json_mod.dumps(
+                    {
+                        "action": "copy",
+                        "resource": "view",
+                        "target": oid,
+                        "data": {
+                            "newClassName": new_class_name,
+                            "newViewName": new_view_name,
+                            "newDeviceType": new_device_type.value,
+                            "newDisplayName": new_display_name,
+                            "newNote": new_note,
+                            "newFormType": new_form_type.value,
+                        },
+                        "reversible": False,
+                    },
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            )
+            raise typer.Exit(code=DRY_RUN_EXIT_CODE)
+
+        client = get_client(ctx)
+        result = formmodel_api.copy_view(
+            client,
+            oid,
+            new_class_name=new_class_name,
+            new_view_name=new_view_name,
+            new_device_type=new_device_type.value,
+            new_display_name=new_display_name,
+            new_note=new_note,
+            new_form_type=new_form_type.value,
+        )
+        typer.echo(f"Copied view: {oid}", err=True)
+        if isinstance(result, dict):
+            typer.echo(json_mod.dumps(result, ensure_ascii=False, indent=2))
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_view_sub.command(name="delete")
+def delete_view(
+    ctx: typer.Context,
+    oid: Annotated[str, typer.Argument(help="View OID to delete")],
+    dry_run: Annotated[
+        bool,
+        typer.Option("--dry-run", help="Preview without executing"),
+    ] = False,
+    yes: Annotated[
+        bool,
+        typer.Option("--force", help="Skip confirmation prompt"),
+    ] = False,
+) -> None:
+    try:
+        if dry_run:
+            typer.echo(
+                json_mod.dumps(
+                    {
+                        "action": "delete",
+                        "resource": "view",
+                        "target": oid,
+                        "reversible": False,
+                    },
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            )
+            raise typer.Exit(code=DRY_RUN_EXIT_CODE)
+
+        if is_tty() and not yes:
+            confirm = typer.confirm(f"Delete view {oid}?", default=False)
+            if not confirm:
+                typer.echo("Cancelled.", err=True)
+                raise typer.Exit(code=0)
+
+        client = get_client(ctx)
+        formmodel_api.delete_view(client, oid)
+        typer.echo(f"Deleted view: {oid}", err=True)
+    except DWFError as exc:
+        handle_error(exc)
+
+
+_component_sub = typer.Typer(
+    help="Component management.", context_settings=_HELP_CONTEXT_SETTINGS
+)
+
+app.add_typer(_component_sub, name="component")
+
+
+@_component_sub.command(name="create-group")
+def create_component_group(
+    ctx: typer.Context,
+    name: Annotated[str, typer.Option("--name", "-n", help="Group name")],
+    display_name: Annotated[
+        str,
+        typer.Option("--display-name", "-d", help="Display name"),
+    ] = "",
+    dry_run: Annotated[
+        bool,
+        typer.Option("--dry-run", help="Preview without executing"),
+    ] = False,
+) -> None:
+    try:
+        if dry_run:
+            typer.echo(
+                json_mod.dumps(
+                    {
+                        "action": "create",
+                        "resource": "component-group",
+                        "data": {
+                            "name": name,
+                            "displayName": display_name,
+                        },
+                        "reversible": False,
+                    },
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            )
+            raise typer.Exit(code=DRY_RUN_EXIT_CODE)
+
+        client = get_client(ctx)
+        result = formmodel_api.create_component_group(client, name, display_name)
+        typer.echo(f"Created component group: {name}", err=True)
+        if isinstance(result, dict):
+            typer.echo(json_mod.dumps(result, ensure_ascii=False, indent=2))
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_component_sub.command(name="tree")
+def get_component_tree(
+    ctx: typer.Context,
+    need_v3_content: Annotated[
+        bool,
+        typer.Option(
+            "--need-v3-content",
+            help="Return v3Content and basicInfo",
+        ),
+    ] = False,
+    form_type: Annotated[
+        str,
+        typer.Option("--form-type", help="Form type filter: PC or Mobile"),
+    ] = "",
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.json,
+) -> None:
+    try:
+        client = get_client(ctx)
+        result = formmodel_api.get_component_tree(
+            client,
+            need_v3_content=need_v3_content,
+            form_type=form_type,
+        )
+        fmt = resolve_format(fmt)
+        typer.echo(json_mod.dumps(result, ensure_ascii=False, indent=2))
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_component_sub.command(name="create")
+def create_component(
+    ctx: typer.Context,
+    view_name: Annotated[
+        str, typer.Option("--view-name", "-n", help="Component name (English)")
+    ],
+    display_name: Annotated[
+        str, typer.Option("--display-name", "-d", help="Component display name")
+    ],
+    form_type: Annotated[
+        FormType,
+        typer.Option("--form-type", help="Form type: PC or Mobile"),
+    ],
+    icon: Annotated[str, typer.Option("--icon", help="Icon")],
+    owner: Annotated[str, typer.Option("--owner", help="Owner component group OID")],
+    basic_info: Annotated[str, typer.Option("--basic-info", help="Basic info")] = "",
+    note: Annotated[str, typer.Option("--note", help="Note")] = "",
+    v3_content: Annotated[
+        str | None,
+        typer.Option("--v3-content", help="Form JSON content (string)"),
+    ] = None,
+    v3_content_file: Annotated[
+        Path | None,
+        typer.Option("--v3-content-file", help="Path to form JSON content file"),
+    ] = None,
+    widget_annotation: Annotated[
+        str, typer.Option("--widget-annotation", help="Widget annotation (JSON)")
+    ] = "{}",
+    dry_run: Annotated[
+        bool,
+        typer.Option("--dry-run", help="Preview without executing"),
+    ] = False,
+) -> None:
+    try:
+        content = ""
+        if v3_content_file:
+            v3_content_file = validate_path(v3_content_file)
+            content = v3_content_file.read_text(encoding="utf-8")
+        elif v3_content:
+            content = v3_content
+        else:
+            if is_tty():
+                content = typer.prompt("v3Content (form JSON)")
+            else:
+                raise DWFError("--v3-content or --v3-content-file is required")
+
+        payload = {
+            "basicInfo": basic_info,
+            "displayName": display_name,
+            "formType": form_type.value,
+            "icon": icon,
+            "note": note,
+            "owner": owner,
+            "v3Content": content,
+            "viewName": view_name,
+            "widgetAnnotation": widget_annotation,
+        }
+
+        if dry_run:
+            typer.echo(
+                json_mod.dumps(
+                    {
+                        "action": "create",
+                        "resource": "component",
+                        "data": [payload],
+                        "reversible": False,
+                    },
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            )
+            raise typer.Exit(code=DRY_RUN_EXIT_CODE)
+
+        client = get_client(ctx)
+        result = formmodel_api.create_component(client, [payload])
+        typer.echo(f"Created component: {view_name}", err=True)
+        if isinstance(result, dict):
+            typer.echo(json_mod.dumps(result, ensure_ascii=False, indent=2))
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_component_sub.command(name="update-group-rel")
+def update_comp2compgroup(
+    ctx: typer.Context,
+    oid: Annotated[str, typer.Option("--oid", help="Relation OID of the component")],
+    component_oid: Annotated[
+        str, typer.Option("--component-oid", help="Component OID")
+    ],
+    component_group_oid: Annotated[
+        str,
+        typer.Option("--component-group-oid", help="Target component group OID"),
+    ],
+    component_display_name: Annotated[
+        str,
+        typer.Option("--display-name", "-d", help="Component display name"),
+    ] = "",
+    component_icon: Annotated[
+        str,
+        typer.Option("--icon", help="Component icon"),
+    ] = "",
+    component_note: Annotated[
+        str,
+        typer.Option("--note", help="Component note"),
+    ] = "",
+    dry_run: Annotated[
+        bool,
+        typer.Option("--dry-run", help="Preview without executing"),
+    ] = False,
+) -> None:
+    try:
+        if dry_run:
+            typer.echo(
+                json_mod.dumps(
+                    {
+                        "action": "update",
+                        "resource": "comp2compgroup",
+                        "data": {
+                            "componentDisplayName": component_display_name,
+                            "componentGroupOid": component_group_oid,
+                            "componentIcon": component_icon,
+                            "componentNote": component_note,
+                            "componentOid": component_oid,
+                            "oid": oid,
+                        },
+                        "reversible": True,
+                    },
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            )
+            raise typer.Exit(code=DRY_RUN_EXIT_CODE)
+
+        client = get_client(ctx)
+        result = formmodel_api.update_comp2compgroup(
+            client,
+            component_display_name=component_display_name,
+            component_group_oid=component_group_oid,
+            component_icon=component_icon,
+            component_note=component_note,
+            component_oid=component_oid,
+            oid=oid,
+        )
+        typer.echo(f"Updated comp2compgroup: {oid}", err=True)
+        if isinstance(result, dict):
+            typer.echo(json_mod.dumps(result, ensure_ascii=False, indent=2))
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_component_sub.command(name="delete")
+def delete_component(
+    ctx: typer.Context,
+    oid: Annotated[str, typer.Argument(help="Component OID to delete")],
+    dry_run: Annotated[
+        bool,
+        typer.Option("--dry-run", help="Preview without executing"),
+    ] = False,
+    yes: Annotated[
+        bool,
+        typer.Option("--force", help="Skip confirmation prompt"),
+    ] = False,
+) -> None:
+    try:
+        if dry_run:
+            typer.echo(
+                json_mod.dumps(
+                    {
+                        "action": "delete",
+                        "resource": "component",
+                        "target": oid,
+                        "reversible": False,
+                    },
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            )
+            raise typer.Exit(code=DRY_RUN_EXIT_CODE)
+
+        if is_tty() and not yes:
+            confirm = typer.confirm(f"Delete component {oid}?", default=False)
+            if not confirm:
+                typer.echo("Cancelled.", err=True)
+                raise typer.Exit(code=0)
+
+        client = get_client(ctx)
+        formmodel_api.delete_component(client, oid)
+        typer.echo(f"Deleted component: {oid}", err=True)
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_component_sub.command(name="delete-group")
+def delete_component_group(
+    ctx: typer.Context,
+    oid: Annotated[str, typer.Argument(help="Component group OID to delete")],
+    dry_run: Annotated[
+        bool,
+        typer.Option("--dry-run", help="Preview without executing"),
+    ] = False,
+    yes: Annotated[
+        bool,
+        typer.Option("--force", help="Skip confirmation prompt"),
+    ] = False,
+) -> None:
+    try:
+        if dry_run:
+            typer.echo(
+                json_mod.dumps(
+                    {
+                        "action": "delete",
+                        "resource": "component-group",
+                        "target": oid,
+                        "reversible": False,
+                    },
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            )
+            raise typer.Exit(code=DRY_RUN_EXIT_CODE)
+
+        if is_tty() and not yes:
+            confirm = typer.confirm(f"Delete component group {oid}?", default=False)
+            if not confirm:
+                typer.echo("Cancelled.", err=True)
+                raise typer.Exit(code=0)
+
+        client = get_client(ctx)
+        formmodel_api.delete_component_group(client, oid)
+        typer.echo(f"Deleted component group: {oid}", err=True)
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_view_sub.command(name="get-by-device")
+def get_view_by_device(
+    ctx: typer.Context,
+    class_name: Annotated[str, typer.Option("--class-name", "-c", help="Class name")],
+    view_name: Annotated[str, typer.Option("--view-name", "-n", help="View name")],
+    device_type: Annotated[
+        FormDeviceType,
+        typer.Option("--device-type", help="Device type"),
+    ],
+    form_type: Annotated[
+        FormType,
+        typer.Option("--form-type", help="Form type: PC or Mobile"),
+    ],
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.json,
+) -> None:
+    try:
+        client = get_client(ctx)
+        result = formmodel_api.get_view_by_device_type(
+            client,
+            class_name=class_name,
+            view_name=view_name,
+            device_type=device_type.value,
+            form_type=form_type.value,
+        )
+        resolve_format(fmt)
+        typer.echo(json_mod.dumps(result, ensure_ascii=False, indent=2))
+    except DWFError as exc:
+        handle_error(exc)
+
+
+_library_sub = typer.Typer(
+    help="Library management.", context_settings=_HELP_CONTEXT_SETTINGS
+)
+
+app.add_typer(_library_sub, name="library")
+
+
+@_library_sub.command(name="files")
+def list_library_files(
+    ctx: typer.Context,
+    library_id: Annotated[
+        str,
+        typer.Option("--library-id", "-l", help="Library ID"),
+    ] = "picture_management",
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.json,
+) -> None:
+    try:
+        client = get_client(ctx)
+        result = formmodel_api.list_library_files(client, library_id)
+        resolve_format(fmt)
+        typer.echo(json_mod.dumps(result, ensure_ascii=False, indent=2))
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_library_sub.command(name="upload")
+def upload_file(
+    ctx: typer.Context,
+    file_path: Annotated[
+        Path,
+        typer.Option("--file-path", "-p", help="Path to the file to upload"),
+    ],
+    library_id: Annotated[
+        str,
+        typer.Option("--library-id", "-l", help="Library ID"),
+    ] = "",
+    dry_run: Annotated[
+        bool,
+        typer.Option("--dry-run", help="Preview without executing"),
+    ] = False,
+) -> None:
+    try:
+        file_path = validate_path(file_path)
+
+        if dry_run:
+            typer.echo(
+                json_mod.dumps(
+                    {
+                        "action": "upload",
+                        "resource": "file",
+                        "file": str(file_path),
+                        "library_id": library_id or None,
+                        "reversible": False,
+                    },
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            )
+            raise typer.Exit(code=DRY_RUN_EXIT_CODE)
+
+        file_content = file_path.read_bytes()
+        client = get_client(ctx)
+        result = formmodel_api.upload_file(
+            client,
+            file_content,
+            file_path.name,
+            library_id=library_id,
+        )
+        typer.echo(f"Uploaded file: {file_path.name}", err=True)
+        if isinstance(result, dict):
+            typer.echo(json_mod.dumps(result, ensure_ascii=False, indent=2))
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_library_sub.command(name="delete")
+def delete_file(
+    ctx: typer.Context,
+    file_oid: Annotated[str, typer.Argument(help="File OID to delete")],
+    dry_run: Annotated[
+        bool,
+        typer.Option("--dry-run", help="Preview without executing"),
+    ] = False,
+    yes: Annotated[
+        bool,
+        typer.Option("--force", help="Skip confirmation prompt"),
+    ] = False,
+) -> None:
+    try:
+        if dry_run:
+            typer.echo(
+                json_mod.dumps(
+                    {
+                        "action": "delete",
+                        "resource": "file",
+                        "target": file_oid,
+                        "reversible": False,
+                    },
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            )
+            raise typer.Exit(code=DRY_RUN_EXIT_CODE)
+
+        if is_tty() and not yes:
+            confirm = typer.confirm(f"Delete file {file_oid}?", default=False)
+            if not confirm:
+                typer.echo("Cancelled.", err=True)
+                raise typer.Exit(code=0)
+
+        client = get_client(ctx)
+        formmodel_api.delete_file(client, file_oid)
+        typer.echo(f"Deleted file: {file_oid}", err=True)
+    except DWFError as exc:
+        handle_error(exc)