bocai-cli 0.1.0__py3-none-any.whl

bocai_cli/__init__.py

@@ -0,0 +1,3 @@
+__all__ = ["__version__"]
+
+__version__ = "0.1.0"

bocai_cli/api/__init__.py

@@ -0,0 +1,19 @@
+from bocai_cli.api.auth_client import AuthClient
+from bocai_cli.api.card_client import CardClient
+from bocai_cli.api.checkin_client import CheckinClient
+from bocai_cli.api.course_client import CourseClient
+from bocai_cli.api.facade import ApiFacade
+from bocai_cli.api.report_client import ReportClient
+from bocai_cli.api.reservation_client import ReservationClient
+from bocai_cli.api.transport import ApiTransport
+
+__all__ = [
+    "ApiFacade",
+    "ApiTransport",
+    "AuthClient",
+    "CardClient",
+    "CheckinClient",
+    "CourseClient",
+    "ReservationClient",
+    "ReportClient",
+]

bocai_cli/api/auth_client.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from typing import Any
+
+from bocai_cli.api.transport import ApiTransport
+from bocai_cli.errors import ApiRequestError
+
+
+class AuthClient:
+    def __init__(self, transport: ApiTransport) -> None:
+        self._transport = transport
+
+    def fetch_access_token(self, *, token_url: str, app_id: str, secret: str) -> str:
+        payload = self._transport.request(
+            "POST",
+            token_url,
+            json_body={"appId": app_id, "appSecret": secret},
+            absolute_url=True,
+            auth_required=False,
+        )
+        if isinstance(payload, dict):
+            value = payload.get("accessToken")
+            if isinstance(value, str) and value.strip():
+                return value.strip()
+
+        raise ApiRequestError("token 接口响应缺少 accessToken。")

bocai_cli/api/card_client.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+from typing import Any
+
+from bocai_cli.api.transport import ApiTransport
+
+
+class CardClient:
+    def __init__(self, transport: ApiTransport) -> None:
+        self._transport = transport
+
+    def sale_performance(
+        self,
+        *,
+        start_date: str,
+        end_date: str,
+        page_num: int,
+        page_size: int,
+        type_: int,
+        center_id: str | None = None,
+    ) -> Any:
+        params: dict[str, Any] = {
+            "startDate": start_date,
+            "endDate": end_date,
+            "pageNum": page_num,
+            "pageSize": page_size,
+            "type": type_,
+        }
+        if center_id is not None:
+            params["centerId"] = center_id
+        return self._transport.request("GET", "/api/bocai/card/sale", params=params)
+
+    def performance_clear(
+        self,
+        *,
+        transaction_ids: list[str],
+        phone: str,
+        center_id: str | None = None,
+    ) -> Any:
+        params: dict[str, Any] | None = None
+        if center_id is not None:
+            params = {"centerId": center_id}
+
+        return self._transport.request(
+            "POST",
+            "/api/bocai/course/performance/clear",
+            params=params,
+            json_body={"transactionIds": transaction_ids, "phone": phone},
+        )
+
+    def performance_update(
+        self,
+        *,
+        phone: str,
+        transactions: list[dict[str, Any]],
+        center_id: str | None = None,
+    ) -> Any:
+        params: dict[str, Any] | None = None
+        if center_id is not None:
+            params = {"centerId": center_id}
+
+        return self._transport.request(
+            "POST",
+            "/api/bocai/course/performance/update",
+            params=params,
+            json_body={"phone": phone, "transactions": transactions},
+        )
+
+    def performance_new(
+        self,
+        *,
+        type_: int,
+        payload: dict[str, Any],
+        center_id: str | None = None,
+    ) -> Any:
+        params: dict[str, Any] = {"type": type_}
+        if center_id is not None:
+            params["centerId"] = center_id
+
+        return self._transport.request(
+            "POST",
+            "/api/bocai/card/performance/new",
+            params=params,
+            json_body=payload,
+        )

bocai_cli/api/checkin_client.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from typing import Any
+
+from bocai_cli.api.transport import ApiTransport
+
+
+class CheckinClient:
+    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/checkin", params=params)

bocai_cli/api/course_client.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+from typing import Any
+
+from bocai_cli.api.transport import ApiTransport
+
+
+class CourseClient:
+    def __init__(self, transport: ApiTransport) -> None:
+        self._transport = transport
+
+    def sale_performance(
+        self,
+        *,
+        start_date: str,
+        end_date: str,
+        page_num: int,
+        page_size: int,
+        type_: int,
+        center_id: str | None = None,
+    ) -> Any:
+        params: dict[str, Any] = {
+            "startDate": start_date,
+            "endDate": end_date,
+            "pageNum": page_num,
+            "pageSize": page_size,
+            "type": type_,
+        }
+        if center_id is not None:
+            params["centerId"] = center_id
+        return self._transport.request("GET", "/api/bocai/course/sale", params=params)
+
+    def performance_clear(
+        self,
+        *,
+        transaction_ids: list[str],
+        phone: str,
+        center_id: str | None = None,
+    ) -> Any:
+        params: dict[str, Any] | None = None
+        if center_id is not None:
+            params = {"centerId": center_id}
+
+        return self._transport.request(
+            "POST",
+            "/api/bocai/course/performance/clear",
+            params=params,
+            json_body={"transactionIds": transaction_ids, "phone": phone},
+        )
+
+    def performance_update(
+        self,
+        *,
+        phone: str,
+        transactions: list[dict[str, Any]],
+        center_id: str | None = None,
+    ) -> Any:
+        params: dict[str, Any] | None = None
+        if center_id is not None:
+            params = {"centerId": center_id}
+
+        return self._transport.request(
+            "POST",
+            "/api/bocai/course/performance/update",
+            params=params,
+            json_body={"phone": phone, "transactions": transactions},
+        )
+
+    def performance_new(
+        self,
+        *,
+        type_: int,
+        payload: dict[str, Any],
+        center_id: str | None = None,
+    ) -> Any:
+        params: dict[str, Any] = {"type": type_}
+        if center_id is not None:
+            params["centerId"] = center_id
+
+        return self._transport.request(
+            "POST",
+            "/api/bocai/course/performance/new",
+            params=params,
+            json_body=payload,
+        )

bocai_cli/api/facade.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from bocai_cli.api.auth_client import AuthClient
+from bocai_cli.api.card_client import CardClient
+from bocai_cli.api.checkin_client import CheckinClient
+from bocai_cli.api.course_client import CourseClient
+from bocai_cli.api.report_client import ReportClient
+from bocai_cli.api.reservation_client import ReservationClient
+from bocai_cli.api.transport import ApiTransport
+
+
+class ApiFacade:
+    def __init__(
+        self,
+        *,
+        base_url: str | None,
+        token: str | None,
+        timeout_seconds: float = 30.0,
+    ) -> None:
+        self.transport = ApiTransport(
+            base_url=base_url,
+            token=token,
+            timeout_seconds=timeout_seconds,
+        )
+        self.auth = AuthClient(self.transport)
+        self.card = CardClient(self.transport)
+        self.checkin = CheckinClient(self.transport)
+        self.course = CourseClient(self.transport)
+        self.reservation = ReservationClient(self.transport)
+        self.report = ReportClient(self.transport)

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,153 @@
+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 = (base_url or "").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,
+        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:
+            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:
+                    response = http_client.request(
+                        method,
+                        url,
+                        headers=headers,
+                        params=params,
+                        json=json_body,
+                    )
+            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 target
+            if target.startswith("/"):
+                if not self.base_url:
+                    raise ConfigValidationError(
+                        "token_url 为相对路径时，配置中必须包含 base_url。",
+                        details={"missing": ["base_url"]},
+                    )
+                return 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 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 _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/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,7 @@
+from bocai_cli.commands.auth import app as auth_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", "checkin_app", "course_app", "reservation_app", "report_app"]

bocai_cli/commands/auth.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+from datetime import datetime, timezone
+
+import typer
+
+from bocai_cli.api import ApiFacade
+from bocai_cli.command_utils import command_handler
+from bocai_cli.config import load_config, save_config
+from bocai_cli.errors import ConfigValidationError
+from bocai_cli.output import print_json
+
+app = typer.Typer(help="鉴权相关命令。", invoke_without_command=True)
+
+
+@app.callback()
+def auth_root(ctx: typer.Context) -> None:
+    if ctx.invoked_subcommand is None:
+        typer.echo(ctx.get_help())
+        raise typer.Exit(code=0)
+
+
+def _build_api() -> ApiFacade:
+    config = load_config()
+    return ApiFacade(
+        base_url=config.base_url,
+        token=config.token,
+        timeout_seconds=config.timeout_seconds,
+    )
+
+
+@app.command("login", help="登录并获取accessToken")
+@command_handler
+def login() -> None:
+    config = load_config()
+    required_fields = ["base_url", "app_id", "secret"]
+    missing = [field for field in required_fields if not getattr(config, field)]
+    if missing:
+        raise ConfigValidationError(
+            "配置缺少获取 token 所需字段。",
+            details={"missing": missing},
+        )
+
+    api = _build_api()
+    new_token = api.auth.fetch_access_token(
+        token_url=config.token_url or "/api/auth/token",
+        app_id=config.app_id or "",
+        secret=config.secret or "",
+    )
+
+    previous_token = config.token
+    if previous_token and previous_token != new_token:
+        config.token_backup = previous_token
+
+    config.token = new_token
+    config.token_updated_at = datetime.now(timezone.utc).isoformat()
+    config_path = save_config(config)
+
+    print_json(
+        {
+            "status": "ok",
+            "message": "登录成功，token 已更新。",
+            "token_updated": True,
+            "config_path": str(config_path),
+        }
+    )