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

dwf_cli/api/formmodel.py

@@ -0,0 +1,197 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from dwf_cli.api.client import APIClient
+
+
+def list_views(
+    client: APIClient,
+    class_name: str,
+    *,
+    need_v3_content: bool = False,
+) -> Any:
+    return client.get(
+        f"/dwf/v1/meta/class/{class_name}/views",
+        params={
+            "needV3Content": str(need_v3_content).lower(),
+        },
+    )
+
+
+def create_views(
+    client: APIClient,
+    views: list[dict[str, Any]],
+) -> Any:
+    return client.post(
+        "/dwf/v1/meta/views-create",
+        json=views,
+    )
+
+
+def update_view(
+    client: APIClient,
+    view: dict[str, Any],
+    *,
+    force_update: bool = False,
+) -> Any:
+    return client.post(
+        "/dwf/v1/meta/view-update",
+        params={
+            "forceUpdate": str(force_update).lower(),
+        },
+        json=view,
+    )
+
+
+def delete_view(
+    client: APIClient,
+    oid: str,
+) -> Any:
+    return client.post(f"/dwf/v1/meta/views-delete/{oid}")
+
+
+def copy_view(
+    client: APIClient,
+    oid: str,
+    *,
+    new_class_name: str = "",
+    new_view_name: str = "",
+    new_device_type: str = "actPc",
+    new_display_name: str = "",
+    new_note: str = "",
+    new_form_type: str = "PC",
+) -> Any:
+    return client.post(
+        f"/dwf/v1/meta/views/{oid}/copy",
+        json={
+            "newClassName": new_class_name,
+            "newViewName": new_view_name,
+            "newDeviceType": new_device_type,
+            "newDisplayName": new_display_name,
+            "newNote": new_note,
+            "newFormType": new_form_type,
+        },
+    )
+
+
+def create_component_group(
+    client: APIClient,
+    name: str,
+    display_name: str = "",
+) -> Any:
+    return client.post(
+        "/dwf/v1/meta/component/component-groups-create",
+        json={
+            "name": name,
+            "displayName": display_name,
+        },
+    )
+
+
+def get_component_tree(
+    client: APIClient,
+    *,
+    need_v3_content: bool = False,
+    form_type: str = "",
+) -> Any:
+    params: dict[str, str] = {
+        "needV3Content": str(need_v3_content).lower(),
+    }
+    if form_type:
+        params["formType"] = form_type
+    return client.get(
+        "/dwf/v1/meta/component/get-tree",
+        params=params,
+    )
+
+
+def create_component(
+    client: APIClient,
+    component: list[dict[str, Any]],
+) -> Any:
+    return client.post(
+        "/dwf/v1/meta/component/components-create",
+        json=component,
+    )
+
+
+def update_comp2compgroup(
+    client: APIClient,
+    *,
+    component_display_name: str = "",
+    component_group_oid: str = "",
+    component_icon: str = "",
+    component_note: str = "",
+    component_oid: str = "",
+    oid: str = "",
+) -> Any:
+    return client.post(
+        "/dwf/v1/meta/component/comp2compgroup-update",
+        json={
+            "componentDisplayName": component_display_name,
+            "componentGroupOid": component_group_oid,
+            "componentIcon": component_icon,
+            "componentNote": component_note,
+            "componentOid": component_oid,
+            "oid": oid,
+        },
+    )
+
+
+def delete_component(
+    client: APIClient,
+    oid: str,
+) -> Any:
+    return client.post(f"/dwf/v1/meta/component/component-delete/{oid}")
+
+
+def delete_component_group(
+    client: APIClient,
+    oid: str,
+) -> Any:
+    return client.post(f"/dwf/v1/meta/component/component-groups-delete/{oid}")
+
+
+def get_view_by_device_type(
+    client: APIClient,
+    class_name: str,
+    view_name: str,
+    device_type: str,
+    form_type: str,
+) -> Any:
+    return client.get(
+        f"/dwf/v1/meta/class/{class_name}/views/{view_name}/devices/{device_type}/type/{form_type}",
+    )
+
+
+def list_library_files(
+    client: APIClient,
+    library_id: str = "picture_management",
+) -> Any:
+    return client.get(f"/dwf/v1/libraries/{library_id}/files")
+
+
+def upload_file(
+    client: APIClient,
+    file_content: bytes,
+    file_name: str,
+    *,
+    library_id: str = "",
+) -> Any:
+    params: dict[str, str] = {}
+    if library_id:
+        params["libraryId"] = library_id
+    return client.post(
+        "/dwf/v1/files-upload",
+        params=params or None,
+        files={"file": (file_name, file_content)},
+    )
+
+
+def delete_file(
+    client: APIClient,
+    file_oid: str,
+) -> Any:
+    return client.post(f"/dwf/v1/files-delete/{file_oid}")

dwf_cli/api/funcmodel.py

@@ -0,0 +1,436 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+import httpx
+
+if TYPE_CHECKING:
+    from dwf_cli.api.client import APIClient
+
+
+# ── Theme ──────────────────────────────────────────────────────────────
+
+
+def list_themes(client: APIClient) -> Any:
+    return client.get("/dwf/v1/theme-list")
+
+
+def create_theme(
+    client: APIClient,
+    *,
+    theme_name: str,
+    note: str | None = None,
+    file_path: str | Path,
+) -> Any:
+    with open(file_path, "rb") as f:
+        files = {"file": f}
+        params: dict[str, str] = {"themeName": theme_name}
+        if note is not None:
+            params["note"] = note
+        return client.post("/dwf/v1/theme-create", params=params, files=files)
+
+
+def update_theme(
+    client: APIClient,
+    oid: str,
+    *,
+    theme_name: str | None = None,
+    note: str | None = None,
+    file_path: str | Path | None = None,
+) -> Any:
+    params: dict[str, str] = {}
+    if theme_name is not None:
+        params["themeName"] = theme_name
+    if note is not None:
+        params["note"] = note
+
+    kwargs: dict[str, Any] = {"params": params}
+    if file_path is not None:
+        with open(file_path, "rb") as f:
+            kwargs["files"] = {"file": f}
+            return client.post(f"/dwf/v1/theme-update/{oid}", **kwargs)
+    return client.post(f"/dwf/v1/theme-update/{oid}", **kwargs)
+
+
+def delete_theme(client: APIClient, oid: str) -> Any:
+    return client.post(f"/dwf/v1/theme-delete/{oid}")
+
+
+# ── App CRUD ───────────────────────────────────────────────────────────
+
+
+def list_apps(
+    client: APIClient,
+    *,
+    published_only: bool = False,
+    with_modeler_app: bool = True,
+    with_ext_config: bool = True,
+    app_type: str | None = None,
+) -> Any:
+    params: dict[str, str] = {
+        "publishedOnly": str(published_only).lower(),
+        "withModelerApp": str(with_modeler_app).lower(),
+        "withExtConfig": str(with_ext_config).lower(),
+    }
+    if app_type is not None:
+        params["type"] = app_type
+    return client.get("/dwf/v1/apps", params=params)
+
+
+def get_app_by_name(client: APIClient, name: str) -> Any:
+    return client.get(f"/dwf/v1/apps/{name}")
+
+
+def get_app_by_id(
+    client: APIClient, app_id: str, *, language: str | None = None
+) -> Any:
+    params: dict[str, str] = {}
+    if language is not None:
+        params["language"] = language
+    return client.get(f"/dwf/v1/apps/id/{app_id}", params=params)
+
+
+def get_default_app_by_type(
+    client: APIClient, app_type: str, *, language: str | None = None
+) -> Any:
+    params: dict[str, str] = {}
+    if language is not None:
+        params["language"] = language
+    return client.get(f"/dwf/v1/apps/default-app/{app_type}", params=params)
+
+
+def create_app(client: APIClient, data: dict[str, Any]) -> Any:
+    return client.post("/dwf/v1/apps-create", json=data)
+
+
+def update_app(client: APIClient, data: dict[str, Any]) -> Any:
+    return client.post("/dwf/v1/apps-update", json=data)
+
+
+def delete_app(client: APIClient, app_id: str) -> Any:
+    return client.post(f"/dwf/v1/apps-delete/{app_id}")
+
+
+def set_default_app(client: APIClient, app_id: str, set_default: bool) -> Any:
+    return client.post(
+        f"/dwf/v1/app-set-default/{app_id}",
+        params={"setDefault": str(set_default).lower()},
+    )
+
+
+def publish_app(client: APIClient, app_id: str, publish: bool) -> Any:
+    return client.post(
+        f"/dwf/v1/app-publish/{app_id}",
+        params={"publish": str(publish).lower()},
+    )
+
+
+def reset_modeler_menus(client: APIClient) -> Any:
+    return client.post("/dwf/v1/apps/reset-modeler")
+
+
+# ── Logo / Icon / CSS ──────────────────────────────────────────────────
+
+
+def upload_logo(client: APIClient, app_id: str, file_path: str | Path) -> Any:
+    with open(file_path, "rb") as f:
+        files = {"logo": f}
+        return client.post(f"/dwf/v1/apps/{app_id}/logo-upload", files=files)
+
+
+def upload_icon(client: APIClient, app_id: str, file_path: str | Path) -> Any:
+    with open(file_path, "rb") as f:
+        files = {"icon": f}
+        return client.post(f"/dwf/v1/apps/{app_id}/icon-upload", files=files)
+
+
+def get_logo(client: APIClient, app_id: str) -> httpx.Response:
+    return client.download(f"/dwf/v1/apps/{app_id}/logo")
+
+
+def get_logo_base64(client: APIClient, app_id: str, img_type: str = "logoImg") -> Any:
+    return client.get(
+        f"/dwf/v1/apps/{app_id}/img-base64",
+        params={"imgType": img_type},
+    )
+
+
+def get_css_file(client: APIClient, app_id: str) -> httpx.Response:
+    return client.download(f"/dwf/v1/apps/{app_id}/css")
+
+
+# ── Language Package ───────────────────────────────────────────────────
+
+
+def list_language_packages(client: APIClient, app_id: str) -> Any:
+    return client.get(f"/dwf/v1/apps/{app_id}/app-language-packages")
+
+
+def get_language_package_by_language(
+    client: APIClient, app_id: str, language: str
+) -> Any:
+    return client.get(f"/dwf/v1/apps/{app_id}/app-language-package/{language}")
+
+
+def get_language_package_file(
+    client: APIClient, app_id: str, language: str
+) -> httpx.Response:
+    return client.download(
+        f"/dwf/v1/apps/{app_id}/app-language-package/{language}/get-file"
+    )
+
+
+def get_language_package_json(
+    client: APIClient, app_id: str, language: str, *, is_frontend: bool = True
+) -> Any:
+    return client.get(
+        f"/dwf/v1/app/{app_id}/app-language-package/{language}/get-json",
+        params={"isFrontend": str(is_frontend).lower()},
+    )
+
+
+def create_language_package(
+    client: APIClient, app_language_package_do: str, file_path: str | Path
+) -> Any:
+    with open(file_path, "rb") as f:
+        files = {"file": f}
+        return client.post(
+            "/dwf/v1/apps/apps-language-package-create",
+            params={"appLanguagePackageDO": app_language_package_do},
+            files=files,
+        )
+
+
+def update_language_package(
+    client: APIClient, package_id: str, file_path: str | Path
+) -> Any:
+    with open(file_path, "rb") as f:
+        files = {"file": f}
+        return client.post(
+            f"/dwf/v1/apps/apps-language-package-update/{package_id}",
+            files=files,
+        )
+
+
+def delete_language_package(client: APIClient, package_id: str) -> Any:
+    return client.post(f"/dwf/v1/apps/apps-language-package-delete/{package_id}")
+
+
+def delete_language_packages_by_app(client: APIClient, app_id: str) -> Any:
+    return client.post(f"/dwf/v1/apps/{app_id}/apps-language-package-delete")
+
+
+def get_supported_language_types(
+    client: APIClient, *, mobile_only: bool = False
+) -> Any:
+    return client.get(
+        "/dwf/v1/apps/app-language-types",
+        params={"mobileOnly": str(mobile_only).lower()},
+    )
+
+
+def get_language_package_template_file(
+    client: APIClient, template_type: str = "PC"
+) -> httpx.Response:
+    return client.download(
+        "/dwf/v1/apps/app-language-package/get-template",
+        params={"type": template_type},
+    )
+
+
+def get_language_package_template_json(
+    client: APIClient, template_type: str = "PC", second_key: str | None = None
+) -> Any:
+    params: dict[str, str] = {"type": template_type}
+    if second_key is not None:
+        params["secondKey"] = second_key
+    return client.get(
+        "/dwf/v1/app/app-language-package/get-template-json", params=params
+    )
+
+
+# ── Operations ─────────────────────────────────────────────────────────
+
+
+_OPERATION_TYPE_PATHS: dict[str, str] = {
+    "global": "/dwf/v1/meta/global-operations",
+    "entity": "/dwf/v1/meta/entities-operations",
+    "relation": "/dwf/v1/meta/relations-operations",
+}
+
+
+def list_operations(
+    client: APIClient,
+    operation_type: str,
+    *,
+    page: int = 0,
+    page_size: int = 25,
+    with_page_info: bool = True,
+    fuzzy_search: str | None = None,
+) -> dict[str, Any]:
+    path = _OPERATION_TYPE_PATHS[operation_type]
+    if operation_type == "global":
+        body: dict[str, str] = {}
+        if fuzzy_search:
+            body["conType"] = fuzzy_search
+            body["displayName"] = fuzzy_search
+            body["name"] = fuzzy_search
+            body["action"] = fuzzy_search
+        return client.post(
+            path,
+            params={
+                "pageIndex": page,
+                "pageSize": page_size,
+                "withPageInfo": str(with_page_info).lower(),
+            },
+            json=body,
+        )
+    params: dict[str, Any] = {
+        "pageIndex": page,
+        "pageSize": page_size,
+        "withPageInfo": str(with_page_info).lower(),
+    }
+    if fuzzy_search:
+        params["fuzzySearch"] = fuzzy_search
+    return client.get(path, params=params)
+
+
+def get_all_operations(client: APIClient) -> Any:
+    return client.get("/dwf/v1/meta/operations")
+
+
+def get_operation_keywords(client: APIClient) -> Any:
+    return client.get("/dwf/v1/meta/operations-keywords")
+
+
+def get_operation_by_id(client: APIClient, oid: str) -> Any:
+    return client.get(f"/dwf/v1/meta/queryoperations/{oid}")
+
+
+def get_operations_by_ids(client: APIClient, ids: list[str]) -> Any:
+    return client.post("/dwf/v1/meta/queryoperations", json=ids)
+
+
+def create_operation(
+    client: APIClient,
+    data: dict[str, Any],
+    *,
+    auto_generate_name: bool = False,
+) -> Any:
+    return client.post(
+        "/dwf/v1/meta/queryoperations-create",
+        params={"autoGenerateName": str(auto_generate_name).lower()},
+        json=data,
+    )
+
+
+def update_operation(
+    client: APIClient,
+    data: dict[str, Any],
+    *,
+    force_update: bool = False,
+) -> Any:
+    return client.post(
+        "/dwf/v1/meta/queryoperations-update",
+        params={"forceUpdate": str(force_update).lower()},
+        json=data,
+    )
+
+
+def delete_operation(client: APIClient, oid: str) -> Any:
+    return client.post(f"/dwf/v1/meta/queryoperations-delete/{oid}")
+
+
+def move_operation(client: APIClient, oid: str, parent_id: str) -> Any:
+    return client.post(
+        f"/dwf/v1/meta/queryoperations/{oid}/move",
+        params={"parentId": parent_id},
+    )
+
+
+def hide_operation(client: APIClient, oid: str, hide: bool) -> Any:
+    return client.post(
+        f"/dwf/v1/meta/queryoperations/{oid}/hide",
+        params={"hide": str(hide).lower()},
+    )
+
+
+def check_operation_display_name(client: APIClient, data: dict[str, Any]) -> Any:
+    return client.post("/dwf/v1/meta/queryoperations-displayNameCheck", json=data)
+
+
+def get_global_implement_scripts(
+    client: APIClient, *, is_client_script: bool = True
+) -> Any:
+    return client.get(
+        "/dwf/v1/meta/global-implement-scripts",
+        params={"isClientScript": str(is_client_script).lower()},
+    )
+
+
+# ── Modules ─────────────────────────────────────────────────────────────
+
+
+def list_modules(
+    client: APIClient,
+    *,
+    app_id: str | None = None,
+    with_default_module: bool = False,
+    language: str | None = None,
+) -> Any:
+    params: dict[str, str] = {
+        "withDefaultModule": str(with_default_module).lower(),
+    }
+    if app_id:
+        params["appId"] = app_id
+    if language:
+        params["language"] = language
+    return client.get("/dwf/v1/meta/modules", params=params)
+
+
+def get_modules_operations_tree(
+    client: APIClient,
+    *,
+    app_id: str | None = None,
+    with_default_module: bool = False,
+    published_only: bool = True,
+    with_hidden: bool = False,
+    language: str | None = None,
+) -> Any:
+    params: dict[str, str] = {
+        "withDefaultModule": str(with_default_module).lower(),
+        "publishedOnly": str(published_only).lower(),
+        "withHidden": str(with_hidden).lower(),
+    }
+    if app_id:
+        params["appId"] = app_id
+    if language:
+        params["language"] = language
+    return client.get("/dwf/v1/meta/modules-operations", params=params)
+
+
+def get_module_operations(
+    client: APIClient,
+    module_name: str,
+    *,
+    with_hidden: bool = False,
+    language: str | None = None,
+) -> Any:
+    params: dict[str, str] = {
+        "withHidden": str(with_hidden).lower(),
+    }
+    if language:
+        params["language"] = language
+    return client.get(f"/dwf/v1/meta/modules/{module_name}/operations", params=params)
+
+
+def update_modules_tree_order(
+    client: APIClient,
+    app_id: str,
+    tree_data: list[dict[str, Any]],
+) -> Any:
+    return client.post(
+        f"/dwf/v1/meta/modules-tree/{app_id}/update-order",
+        json=tree_data,
+    )

dwf_cli/cli/__init__.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+
+from dwf_cli.cli import auth, config, datamodel, formmodel, funcmodel, schema
+from dwf_cli.cli._common import APIClient, ContextObj
+from dwf_cli.core.config import Config
+from dwf_cli.core.errors import DWFError
+
+_HELP_CONTEXT_SETTINGS = {"help_option_names": ["-h", "--help"]}
+
+__version__ = "0.2.0"
+
+
+def _version_callback(value: bool) -> None:
+    if value:
+        typer.echo(f"dwf-cli {__version__}")
+        raise typer.Exit(code=0)
+
+
+app = typer.Typer(
+    name="dwf-cli",
+    help="DWF platform command-line tool.",
+    pretty_exceptions_show_locals=False,
+    rich_markup_mode="rich",
+    context_settings=_HELP_CONTEXT_SETTINGS,
+)
+
+app.add_typer(auth.app, name="auth")
+app.add_typer(datamodel.app, name="datamodel")
+app.add_typer(funcmodel.app, name="funcmodel")
+app.add_typer(formmodel.app, name="formmodel")
+app.add_typer(config.app, name="config")
+app.add_typer(schema.app, name="schema")
+
+
+@app.callback(invoke_without_command=True)
+def main(
+    ctx: typer.Context,
+    version: Annotated[
+        bool | None,
+        typer.Option(
+            "--version",
+            "-V",
+            help="Show version and exit",
+            callback=_version_callback,
+            is_eager=True,
+        ),
+    ] = None,
+) -> None:
+    if ctx.invoked_subcommand is None:
+        typer.echo(ctx.get_help())
+        raise typer.Exit(code=0)
+
+    try:
+        cfg = Config()
+    except DWFError:
+        cfg = Config.__new__(Config)
+        cfg._data = {}
+    client: APIClient | None = None
+    app_client: APIClient | None = None
+    if cfg.server and cfg.token:
+        client = APIClient(cfg.server, cfg.token)
+        app_url = cfg.app_server
+        if app_url and app_url != cfg.server:
+            app_client = APIClient(app_url, cfg.token)
+    ctx.obj = ContextObj(config=cfg, client=client, app_client=app_client)