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

dwf_cli/__init__.py

@@ -0,0 +1,3 @@
+from dwf_cli.cli import app
+
+__all__ = ["app"]

dwf_cli/__main__.py

@@ -0,0 +1,4 @@
+from dwf_cli.cli import app
+
+if __name__ == "__main__":
+    app(prog_name="dwf-cli")

dwf_cli/api/__init__.py

@@ -0,0 +1,3 @@
+from dwf_cli.api.client import APIClient
+
+__all__ = ["APIClient"]

dwf_cli/api/auth.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import httpx
+
+from dwf_cli.core.crypto import encrypt_password
+from dwf_cli.core.errors import AuthError
+
+if TYPE_CHECKING:
+    from dwf_cli.api.client import APIClient
+
+
+def login(
+    client: APIClient,
+    username: str,
+    password: str,
+    aes_key: str,
+    aes_iv: str,
+) -> str:
+    encrypted_pwd = encrypt_password(password, aes_key, aes_iv)
+    response = client._http.request(
+        "POST",
+        "/dwf/v1/login",
+        auth=httpx.BasicAuth(username, password),
+        files={
+            "username": (None, username),
+            "password": (None, encrypted_pwd),
+        },
+    )
+    if response.status_code != 200:
+        raise AuthError(
+            f"Login failed (status={response.status_code}, body={response.text[:200]})"
+        )
+    token = response.headers.get("authorization")
+    if not token:
+        raise AuthError("No authorization token in login response header")
+    return token
+
+
+def validate_token(client: APIClient) -> bool:
+    try:
+        client.get("/dwf/v1/org/current-user-environment")
+        return True
+    except Exception:
+        return False

dwf_cli/api/client.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+from dwf_cli.core.errors import APIError, AuthError, ConflictError
+
+
+def raise_if_not_success(result: object, action: str = "Operation") -> None:
+    if isinstance(result, dict) and result.get("success") is False:
+        msg = result.get("message", "Unknown error")
+        raise APIError(200, f"{action} failed: {msg}")
+
+
+class APIClient:
+    def __init__(
+        self,
+        base_url: str,
+        token: str | None = None,
+        timeout: float = 30.0,
+    ) -> None:
+        self.base_url = base_url.rstrip("/")
+        self.token = token
+        self._http = httpx.Client(
+            base_url=self.base_url,
+            timeout=timeout,
+        )
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        *,
+        params: dict[str, Any] | None = None,
+        json: dict[str, Any] | None = None,
+        files: dict[str, Any] | None = None,
+    ) -> Any:
+        headers: dict[str, str] = {}
+        if self.token:
+            headers["Authorization"] = self.token
+
+        response = self._http.request(
+            method,
+            path,
+            headers=headers,
+            params=params,
+            json=json,
+            files=files,
+        )
+
+        if response.status_code == 401:
+            raise AuthError(f"Unauthorized (body: {response.text[:200]})")
+        if response.status_code == 404:
+            from dwf_cli.core.errors import NotFoundError
+
+            raise NotFoundError(f"Not found: {path}")
+        if response.status_code == 409:
+            raise ConflictError(
+                f"Conflict: {path}",
+                detail=response.text[:500],
+            )
+        if response.status_code >= 400:
+            raise APIError(response.status_code, response.text)
+
+        if response.status_code == 204:
+            return None
+
+        content_type = response.headers.get("content-type", "")
+        if "application/json" in content_type:
+            return response.json()
+        return response
+
+    def download(self, path: str, **kwargs: Any) -> httpx.Response:
+        headers: dict[str, str] = {}
+        if self.token:
+            headers["Authorization"] = self.token
+        response = self._http.request(
+            "GET" if "method" not in kwargs else kwargs.pop("method"),
+            path,
+            headers=headers,
+            **kwargs,
+        )
+        if response.status_code == 401:
+            raise AuthError(f"Unauthorized (body: {response.text[:200]})")
+        if response.status_code == 404:
+            from dwf_cli.core.errors import NotFoundError
+
+            raise NotFoundError(f"Not found: {path}")
+        if response.status_code >= 400:
+            raise APIError(response.status_code, response.text)
+        return response
+
+    def raw_request(
+        self,
+        method: str,
+        path: str,
+        *,
+        auth: httpx.Auth | None = None,
+    ) -> httpx.Response:
+        return self._http.request(method, path, auth=auth)
+
+    def get(self, path: str, **kwargs: Any) -> Any:
+        return self._request("GET", path, **kwargs)
+
+    def post(self, path: str, **kwargs: Any) -> Any:
+        return self._request("POST", path, **kwargs)
+
+    def put(self, path: str, **kwargs: Any) -> Any:
+        return self._request("PUT", path, **kwargs)
+
+    def delete(self, path: str, **kwargs: Any) -> None:
+        self._request("DELETE", path, **kwargs)

dwf_cli/api/datamodel.py

@@ -0,0 +1,458 @@
+from __future__ import annotations
+
+from enum import Enum
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    import httpx
+    from dwf_cli.api.client import APIClient
+
+
+class ModelType(str, Enum):
+    entity = "entity"
+    e = "e"
+    relation = "relation"
+    r = "r"
+    external = "external"
+    x = "x"
+
+
+_MODEL_TYPE_PATHS: dict[str, str] = {
+    "entity": "/dwf/v1/meta/entities-internal",
+    "e": "/dwf/v1/meta/entities-internal",
+    "relation": "/dwf/v1/meta/relations",
+    "r": "/dwf/v1/meta/relations",
+    "external": "/dwf/v1/meta/entities-external",
+    "x": "/dwf/v1/meta/entities-external",
+}
+
+_ENTITY_VALUES = {"entity", "e"}
+
+
+def list_models(
+    client: APIClient,
+    model_type: ModelType,
+    *,
+    page: int = 0,
+    page_size: int = 25,
+    with_page_info: bool = True,
+    is_system: bool = False,
+    search: str | None = None,
+    search_fields: list[str] | None = None,
+) -> dict[str, Any]:
+    path = _MODEL_TYPE_PATHS[model_type.value]
+    params: dict[str, Any] = {
+        "pageIndex": page,
+        "pageSize": page_size,
+        "withPageInfo": str(with_page_info).lower(),
+    }
+    if model_type.value in _ENTITY_VALUES:
+        params["isSystem"] = str(is_system).lower()
+    body: dict[str, Any] = {}
+    if search:
+        body["keyword"] = search
+        body["attributes"] = search_fields or [
+            "className",
+            "displayName",
+            "zoneName",
+            "note",
+        ]
+    return client.post(path, params=params, json=body)
+
+
+def get_class(
+    client: APIClient,
+    name: str,
+) -> Any:
+    return client.get(f"/dwf/v1/meta/classes/{name}")
+
+
+def create_entity(
+    client: APIClient,
+    classes: list[dict[str, Any]],
+    *,
+    with_parent_oid: bool = False,
+) -> Any:
+    return client.post(
+        "/dwf/v1/meta/entities-create",
+        params={"withParentOid": str(with_parent_oid).lower()},
+        json=classes,
+    )
+
+
+def update_entity(
+    client: APIClient,
+    class_data: dict[str, Any],
+) -> Any:
+    return client.post("/dwf/v1/meta/entities-update", json=class_data)
+
+
+def update_relation(
+    client: APIClient,
+    relation_data: dict[str, Any],
+) -> Any:
+    return client.post("/dwf/v1/meta/relation-update", json=relation_data)
+
+
+def delete_class(
+    client: APIClient,
+    name: str,
+    *,
+    cascade: bool = False,
+) -> Any:
+    return client.post(
+        f"/dwf/v1/meta/classes-delete/{name}",
+        params={"cascade": str(cascade).lower()},
+    )
+
+
+def get_relations_tree(client: APIClient) -> Any:
+    return client.get("/dwf/v1/meta/relations/tree")
+
+
+def list_class_names(client: APIClient) -> Any:
+    return client.get("/dwf/v1/meta/class-names")
+
+
+def get_attributes(
+    client: APIClient,
+    class_name: str,
+    *,
+    need_sys_attr: bool = False,
+) -> Any:
+    return client.get(
+        f"/dwf/v1/meta/entities/{class_name}/attributes",
+        params={"needSysAttr": str(need_sys_attr).lower()},
+    )
+
+
+def list_attributes(
+    client: APIClient,
+    *,
+    keyword: str | None = None,
+) -> Any:
+    params: dict[str, str] = {}
+    if keyword:
+        params["keyword"] = keyword
+    return client.get("/dwf/v1/meta/attributes", params=params)
+
+
+def list_objects(
+    client: APIClient,
+    class_name: str,
+    *,
+    page: int = 0,
+    page_size: int = 25,
+    with_page_info: bool = True,
+    condition: str | None = None,
+    order_condition: dict[str, str] | None = None,
+    return_attrs: list[str] | None = None,
+) -> Any:
+    body: dict[str, Any] = {}
+    if condition:
+        body["condition"] = condition
+    if order_condition:
+        body["orderCondition"] = order_condition
+    if return_attrs:
+        body["returnAttrs"] = return_attrs
+    body["startIndex"] = page * page_size
+    body["pageSize"] = page_size
+    return client.post(
+        f"/dwf/v1/omf/entities/{class_name}/objects",
+        params={
+            "pageIndex": page,
+            "pageSize": page_size,
+            "totalCount": str(with_page_info).lower(),
+        },
+        json=body,
+    )
+
+
+def query_objects(
+    client: APIClient,
+    class_name: str,
+    body: dict[str, Any],
+    *,
+    page: int = 0,
+    page_size: int = 25,
+    with_page_info: bool = True,
+) -> Any:
+    body["startIndex"] = page * page_size
+    body["pageSize"] = page_size
+    return client.post(
+        f"/dwf/v1/omf/entities/{class_name}/objects",
+        params={
+            "pageIndex": page,
+            "pageSize": page_size,
+            "totalCount": str(with_page_info).lower(),
+        },
+        json=body,
+    )
+
+
+def get_object(
+    client: APIClient,
+    class_name: str,
+    oid: str,
+) -> Any:
+    return client.post(f"/dwf/v1/omf/entities/{class_name}/objects/{oid}")
+
+
+def create_objects(
+    client: APIClient,
+    class_name: str,
+    objects: list[dict[str, Any]],
+) -> Any:
+    return client.post(
+        f"/dwf/v1/omf/entities/{class_name}/objects-create",
+        json=objects,
+    )
+
+
+def update_objects(
+    client: APIClient,
+    class_name: str,
+    objects: list[dict[str, Any]],
+    *,
+    force_update: bool = False,
+) -> Any:
+    return client.post(
+        f"/dwf/v1/omf/entities/{class_name}/objects-update",
+        params={"forceUpdate": str(force_update).lower()},
+        json=objects,
+    )
+
+
+def delete_objects(
+    client: APIClient,
+    class_name: str,
+    oids: list[str],
+) -> Any:
+    return client.post(
+        f"/dwf/v1/omf/entities/{class_name}/objects-delete",
+        json=oids,
+    )
+
+
+def count_objects(
+    client: APIClient,
+    class_name: str,
+    *,
+    condition: str | None = None,
+) -> Any:
+    body: dict[str, Any] = {}
+    if condition:
+        body["condition"] = condition
+    return client.post(
+        f"/dwf/v1/omf/entities/{class_name}/objects/count",
+        json=body,
+    )
+
+
+def create_relations(
+    client: APIClient,
+    relations: list[dict[str, Any]],
+) -> Any:
+    return client.post("/dwf/v1/meta/relations-create", json=relations)
+
+
+def create_external_class(
+    client: APIClient,
+    class_list: list[dict[str, Any]],
+    custom_sql_map: dict[str, str] | None = None,
+) -> Any:
+    body: dict[str, Any] = {"classList": class_list}
+    if custom_sql_map:
+        body["customSqlMap"] = custom_sql_map
+    return client.post("/dwf/v1/meta/external-entities-create", json=body)
+
+
+def update_external_class(
+    client: APIClient,
+    class_list: list[dict[str, Any]],
+    custom_sql_map: dict[str, str] | None = None,
+) -> Any:
+    body: dict[str, Any] = {"classList": class_list}
+    if custom_sql_map:
+        body["customSqlMap"] = custom_sql_map
+    return client.post("/dwf/v1/meta/external-entities-update", json=body)
+
+
+def create_attributes(
+    client: APIClient,
+    attributes: list[dict[str, Any]],
+) -> Any:
+    return client.post("/dwf/v1/meta/attributes-create", json=attributes)
+
+
+def update_attribute(
+    client: APIClient,
+    attribute: dict[str, Any],
+) -> Any:
+    return client.post("/dwf/v1/meta/attributes-update", json=attribute)
+
+
+def delete_attribute(
+    client: APIClient,
+    name: str,
+    *,
+    force: bool = False,
+) -> Any:
+    return client.post(
+        f"/dwf/v1/meta/attributes-delete/{name}",
+        params={"force": str(force).lower()},
+    )
+
+
+def get_attribute(
+    client: APIClient,
+    name: str,
+) -> Any:
+    return client.get(f"/dwf/v1/meta/attributes/{name}")
+
+
+def get_attribute_bind_classes(
+    client: APIClient,
+    name: str,
+) -> Any:
+    return client.get(f"/dwf/v1/meta/attributes/{name}/bind-classes")
+
+
+def bind_attributes(
+    client: APIClient,
+    class_name: str,
+    attributes: list[dict[str, Any]],
+    *,
+    is_relation: bool = False,
+) -> Any:
+    prefix = "relations" if is_relation else "entities"
+    return client.post(
+        f"/dwf/v1/meta/{prefix}/{class_name}/attributes-bind",
+        json=attributes,
+    )
+
+
+def unbind_attribute(
+    client: APIClient,
+    class_name: str,
+    attr_name: str,
+    *,
+    is_relation: bool = False,
+) -> Any:
+    prefix = "relations" if is_relation else "entities"
+    return client.post(
+        f"/dwf/v1/meta/{prefix}/{class_name}/attributes-untie/{attr_name}",
+    )
+
+
+def get_import_uuid(
+    client: APIClient,
+    *,
+    update_if_exist: bool = False,
+) -> Any:
+    return client.get(
+        "/dwf/v1/importData/getImportDataUUID",
+        params={"updateIfExist": str(update_if_exist).lower()},
+    )
+
+
+def import_data(
+    client: APIClient,
+    uuid: str,
+    sock_id: str,
+    file_path: str,
+) -> Any:
+    with open(file_path, "rb") as f:
+        return client.post(
+            "/dwf/v1/importData/importData",
+            params={"uuid": uuid, "sockID": sock_id},
+            files={"file": f},
+        )
+
+
+def export_data(
+    client: APIClient,
+    class_name: str,
+    attributes: list[str],
+    *,
+    condition: str | None = None,
+    join_to_one: bool = False,
+    title_only: bool = False,
+) -> httpx.Response:
+    body: dict[str, Any] = {
+        "className": class_name,
+        "attributes": attributes,
+    }
+    if condition:
+        body["condition"] = condition
+    return client.download(
+        "/dwf/v1/exportData/exportData",
+        method="POST",
+        params={
+            "joinToOneSheet": str(join_to_one).lower(),
+            "titleOnly": str(title_only).lower(),
+        },
+        json=body,
+    )
+
+
+def upload_excel(
+    client: APIClient,
+    file_path: str,
+) -> Any:
+    with open(file_path, "rb") as f:
+        return client.post(
+            "/dwf/v1/quickStartFromExcel/uploadExcel",
+            files={"excelFile": f},
+        )
+
+
+def confirm_excel(
+    client: APIClient,
+    info: dict[str, Any],
+) -> Any:
+    return client.post(
+        "/dwf/v1/quickStartFromExcel/confirmClassInfo",
+        json=info,
+    )
+
+
+def check_class_name_valid(
+    client: APIClient,
+    class_name: str,
+) -> bool:
+    result = client.get(
+        "/dwf/v1/quickStartFromExcel/checkClassNameValid",
+        params={"className": class_name},
+    )
+    if isinstance(result, dict):
+        data = result.get("data", {})
+        if isinstance(data, dict):
+            return data.get("valid", False) is True
+    return False
+
+
+def check_attribute_type_valid(
+    client: APIClient,
+    attribute_name: str,
+    value_type: str,
+) -> bool:
+    result = client.get(
+        "/dwf/v1/quickStartFromExcel/checkAttributeTypeValid",
+        params={"attributeName": attribute_name, "valueType": value_type},
+    )
+    if isinstance(result, dict):
+        data = result.get("data", {})
+        if isinstance(data, dict):
+            return data.get("valid", False) is True
+    return False
+
+
+def delete_temp_excel(
+    client: APIClient,
+    uuid: str,
+) -> Any:
+    return client.get(
+        "/dwf/v1/quickStartFromExcel/deleteTempExcelFile",
+        params={"uuid": uuid},
+    )