hap-cli 0.5.0__py3-none-any.whl

hap_cli/core/session.py

@@ -0,0 +1,348 @@
+"""Session management and API client for MingDAO HAP.
+
+URL routing by host type:
+- mingdao SaaS — three sub-environments sharing the same main API but
+  different workflow/report API subdomains:
+    www.mingdao.com    (production)   api  → api.mingdao.com
+    meihua.mingdao.com (pre-release)  api  → api2.mingdao.com
+    sandbox.mingdao.com (sandbox)     api  → api3.mingdao.com
+
+    main API  : https://www.mingdao.com/api/{Controller}/{Action}
+    workflow  : https://api{n}.mingdao.com/workflow/{path}
+    report    : https://api{n}.mingdao.com/report/{path}
+
+- nocoly (www.nocoly.com):
+    main API  : https://www.nocoly.com/wwwapi/{Controller}/{Action}
+    workflow  : https://www.nocoly.com/api/workflow/{path}
+    report    : https://www.nocoly.com/report/{path}
+
+- selfhosted (any other URL, e.g. https://p-demo.mingdaoyun.cn):
+    main API  : {login_url}/wwwapi/{Controller}/{Action}
+    workflow  : {login_url}/api/workflow/{path}
+    report    : {login_url}/report/{path}
+"""
+
+import json
+import os
+from pathlib import Path
+from typing import Any, Optional
+from urllib.parse import urlparse
+
+import requests
+
+CONFIG_DIR = Path.home() / ".hap-cli"
+CONFIG_FILE = CONFIG_DIR / "config.json"
+
+# MingDAO SaaS: login hostname -> API subdomain prefix for workflow/report
+# production uses "api", pre-release uses "api2", sandbox uses "api3"
+MINGDAO_API_SUBDOMAIN: dict[str, str] = {
+    "www.mingdao.com": "api",
+    "meihua.mingdao.com": "api2",
+    "sandbox.mingdao.com": "api3",
+}
+# All known MingDAO SaaS hostnames
+MINGDAO_HOSTS = set(MINGDAO_API_SUBDOMAIN.keys())
+# Known Nocoly SaaS hostnames
+NOCOLY_HOSTS = {"www.nocoly.com"}
+
+DEFAULT_CONFIG = {
+    "login_url": "",
+    "auth_token": "",
+    "default_app_id": "",
+    "default_project_id": "",
+}
+
+
+def _detect_host_type(url: str) -> str:
+    """Detect host type from any URL (login URL or API base).
+
+    Returns:
+        'mingdao', 'nocoly', or 'selfhosted'
+    """
+    if not url:
+        return "selfhosted"
+    full_url = url if "://" in url else f"https://{url}"
+    hostname = urlparse(full_url).hostname or ""
+    if hostname in MINGDAO_HOSTS or hostname.endswith(".mingdao.com"):
+        return "mingdao"
+    if hostname in NOCOLY_HOSTS or hostname.endswith(".nocoly.com"):
+        return "nocoly"
+    return "selfhosted"
+
+
+def _main_api_base_for_url(url: str) -> str:
+    """Return the main API base URL for any input URL (login URL or old API base).
+
+    Handles backward-compat: old configs stored API base like
+    'https://www.mingdao.com/api' or 'https://host/wwwapi'.
+    """
+    if not url:
+        return ""
+    host_type = _detect_host_type(url)
+    if host_type == "mingdao":
+        return "https://www.mingdao.com/api"
+    if host_type == "nocoly":
+        return "https://www.nocoly.com/wwwapi"
+    # Self-hosted: strip any /api or /wwwapi suffix from old configs
+    base = url.rstrip("/")
+    if base.endswith("/api"):
+        base = base[:-4]
+    elif base.endswith("/wwwapi"):
+        base = base[:-7]
+    return f"{base}/wwwapi"
+
+
+def _normalize_login_url(url: str) -> str:
+    """Normalize a stored URL to a clean login URL.
+
+    Old configs may have stored API base URLs like:
+    'https://www.mingdao.com/api' or 'https://host/wwwapi'.
+    Strips those suffixes to get the clean login URL.
+    """
+    if not url:
+        return ""
+    base = url.rstrip("/")
+    if base.endswith("/api"):
+        host_type = _detect_host_type(base[:-4])
+        if host_type == "mingdao":
+            return base[:-4]
+    if base.endswith("/wwwapi"):
+        return base[:-7]
+    return base
+
+
+class Session:
+    """Manages authentication and API communication with MingDAO server."""
+
+    def __init__(self, server_url: str = "", auth_token: str = ""):
+        # Store as login_url internally; server_url is the backward-compat name
+        self._login_url = server_url.rstrip("/")
+        self.auth_token = auth_token
+        self.default_app_id = ""
+        self.default_project_id = ""
+
+    # ── Properties ───────────────────────────────────────────────────────
+
+    @property
+    def login_url(self) -> str:
+        return self._login_url
+
+    @login_url.setter
+    def login_url(self, value: str) -> None:
+        self._login_url = value.rstrip("/")
+
+    @property
+    def server_url(self) -> str:
+        """Backward-compatible alias for login_url."""
+        return self._login_url
+
+    @server_url.setter
+    def server_url(self, value: str) -> None:
+        self._login_url = value.rstrip("/")
+
+    @property
+    def host_type(self) -> str:
+        """Detected host type: 'mingdao', 'nocoly', or 'selfhosted'."""
+        return _detect_host_type(self._login_url)
+
+    # ── API Base URLs ─────────────────────────────────────────────────────
+
+    def _main_api_base(self) -> str:
+        """Main API base for app/worksheet/record/role/contact etc."""
+        if self.host_type == "mingdao":
+            return "https://www.mingdao.com/api"
+        if self.host_type == "nocoly":
+            return "https://www.nocoly.com/wwwapi"
+        return f"{self._login_url}/wwwapi"
+
+    def _mingdao_api_subdomain(self) -> str:
+        """Return the API subdomain prefix for the current MingDAO environment.
+
+        www.mingdao.com    -> 'api'
+        meihua.mingdao.com -> 'api2'
+        sandbox.mingdao.com -> 'api3'
+        """
+        hostname = urlparse(
+            self._login_url if "://" in self._login_url else f"https://{self._login_url}"
+        ).hostname or ""
+        return MINGDAO_API_SUBDOMAIN.get(hostname, "api")
+
+    def _workflow_api_base(self) -> str:
+        """Workflow API base for process/node/instance operations."""
+        if self.host_type == "mingdao":
+            sub = self._mingdao_api_subdomain()
+            return f"https://{sub}.mingdao.com/workflow"
+        if self.host_type == "nocoly":
+            return "https://www.nocoly.com/api/workflow"
+        return f"{self._login_url}/api/workflow"
+
+    def _report_api_base(self) -> str:
+        """Report API base for statistics/analytics."""
+        if self.host_type == "mingdao":
+            sub = self._mingdao_api_subdomain()
+            return f"https://{sub}.mingdao.com/report"
+        if self.host_type == "nocoly":
+            return "https://www.nocoly.com/report"
+        return f"{self._login_url}/report"
+
+    # ── Core HTTP ─────────────────────────────────────────────────────────
+
+    def _post(
+        self,
+        url: str,
+        data: Optional[dict],
+        timeout: int,
+    ) -> dict[str, Any]:
+        """Execute a POST request with standard HAP headers."""
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"md_pss_id {self.auth_token}",
+            "X-Requested-With": "XMLHttpRequest",
+        }
+        response = requests.post(
+            url,
+            json=data or {},
+            headers=headers,
+            timeout=timeout,
+        )
+        response.raise_for_status()
+        result = response.json()
+        if result.get("state") == 0:
+            raise APIError(
+                result.get("exception", "Unknown API error"),
+                code=result.get("code"),
+            )
+        return result.get("data", result)
+
+    # ── API Call Methods ──────────────────────────────────────────────────
+
+    def api_call(
+        self,
+        controller: str,
+        action: str,
+        data: Optional[dict] = None,
+        timeout: int = 30,
+    ) -> dict[str, Any]:
+        """Make a main API call.
+
+        URL: {main_api_base}/{controller}/{action}
+
+        Args:
+            controller: API controller name (e.g., 'Worksheet')
+            action: API action name (e.g., 'GetFilterRows')
+            data: Request body data
+            timeout: Request timeout in seconds
+
+        Returns:
+            API response data
+        """
+        if not self.is_configured():
+            raise SessionError("Session not configured. Run 'config set' first.")
+        url = f"{self._main_api_base()}/{controller}/{action}"
+        return self._post(url, data, timeout)
+
+    def workflow_call(
+        self,
+        path: str,
+        data: Optional[dict] = None,
+        timeout: int = 30,
+    ) -> dict[str, Any]:
+        """Make a workflow API call.
+
+        URL: {workflow_api_base}/{path}
+
+        Args:
+            path: API path (e.g., 'process/add', 'flowNode/saveNode')
+            data: Request body data
+            timeout: Request timeout in seconds
+
+        Returns:
+            API response data
+        """
+        if not self.is_configured():
+            raise SessionError("Session not configured. Run 'config set' first.")
+        url = f"{self._workflow_api_base()}/{path.lstrip('/')}"
+        return self._post(url, data, timeout)
+
+    def report_call(
+        self,
+        path: str,
+        data: Optional[dict] = None,
+        timeout: int = 30,
+    ) -> dict[str, Any]:
+        """Make a report/analytics API call.
+
+        URL: {report_api_base}/{path}
+
+        Args:
+            path: API path
+            data: Request body data
+            timeout: Request timeout in seconds
+
+        Returns:
+            API response data
+        """
+        if not self.is_configured():
+            raise SessionError("Session not configured. Run 'config set' first.")
+        url = f"{self._report_api_base()}/{path.lstrip('/')}"
+        return self._post(url, data, timeout)
+
+    # ── Config Persistence ────────────────────────────────────────────────
+
+    @classmethod
+    def load(cls) -> "Session":
+        """Load session from config file."""
+        config = load_config()
+        # Support both new 'login_url' key and legacy 'server_url' key
+        raw_url = config.get("login_url") or config.get("server_url", "")
+        # Normalize: old configs may have stored the API base URL
+        login_url = _normalize_login_url(raw_url)
+        session = cls(
+            server_url=login_url,
+            auth_token=config.get("auth_token", ""),
+        )
+        session.default_app_id = config.get("default_app_id", "")
+        session.default_project_id = config.get("default_project_id", "")
+        return session
+
+    def save(self) -> None:
+        """Save session to config file."""
+        save_config(
+            {
+                "login_url": self._login_url,
+                "auth_token": self.auth_token,
+                "default_app_id": self.default_app_id,
+                "default_project_id": self.default_project_id,
+            }
+        )
+
+    def is_configured(self) -> bool:
+        """Check if session has login URL and auth token."""
+        return bool(self._login_url and self.auth_token)
+
+
+class SessionError(Exception):
+    """Raised when session is not properly configured."""
+
+
+class APIError(Exception):
+    """Raised when API returns an error."""
+
+    def __init__(self, message: str, code: Optional[int] = None):
+        super().__init__(message)
+        self.code = code
+
+
+def load_config() -> dict:
+    """Load config from file."""
+    if CONFIG_FILE.exists():
+        with open(CONFIG_FILE) as f:
+            return json.load(f)
+    return dict(DEFAULT_CONFIG)
+
+
+def save_config(config: dict) -> None:
+    """Save config to file."""
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    with open(CONFIG_FILE, "w") as f:
+        json.dump(config, f, indent=2)