makea-cli 0.1.1__py3-none-any.whl

makea_cli/commands/auth/cmd.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+import typer
+from rich.console import Console
+
+from makea_cli.auth_pkce import login_and_save
+from makea_cli.config import clear_credentials
+
+console = Console()
+
+
+def register(app: typer.Typer) -> None:
+    @app.command(
+        "auth",
+        help="Browser login (Cognito); saves tokens locally, or --logout to clear.",
+    )
+    def auth(
+        logout: bool = typer.Option(
+            False,
+            "--logout",
+            help="Remove locally saved tokens and exit.",
+        ),
+    ) -> None:
+        """
+        Sign in via Cognito Hosted UI in the browser and save tokens locally.
+
+        Input: optional --logout to clear saved credentials instead of logging in.
+
+        Output: on login, stores ID (and refresh when issued) token under the app config
+        directory; the Makea API accepts the ID token as Authorization: Bearer.
+        """
+        if logout:
+            clear_credentials()
+            console.print("[green]已退出登录（本机保存的登录信息已清除）。[/green]")
+            raise typer.Exit(0)
+        try:
+            login_and_save()
+        except Exception as e:
+            console.print(f"[red]{e}[/red]")
+            raise typer.Exit(1) from e
+        console.print("[green]登录成功，已保存在本机。[/green]")

makea_cli/commands/directory/__init__.py

@@ -0,0 +1,3 @@
+from makea_cli.commands.directory.cmd import register
+
+__all__ = ["register"]

makea_cli/commands/directory/cmd.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+import typer
+from rich.console import Console
+
+from makea_cli import api_client
+from makea_cli.commands._util import print_json_or_exit
+
+console = Console()
+
+
+def register(app: typer.Typer) -> None:
+    @app.command(
+        "list-users",
+        help="GET /admin/users — list registered users (admin, optional pagination).",
+    )
+    def list_users(
+        limit: int | None = typer.Option(
+            None,
+            "--limit",
+            "-n",
+            help="Optional page size (omit for one full response per server rules).",
+        ),
+        offset: int = typer.Option(
+            0,
+            "--offset",
+            help="Pagination offset (used with --limit).",
+        ),
+    ) -> None:
+        """
+        List registered users (admin).
+
+        Input: optional --limit / --offset for pagination (GET /admin/users query params).
+
+        Output: JSON body from the API (typically success, result, pagination when limited).
+        """
+        print_json_or_exit(
+            console, lambda: api_client.get_all_users(limit=limit, offset=offset)
+        )

makea_cli/commands/document/__init__.py

@@ -0,0 +1,3 @@
+from makea_cli.commands.document.cmd import register
+
+__all__ = ["register"]

makea_cli/commands/document/cmd.py

@@ -0,0 +1,182 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import typer
+from rich.console import Console
+
+from makea_cli import api_client
+
+console = Console()
+
+
+def _write_downloaded_file(
+    data: bytes,
+    *,
+    suggested: str | None,
+    fallback_name: str,
+    output: Path | None,
+) -> None:
+    out_path = output
+    if out_path is None:
+        out_path = Path.cwd() / (suggested or fallback_name)
+    out_path.write_bytes(data)
+    console.print(f"Wrote [green]{out_path.resolve()}[/green] ({len(data)} bytes)")
+
+
+def register(app: typer.Typer) -> None:
+    @app.command(
+        "download-document",
+        help=(
+            "GET /admin/document/download — save a document file "
+            "(document id + designer user_id)."
+        ),
+    )
+    def download_document(
+        document_id: str = typer.Argument(
+            ...,
+            help="Document id (same as document reference id / UUID in Dynamo).",
+        ),
+        user_id: str = typer.Option(
+            ...,
+            "--user-id",
+            "-u",
+            help="Designer user id (document owner); required by the API query string.",
+        ),
+        output: Path | None = typer.Option(
+            None,
+            "--output",
+            "-o",
+            help=(
+                "Output path. Default: current directory + filename from "
+                "Content-Disposition, or document_id if missing."
+            ),
+        ),
+        timeout: float = typer.Option(
+            120.0,
+            "--timeout",
+            "-t",
+            help="HTTP timeout in seconds.",
+            min=10.0,
+            max=3600.0,
+        ),
+    ) -> None:
+        """
+        Calls the same admin endpoint as the web app: **GET /admin/document/download**
+        with query parameters ``user_id`` and ``document_id``.
+
+        The backend may return a file body or redirect to a presigned URL; the client
+        follows redirects and writes the final bytes to disk.
+        """
+        try:
+            data, suggested = api_client.download_admin_document(
+                user_id=user_id,
+                document_id=document_id,
+                timeout=timeout,
+            )
+        except Exception as e:
+            console.print(f"[red]{e}[/red]")
+            raise typer.Exit(1) from e
+
+        _write_downloaded_file(
+            data, suggested=suggested, fallback_name=document_id, output=output
+        )
+
+    @app.command(
+        "download-product-document",
+        help=(
+            "Resolve product via list-product-orders payload, then GET /admin/document/download."
+        ),
+    )
+    def download_product_document(
+        product_reference_id: str = typer.Argument(
+            ...,
+            help="Product ``reference_id`` (or ``product_id``) as in list-product-orders JSON.",
+        ),
+        document_id: str = typer.Argument(
+            ...,
+            help="``document_id`` from that product's ``available_documents`` entry.",
+        ),
+        designer_user_id: str = typer.Option(
+            ...,
+            "--designer-user-id",
+            "-d",
+            help=(
+                "Designer Cognito ``user_id``. Command uses per-user product-order API; "
+                "no global list scan."
+            ),
+        ),
+        output: Path | None = typer.Option(
+            None,
+            "--output",
+            "-o",
+            help="Output path (default: cwd + Content-Disposition name or document_id).",
+        ),
+        timeout: float = typer.Option(
+            120.0,
+            "--timeout",
+            "-t",
+            help="HTTP timeout in seconds.",
+            min=10.0,
+            max=3600.0,
+        ),
+    ) -> None:
+        """
+        **Metadata source:** ``list-product-orders`` (and the per-user variant) already returns
+        ``user_id`` and each document's ``document_id`` under ``available_documents`` — no extra
+        metadata endpoint is required for this flow.
+
+        This command fetches one designer's product-order list, finds the product row,
+        checks the document exists, picks the correct ``user_id`` for the download query
+        (admin uploads use ``admin_user_id`` when present), then downloads the file.
+        """
+        payload = api_client.get_product_orders_by_user(designer_user_id)
+        product: dict[str, Any] | None = None
+        for row in payload.get("result") or []:
+            if (
+                isinstance(row, dict)
+                and (
+                    row.get("reference_id") == product_reference_id
+                    or row.get("product_id") == product_reference_id
+                )
+            ):
+                product = row
+                break
+        if not product:
+            console.print(
+                "[red]Product not found in this designer's product orders.[/red]"
+            )
+            raise typer.Exit(1)
+
+        doc_entry: dict[str, Any] | None = None
+        for raw in product.get("available_documents") or []:
+            if isinstance(raw, dict) and raw.get("document_id") == document_id:
+                doc_entry = raw
+                break
+        if not doc_entry:
+            console.print(
+                "[red]document_id not found on this product's available_documents.[/red]"
+            )
+            raise typer.Exit(1)
+
+        download_uid = api_client.effective_user_id_for_document_download(
+            product, doc_entry
+        )
+        if not download_uid:
+            console.print("[red]Could not determine user_id for download.[/red]")
+            raise typer.Exit(1)
+
+        try:
+            data, suggested = api_client.download_admin_document(
+                user_id=download_uid,
+                document_id=document_id,
+                timeout=timeout,
+            )
+        except Exception as e:
+            console.print(f"[red]{e}[/red]")
+            raise typer.Exit(1) from e
+
+        _write_downloaded_file(
+            data, suggested=suggested, fallback_name=document_id, output=output
+        )

makea_cli/commands/email/__init__.py

@@ -0,0 +1,3 @@
+from makea_cli.commands.email.cmd import register
+
+__all__ = ["register"]

makea_cli/commands/email/cmd.py

@@ -0,0 +1,122 @@
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from rich.console import Console
+
+from makea_cli import api_client
+from makea_cli.commands._util import print_json_or_exit
+
+console = Console()
+
+
+def register(app: typer.Typer) -> None:
+    @app.command(
+        "send-email",
+        help=(
+            "POST /admin/email/send — queue an HTML email (To required, Cc optional). "
+            "From must be @makea.co; HTML from --html-file or stdin ('-'). "
+            "Requires admin login (makea-cli auth)."
+        ),
+    )
+    def send_email(
+        from_email: str = typer.Option(
+            ...,
+            "--from",
+            help="Envelope From (must be @makea.co; supports 'Name <addr@makea.co>').",
+        ),
+        subject: str = typer.Option(
+            ...,
+            "--subject",
+            "-s",
+            help="Email Subject header.",
+        ),
+        to: Annotated[
+            list[str],
+            typer.Option(
+                "--to",
+                "-t",
+                help="To recipient (repeat per address). At least one required.",
+            ),
+        ] = [],
+        cc: Annotated[
+            list[str],
+            typer.Option(
+                "--cc",
+                "-c",
+                help="Cc recipient (repeat per address). Optional; omitted if unused.",
+            ),
+        ] = [],
+        html_file: Path | None = typer.Option(
+            None,
+            "--html-file",
+            "-f",
+            exists=False,
+            dir_okay=False,
+            help="UTF-8 HTML body file, or '-' to read HTML from stdin.",
+        ),
+        text: str | None = typer.Option(
+            None,
+            "--text",
+            help="Optional plain-text part (MIME alternative); if omitted, server derives from HTML.",
+        ),
+    ) -> None:
+        """
+        Queue an HTML email through ``POST /admin/email/send``.
+
+        **To** is required (``--to`` / ``-t``, repeat for multiple). **Cc** is optional
+        (``--cc`` / ``-c``). The API drops any Cc address that duplicates a To address.
+
+        **From** must use the ``makea.co`` domain. **HTML** comes from ``--html-file``
+        or from stdin when ``-f -``.
+
+        **Auth:** run ``makea-cli auth`` first with an admin account.
+
+        **Examples**::
+
+            makea-cli send-email --from noreply@makea.co -s "Hello" \\
+              -t one@example.com -t two@example.com -f ./body.html
+
+            makea-cli send-email --from alerts@makea.co -s "FYI" \\
+              -t lead@example.com --cc manager@example.com -f ./news.html
+
+            cat body.html | makea-cli send-email --from noreply@makea.co -s "Hi" \\
+              -t user@example.com -f -
+        """
+        if not to:
+            console.print("[red]Provide at least one --to recipient.[/red]")
+            raise typer.Exit(1)
+
+        if html_file is None:
+            console.print("[red]Provide --html-file (use '-' for stdin).[/red]")
+            raise typer.Exit(1)
+
+        p = html_file.expanduser()
+        if str(p) == "-":
+            html = sys.stdin.read()
+        else:
+            if not p.is_file():
+                console.print(f"[red]Not a file: {p}[/red]")
+                raise typer.Exit(1)
+            html = p.read_text(encoding="utf-8")
+
+        if not html.strip():
+            console.print("[red]HTML body is empty.[/red]")
+            raise typer.Exit(1)
+
+        body: dict[str, str | list[str]] = {
+            "from": from_email.strip(),
+            "to": [x.strip() for x in to if x.strip()],
+            "subject": subject.strip(),
+            "html": html,
+        }
+        cc_addrs = [x.strip() for x in cc if x.strip()]
+        if cc_addrs:
+            body["cc"] = cc_addrs
+        if text is not None and text.strip():
+            body["text"] = text.strip()
+
+        print_json_or_exit(console, lambda: api_client.send_admin_raw_email(body))

makea_cli/commands/metrics/cmd.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+import typer
+from rich.console import Console
+
+from makea_cli import api_client
+from makea_cli.commands._util import print_json_or_exit
+
+console = Console()
+
+_GRANULARITIES = ("day", "week", "month")
+_ORDER_TYPES = ("all", "sampling", "production")
+
+
+def register(app: typer.Typer) -> None:
+    @app.command(
+        "get-cumulative-payment-and-platform-revenue",
+        help=(
+            "GET /admin/business-metrics/cumulative-payment-and-platform-revenue — "
+            "platform-wide payment received and platform revenue (service fee + "
+            "transaction fee) bucketed over a date range."
+        ),
+    )
+    def get_cumulative_payment_and_platform_revenue(
+        start_date: str = typer.Option(
+            ...,
+            "--start-date",
+            help="Start date (inclusive), ISO format YYYY-MM-DD.",
+        ),
+        end_date: str = typer.Option(
+            ...,
+            "--end-date",
+            help="End date (inclusive), ISO format YYYY-MM-DD.",
+        ),
+        granularity: str = typer.Option(
+            "day",
+            "--granularity",
+            "-g",
+            help="Time bucket: day, week, or month. Default: day.",
+        ),
+        currency: str = typer.Option(
+            "GBP",
+            "--currency",
+            "-c",
+            help="Target currency for conversion. Default: GBP.",
+        ),
+        order_type: str = typer.Option(
+            "all",
+            "--order-type",
+            "-t",
+            help="Filter: all, sampling, or production. Default: all.",
+        ),
+    ) -> None:
+        """
+        Platform-wide cumulative payment received and platform revenue over a date range.
+
+        Calls GET /admin/business-metrics/cumulative-payment-and-platform-revenue.
+
+        Platform revenue = service fee + transaction fee (the 2.8% transaction fee is
+        applied by the server). The response contains two siblings under ``result``:
+
+        - ``payment_received``: cumulative/period amounts per bucket, plus a
+          ``payment_breakdown`` (sampling / production_deposit / production_final).
+        - ``platform_revenue``: cumulative/period amounts per bucket.
+
+        Input: required --start-date and --end-date (YYYY-MM-DD); optional
+        --granularity (day|week|month), --currency, --order-type (all|sampling|production).
+
+        Output: raw JSON body from the admin business-metrics endpoint.
+
+        This endpoint is **platform-wide only** and does not support filtering by
+        user_id, product, or category. For per-user / per-product drill-downs, use
+        list-product-orders / list-sampling-orders-by-product /
+        list-production-orders-by-product and aggregate client-side.
+        """
+        g = granularity.strip().lower()
+        if g not in _GRANULARITIES:
+            console.print(
+                f"[red]--granularity must be one of: {', '.join(_GRANULARITIES)}.[/red]"
+            )
+            raise typer.Exit(1)
+        ot = order_type.strip().lower()
+        if ot not in _ORDER_TYPES:
+            console.print(
+                f"[red]--order-type must be one of: {', '.join(_ORDER_TYPES)}.[/red]"
+            )
+            raise typer.Exit(1)
+
+        print_json_or_exit(
+            console,
+            lambda: api_client.get_cumulative_payment_and_platform_revenue(
+                start_date=start_date,
+                end_date=end_date,
+                granularity=g,
+                currency=currency,
+                order_type=ot,
+            ),
+        )

makea_cli/commands/orders/__init__.py

@@ -0,0 +1,3 @@
+from makea_cli.commands.orders.cmd import register
+
+__all__ = ["register"]