bocai-cli-core 0.2.0__py3-none-any.whl

bocai_cli/api/month_dashboard_client.py

@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+from typing import Any
+
+from bocai_cli.api.transport import ApiTransport
+
+
+class MonthDashboardClient:
+    def __init__(self, transport: ApiTransport) -> None:
+        self._transport = transport
+
+    def _request_date_range(
+        self,
+        target: str,
+        *,
+        center_id: str,
+        start_date: str,
+        end_date: str,
+    ) -> Any:
+        return self._transport.request(
+            "GET",
+            target,
+            params={
+                "centerId": center_id,
+                "startDate": start_date,
+                "endDate": end_date,
+            },
+        )
+
+    def statistics(
+        self,
+        *,
+        center_id: str,
+        start_date: str,
+        end_date: str,
+    ) -> Any:
+        return self._request_date_range(
+            "/api/bocai/month/dashboard/month_payment",
+            center_id=center_id,
+            start_date=start_date,
+            end_date=end_date,
+        )
+
+    def recognize_income(
+        self,
+        *,
+        center_id: str,
+        start_date: str,
+        end_date: str,
+    ) -> Any:
+        return self._transport.request(
+            "GET",
+            "/api/bocai/month/dashboard/recognize/income",
+            params={
+                "centerId": center_id,
+                "type": 1,
+                "startDate": start_date,
+                "endDate": end_date,
+            },
+        )
+
+    def clue_conversion(
+        self,
+        *,
+        center_id: str,
+        start_date: str,
+        end_date: str,
+    ) -> Any:
+        return self._request_date_range(
+            "/api/bocai/month/dashboard/clue_conversion/count",
+            center_id=center_id,
+            start_date=start_date,
+            end_date=end_date,
+        )
+
+    def service_delivery(
+        self,
+        *,
+        center_id: str,
+        start_date: str,
+        end_date: str,
+    ) -> Any:
+        return self._request_date_range(
+            "/api/bocai/month/dashboard/service_delivery",
+            center_id=center_id,
+            start_date=start_date,
+            end_date=end_date,
+        )
+
+    def member_count(
+        self,
+        *,
+        center_id: str,
+        start_date: str,
+        end_date: str,
+    ) -> Any:
+        return self._request_date_range(
+            "/api/bocai/month/dashboard/member/count",
+            center_id=center_id,
+            start_date=start_date,
+            end_date=end_date,
+        )
+
+    def attendance_count(
+        self,
+        *,
+        center_id: str,
+        start_date: str,
+        end_date: str,
+    ) -> Any:
+        return self._request_date_range(
+            "/api/bocai/month/dashboard/attendance/count",
+            center_id=center_id,
+            start_date=start_date,
+            end_date=end_date,
+        )
+
+    def revenue_info(
+        self,
+        *,
+        center_id: str,
+        start_date: str,
+        end_date: str,
+    ) -> Any:
+        return self._request_date_range(
+            "/api/bocai/month/dashboard/revenue_info",
+            center_id=center_id,
+            start_date=start_date,
+            end_date=end_date,
+        )

bocai_cli/api/qywx_client.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from bocai_cli.api.transport import ApiTransport
+
+
+class QywxClient:
+    def __init__(self, transport: ApiTransport) -> None:
+        self._transport = transport
+
+    def send_message(self, *, center_id: str, payload: dict[str, Any]) -> Any:
+        return self._transport.request(
+            "POST",
+            "/api/bocai/qywx/message/send",
+            params={"centerId": center_id},
+            json_body=payload,
+        )
+
+    def upload(self, *, center_id: str, file_path: Path) -> Any:
+        with file_path.open("rb") as file_handle:
+            return self._transport.request(
+                "POST",
+                "/api/bocai/qywx/media/upload",
+                params={"centerId": center_id},
+                files={"file": (file_path.name, file_handle)},
+            )

bocai_cli/api/report_client.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from typing import Any
+
+from bocai_cli.api.transport import ApiTransport
+
+
+class ReportClient:
+    def __init__(self, transport: ApiTransport) -> None:
+        self._transport = transport
+
+    def get_revenue(
+        self,
+        *,
+        start_date: str | None = None,
+        end_date: str | None = None,
+        center_id: str | None = None,
+    ) -> Any:
+        params: dict[str, Any] | None = None
+        if start_date is not None and end_date is not None:
+            params = {"startDate": start_date, "endDate": end_date}
+        if center_id is not None:
+            if params is None:
+                params = {}
+            params["centerId"] = center_id
+        return self._transport.request("GET", "/api/bocai/revenue", params=params)
+
+    def get_revenue_detail(
+        self,
+        *,
+        type_: str,
+        start_date: str | None = None,
+        end_date: str | None = None,
+        center_id: str | None = None,
+    ) -> Any:
+        params: dict[str, Any] = {"type": type_}
+        if start_date is not None and end_date is not None:
+            params.update({"startDate": start_date, "endDate": end_date})
+        if center_id is not None:
+            params["centerId"] = center_id
+        return self._transport.request("GET", "/api/bocai/revenue/detail", params=params)

bocai_cli/api/reservation_client.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from typing import Any
+
+from bocai_cli.api.transport import ApiTransport
+
+
+class ReservationClient:
+    def __init__(self, transport: ApiTransport) -> None:
+        self._transport = transport
+
+    def list(
+        self,
+        *,
+        start_date: str,
+        end_date: str,
+        page_num: int,
+        page_size: int,
+        center_id: str | None = None,
+    ) -> Any:
+        params: dict[str, Any] = {
+            "startDate": start_date,
+            "endDate": end_date,
+            "pageNum": page_num,
+            "pageSize": page_size,
+        }
+        if center_id is not None:
+            params["centerId"] = center_id
+        return self._transport.request("GET", "/api/bocai/reservation", params=params)

bocai_cli/api/transport.py

@@ -0,0 +1,166 @@
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+from tenacity import retry, retry_if_exception, stop_after_attempt, wait_exponential
+
+from bocai_cli.errors import ApiRequestError, ConfigValidationError
+
+
+def _should_retry(exc: BaseException) -> bool:
+    if isinstance(exc, ApiRequestError):
+        return exc.status_code is None or exc.status_code >= 500
+    return False
+
+
+class ApiTransport:
+    def __init__(
+        self,
+        *,
+        base_url: str | None,
+        token: str | None,
+        timeout_seconds: float = 30.0,
+    ) -> None:
+        self.base_url = _upgrade_openapi_url((base_url or "").strip()).rstrip("/")
+        self.token = token
+        self.timeout_seconds = timeout_seconds
+
+    def request(
+        self,
+        method: str,
+        target: str,
+        *,
+        params: dict[str, Any] | None = None,
+        json_body: dict[str, Any] | None = None,
+        files: dict[str, Any] | None = None,
+        absolute_url: bool = False,
+        auth_required: bool = True,
+    ) -> Any:
+        url = self._build_url(target, absolute_url=absolute_url)
+        headers = self._build_headers(auth_required=auth_required)
+        if json_body is not None and files is None:
+            headers["Content-Type"] = "application/json"
+
+        @retry(
+            stop=stop_after_attempt(3),
+            wait=wait_exponential(multiplier=0.5, min=0.5, max=2),
+            retry=retry_if_exception(_should_retry),
+            reraise=True,
+        )
+        def _do_request() -> httpx.Response:
+            try:
+                with httpx.Client(timeout=self.timeout_seconds) as http_client:
+                    request_kwargs: dict[str, Any] = {
+                        "headers": headers,
+                        "params": params,
+                        "json": json_body,
+                    }
+                    if files is not None:
+                        request_kwargs["files"] = files
+
+                    response = http_client.request(method, url, **request_kwargs)
+            except httpx.TimeoutException as exc:
+                raise ApiRequestError("请求超时。") from exc
+            except httpx.RequestError as exc:
+                raise ApiRequestError("网络请求失败。") from exc
+
+            if response.status_code >= 500:
+                raise ApiRequestError(
+                    "服务暂时不可用，请稍后重试。",
+                    status_code=response.status_code,
+                )
+
+            if response.status_code >= 400:
+                raise ApiRequestError(
+                    _extract_error_message(response),
+                    status_code=response.status_code,
+                )
+            return response
+
+        response = _do_request()
+        if response.status_code == 204 or not response.text.strip():
+            return {}
+
+        try:
+            payload = response.json()
+        except ValueError as exc:
+            raise ApiRequestError("响应不是合法 JSON。", status_code=response.status_code) from exc
+
+        return self._unwrap_payload(payload, status_code=response.status_code)
+
+    def _unwrap_payload(self, payload: Any, *, status_code: int) -> Any:
+        if not isinstance(payload, dict) or "code" not in payload:
+            return payload
+
+        code = payload.get("code")
+        if code != 200:
+            message = payload.get("message")
+            if not isinstance(message, str) or not message.strip():
+                message = f"请求失败（code={code}）。"
+            raise ApiRequestError(
+                message.strip(),
+                status_code=status_code,
+                details={"code": code},
+            )
+
+        return payload.get("data")
+
+    def _build_url(self, target: str, *, absolute_url: bool) -> str:
+        if absolute_url:
+            if target.startswith("http://") or target.startswith("https://"):
+                return _upgrade_openapi_url(target)
+            if target.startswith("/"):
+                if not self.base_url:
+                    raise ConfigValidationError(
+                        "token_url 为相对路径时，配置中必须包含 base_url。",
+                        details={"missing": ["base_url"]},
+                    )
+                return _upgrade_openapi_url(f"{self.base_url}{target}")
+            raise ConfigValidationError(
+                "token_url 必须是完整 URL，或以 / 开头的相对路径。",
+                details={"invalid": ["token_url"]},
+            )
+
+        if not self.base_url:
+            raise ConfigValidationError(
+                "配置缺少 base_url。",
+                details={"missing": ["base_url"]},
+            )
+        return _upgrade_openapi_url(f"{self.base_url}{target}")
+
+    def _build_headers(self, *, auth_required: bool) -> dict[str, str]:
+        headers = {"Accept": "application/json"}
+        if auth_required:
+            if not self.token:
+                raise ConfigValidationError(
+                    "配置缺少 token。",
+                    details={"missing": ["token"]},
+                )
+            headers["Authorization"] = f"Bearer {self.token}"
+        return headers
+
+
+def _upgrade_openapi_url(url: str) -> str:
+    http_origin = "http://openapi.forzadata.cn"
+    https_origin = "https://openapi.forzadata.cn"
+    if url == http_origin:
+        return https_origin
+    if url.startswith(f"{http_origin}/"):
+        return f"{https_origin}/{url[len(http_origin) + 1 :]}"
+    return url
+
+
+def _extract_error_message(response: httpx.Response) -> str:
+    try:
+        payload = response.json()
+    except ValueError:
+        return f"请求失败（HTTP {response.status_code}）。"
+
+    if isinstance(payload, dict):
+        for field in ("message", "error", "detail"):
+            value = payload.get(field)
+            if isinstance(value, str) and value.strip():
+                return value.strip()
+
+    return f"请求失败（HTTP {response.status_code}）。"

bocai_cli/app.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+import typer
+
+from bocai_cli.commands.registry import register_commands
+from bocai_cli.product import PRODUCT_HELP, Product
+
+
+def create_app(product: Product) -> typer.Typer:
+    root_app = typer.Typer(no_args_is_help=True, help=PRODUCT_HELP[product])
+    register_commands(root_app, product=product)
+    return root_app

bocai_cli/client.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+from typing import Any
+
+from bocai_cli.api import ApiFacade
+
+
+class SaasClient:
+    """Deprecated: 请优先使用 bocai_cli.api.ApiFacade。"""
+
+    def __init__(
+        self,
+        *,
+        base_url: str | None,
+        token: str | None,
+        timeout_seconds: float = 30.0,
+    ) -> None:
+        self._api = ApiFacade(
+            base_url=base_url,
+            token=token,
+            timeout_seconds=timeout_seconds,
+        )
+
+    def get_revenue(
+        self,
+        *,
+        start_date: str | None = None,
+        end_date: str | None = None,
+    ) -> Any:
+        return self._api.report.get_revenue(start_date=start_date, end_date=end_date)
+
+    def get_revenue_detail(
+        self,
+        *,
+        type_: str,
+        start_date: str | None = None,
+        end_date: str | None = None,
+    ) -> Any:
+        return self._api.report.get_revenue_detail(
+            type_=type_,
+            start_date=start_date,
+            end_date=end_date,
+        )
+
+    def fetch_access_token(self, *, token_url: str, app_id: str, secret: str) -> str:
+        return self._api.auth.fetch_access_token(
+            token_url=token_url,
+            app_id=app_id,
+            secret=secret,
+        )
+
+    def _request(
+        self,
+        method: str,
+        target: str,
+        *,
+        params: dict[str, Any] | None = None,
+        json_body: dict[str, Any] | None = None,
+        absolute_url: bool = False,
+        auth_required: bool = True,
+    ) -> Any:
+        return self._api.transport.request(
+            method,
+            target,
+            params=params,
+            json_body=json_body,
+            absolute_url=absolute_url,
+            auth_required=auth_required,
+        )

bocai_cli/command_utils.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from functools import wraps
+from typing import Any, ParamSpec, TypeVar
+
+import typer
+
+from bocai_cli.errors import BocaiCliError
+from bocai_cli.output import print_error
+
+P = ParamSpec("P")
+R = TypeVar("R")
+
+
+def command_handler(func: Callable[P, R]) -> Callable[P, R]:
+    @wraps(func)
+    def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+        try:
+            return func(*args, **kwargs)
+        except BocaiCliError as exc:
+            print_error(exc.message, status_code=exc.status_code, details=exc.details)
+            raise typer.Exit(code=1)
+        except Exception:
+            print_error("发生未知错误。")
+            raise typer.Exit(code=1)
+
+    return wrapper

bocai_cli/commands/__init__.py

@@ -0,0 +1,8 @@
+from bocai_cli.commands.auth import app as auth_app
+from bocai_cli.commands.center import app as center_app
+from bocai_cli.commands.checkin import app as checkin_app
+from bocai_cli.commands.course import app as course_app
+from bocai_cli.commands.reservation import app as reservation_app
+from bocai_cli.commands.report import app as report_app
+
+__all__ = ["auth_app", "center_app", "checkin_app", "course_app", "reservation_app", "report_app"]