drinkzen-admin-cli 0.2.4__py3-none-any.whl

drinkzen_admin/__init__.py

@@ -0,0 +1,3 @@
+"""DrinkZen Admin CLI package."""
+
+__version__ = "0.2.4"

drinkzen_admin/cli.py

@@ -0,0 +1,547 @@
+"""CLI entry point for DrinkZen Admin operations."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+from typing import Any
+
+from .client import AdminCLIClient
+from .config import cmd_config_path, cmd_config_set, cmd_config_show
+from .formatting import format_cli_output
+from .menu_options import normalize_menu_option_config
+
+
+# ----------------------------------------------------------------------
+# Brand Commands
+# ----------------------------------------------------------------------
+
+
+def cmd_brand_list(
+    client: AdminCLIClient,
+    search: str | None = None,
+    active_only: bool = False,
+    is_json: bool = False,
+) -> int:
+    params: dict[str, Any] = {}
+    if search:
+        params["search"] = search
+    if active_only:
+        params["is_active"] = "true"
+
+    status, data = client.request("GET", "/api/admin/brands", params=params)
+    if status != 200:
+        print(format_cli_output({"error": data}, is_json))
+        return 1
+
+    print(format_cli_output(data, is_json))
+    return 0
+
+
+def cmd_brand_show(
+    client: AdminCLIClient, brand_id_or_name: str, is_json: bool = False
+) -> int:
+    status, l_data = client.request("GET", "/api/admin/brands", params={"search": brand_id_or_name})
+    if status == 200 and isinstance(l_data, list):
+        matched = [b for b in l_data if b.get("id") == brand_id_or_name or b.get("name") == brand_id_or_name]
+        if matched:
+            print(format_cli_output(matched[0], is_json))
+            return 0
+        if l_data:
+            print(format_cli_output(l_data[0], is_json))
+            return 0
+
+    status, data = client.request("GET", f"/api/admin/brands/{brand_id_or_name}")
+    if status != 200:
+        print(format_cli_output({"error": f"Brand '{brand_id_or_name}' not found", "details": data}, is_json))
+        return 1
+
+    print(format_cli_output(data, is_json))
+    return 0
+
+
+def cmd_brand_update(
+    client: AdminCLIClient,
+    brand_id_or_name: str,
+    name: str | None = None,
+    aliases: list[str] | None = None,
+    is_active: bool | None = None,
+    dry_run: bool = False,
+    is_json: bool = False,
+) -> int:
+    status, current = client.request("GET", f"/api/admin/brands/{brand_id_or_name}")
+    if status == 404 and not brand_id_or_name.startswith("brand-"):
+        l_status, l_data = client.request("GET", "/api/admin/brands", params={"search": brand_id_or_name})
+        if l_status == 200 and isinstance(l_data, list) and l_data:
+            current = l_data[0]
+            status = 200
+
+    if status != 200:
+        print(format_cli_output({"error": f"Brand '{brand_id_or_name}' not found", "details": current}, is_json))
+        return 1
+
+    brand_id = current["id"]
+    payload: dict[str, Any] = {}
+    if name is not None:
+        payload["name"] = name
+    if aliases is not None:
+        payload["aliases"] = aliases
+    if is_active is not None:
+        payload["is_active"] = is_active
+
+    if not payload:
+        print(format_cli_output({"message": "No updates specified"}, is_json))
+        return 0
+
+    if dry_run:
+        result = {
+            "dry_run": True,
+            "brand_id": brand_id,
+            "current": {k: current.get(k) for k in payload},
+            "proposed": payload,
+        }
+        print(format_cli_output(result, is_json))
+        return 0
+
+    u_status, u_data = client.request("PATCH", f"/api/admin/brands/{brand_id}", json_data=payload)
+    if u_status not in {200, 204}:
+        u_status, u_data = client.request("PUT", f"/api/admin/brands/{brand_id}", json_data=payload)
+    if u_status not in {200, 204}:
+        print(format_cli_output({"error": u_data}, is_json))
+        return 1
+
+    print(format_cli_output(u_data, is_json))
+    return 0
+
+
+def cmd_brand_set_logo(
+    client: AdminCLIClient,
+    brand_id_or_name: str,
+    file_path: str,
+    source_name: str | None = None,
+    source_url: str | None = None,
+    confidence: str | None = None,
+    dry_run: bool = False,
+    is_json: bool = False,
+) -> int:
+    path = Path(file_path)
+    if not path.is_file():
+        print(format_cli_output({"error": f"File not found: {file_path}"}, is_json))
+        return 1
+
+    status, current = client.request("GET", f"/api/admin/brands/{brand_id_or_name}")
+    if status == 404 and not brand_id_or_name.startswith("brand-"):
+        l_status, l_data = client.request("GET", "/api/admin/brands", params={"search": brand_id_or_name})
+        if l_status == 200 and isinstance(l_data, list) and l_data:
+            current = l_data[0]
+            status = 200
+
+    if status != 200:
+        print(format_cli_output({"error": f"Brand '{brand_id_or_name}' not found"}, is_json))
+        return 1
+
+    brand_id = current["id"]
+    content = path.read_bytes()
+
+    if dry_run:
+        result = {
+            "dry_run": True,
+            "brand_id": brand_id,
+            "file": str(path),
+            "file_size": len(content),
+            "source_name": source_name,
+            "source_url": source_url,
+            "confidence": confidence,
+        }
+        print(format_cli_output(result, is_json))
+        return 0
+
+    params = {}
+    if source_name:
+        params["source_name"] = source_name
+    if source_url:
+        params["source_url"] = source_url
+    if confidence:
+        params["confidence"] = confidence
+
+    files = {"file": (path.name, content, "image/png")}
+    u_status, u_data = client.request("POST", f"/api/admin/brands/{brand_id}/logo", params=params, files=files)
+    if u_status != 200:
+        print(format_cli_output({"error": u_data}, is_json))
+        return 1
+
+    print(format_cli_output(u_data, is_json))
+    return 0
+
+
+# ----------------------------------------------------------------------
+# Menu-Template Commands
+# ----------------------------------------------------------------------
+
+
+def cmd_menu_template_export(
+    client: AdminCLIClient,
+    brand_id_or_name: str,
+    out_file: str | None = None,
+    is_json: bool = False,
+) -> int:
+    status, current = client.request("GET", f"/api/admin/brands/{brand_id_or_name}")
+    if status == 404 and not brand_id_or_name.startswith("brand-"):
+        l_status, l_data = client.request("GET", "/api/admin/brands", params={"search": brand_id_or_name})
+        if l_status == 200 and isinstance(l_data, list) and l_data:
+            current = l_data[0]
+            status = 200
+
+    if status != 200:
+        print(format_cli_output({"error": f"Brand '{brand_id_or_name}' not found"}, is_json))
+        return 1
+
+    template = current.get("menu_option_template") or {"optionGroups": []}
+
+    if out_file:
+        out_path = Path(out_file)
+        out_path.write_text(json.dumps(template, ensure_ascii=False, indent=2), encoding="utf-8")
+        result = {"exported_to": str(out_path), "brand_id": current["id"], "template": template}
+        print(format_cli_output(result, is_json))
+        return 0
+
+    print(format_cli_output(template, is_json))
+    return 0
+
+
+def cmd_menu_template_validate(
+    template_data_or_file: str, is_json: bool = False
+) -> int:
+    try:
+        path = Path(template_data_or_file)
+        if path.is_file():
+            raw = json.loads(path.read_text(encoding="utf-8"))
+        else:
+            raw = json.loads(template_data_or_file)
+    except Exception as err:
+        print(format_cli_output({"error": f"Invalid JSON data: {err}"}, is_json))
+        return 1
+
+    try:
+        normalized = normalize_menu_option_config(raw)
+        result = {"valid": True, "errors": [], "normalized": normalized}
+        print(format_cli_output(result, is_json))
+        return 0
+    except ValueError as err:
+        result = {"valid": False, "errors": [str(err)], "normalized": None}
+        print(format_cli_output(result, is_json))
+        return 1
+
+
+def cmd_menu_template_apply(
+    client: AdminCLIClient,
+    brand_id_or_name: str,
+    template_file: str,
+    dry_run: bool = False,
+    is_json: bool = False,
+) -> int:
+    path = Path(template_file)
+    if not path.is_file():
+        print(format_cli_output({"error": f"File not found: {template_file}"}, is_json))
+        return 1
+
+    try:
+        template_raw = json.loads(path.read_text(encoding="utf-8"))
+    except Exception as err:
+        print(format_cli_output({"error": f"Invalid JSON file: {err}"}, is_json))
+        return 1
+
+    try:
+        normalized = normalize_menu_option_config(template_raw)
+    except ValueError as err:
+        print(format_cli_output({"error": "Template validation failed", "errors": [str(err)]}, is_json))
+        return 1
+
+    status, current = client.request("GET", f"/api/admin/brands/{brand_id_or_name}")
+    if status == 404 and not brand_id_or_name.startswith("brand-"):
+        l_status, l_data = client.request("GET", "/api/admin/brands", params={"search": brand_id_or_name})
+        if l_status == 200 and isinstance(l_data, list) and l_data:
+            current = l_data[0]
+            status = 200
+
+    if status != 200:
+        print(format_cli_output({"error": f"Brand '{brand_id_or_name}' not found"}, is_json))
+        return 1
+
+    brand_id = current["id"]
+
+    if dry_run:
+        result = {
+            "dry_run": True,
+            "brand_id": brand_id,
+            "current_template": current.get("menu_option_template"),
+            "proposed_template": normalized,
+        }
+        print(format_cli_output(result, is_json))
+        return 0
+
+    payload = {"menu_option_template": normalized}
+    u_status, u_data = client.request("PATCH", f"/api/admin/brands/{brand_id}", json_data=payload)
+    if u_status not in {200, 204}:
+        u_status, u_data = client.request("PUT", f"/api/admin/brands/{brand_id}", json_data=payload)
+    if u_status not in {200, 204}:
+        print(format_cli_output({"error": u_data}, is_json))
+        return 1
+
+    print(format_cli_output(u_data, is_json))
+    return 0
+
+
+# ----------------------------------------------------------------------
+# Review Commands
+# ----------------------------------------------------------------------
+
+
+def cmd_review_list(
+    client: AdminCLIClient,
+    status_filter: str | None = None,
+    limit: int = 20,
+    is_json: bool = False,
+) -> int:
+    params: dict[str, Any] = {"limit": limit}
+    if status_filter:
+        params["status"] = status_filter
+
+    status, data = client.request("GET", "/api/admin/review-tasks", params=params)
+    if status != 200:
+        print(format_cli_output({"error": data}, is_json))
+        return 1
+
+    print(format_cli_output(data, is_json))
+    return 0
+
+
+def cmd_review_show(
+    client: AdminCLIClient, task_id: str, is_json: bool = False
+) -> int:
+    status, data = client.request("GET", f"/api/admin/review-tasks/{task_id}/submission-context")
+    if status != 200:
+        print(format_cli_output({"error": data}, is_json))
+        return 1
+
+    print(format_cli_output(data, is_json))
+    return 0
+
+
+def cmd_review_resolve(
+    client: AdminCLIClient,
+    task_id: str,
+    action: str,
+    target_product_id: str | None = None,
+    reason: str | None = None,
+    dry_run: bool = False,
+    is_json: bool = False,
+) -> int:
+    action_map = {
+        "create": "approve_new",
+        "merge": "merge_existing",
+        "supplement": "accept_contribution",
+        "reject": "reject",
+    }
+    resolved_action = action_map.get(action, action)
+
+    payload: dict[str, Any] = {"action": resolved_action}
+    if target_product_id:
+        payload["target_product_id"] = target_product_id
+    if reason:
+        payload["resolution_note"] = reason
+
+    if dry_run:
+        ctx_status, ctx_data = client.request("GET", f"/api/admin/review-tasks/{task_id}/submission-context")
+        result = {
+            "dry_run": True,
+            "task_id": task_id,
+            "proposed_payload": payload,
+            "context": ctx_data if ctx_status == 200 else None,
+        }
+        print(format_cli_output(result, is_json))
+        return 0
+
+    r_status, r_data = client.request("POST", f"/api/admin/review-tasks/{task_id}/resolve", json_data=payload)
+    if r_status != 200:
+        print(format_cli_output({"error": r_data}, is_json))
+        return 1
+
+    print(format_cli_output(r_data, is_json))
+    return 0
+
+
+# ----------------------------------------------------------------------
+# CLI Main Parser
+# ----------------------------------------------------------------------
+
+
+def build_parser() -> argparse.ArgumentParser:
+    common_parser = argparse.ArgumentParser(add_help=False)
+    common_parser.add_argument("--url", default=None, help="DrinkZen Admin API Base URL")
+    common_parser.add_argument("--token", default=None, help="DrinkZen Admin Token")
+    common_parser.add_argument("--json", action="store_true", help="Output JSON format")
+    common_parser.add_argument("--dry-run", action="store_true", help="Preview modifications without writing")
+
+    parser = argparse.ArgumentParser(
+        prog="drinkzen-admin",
+        description="DrinkZen Admin CLI for brand, menu template, review, and configuration workflows.",
+        parents=[common_parser],
+    )
+
+    subparsers = parser.add_subparsers(dest="subcommand", required=True)
+
+    # config
+    config_parser = subparsers.add_parser("config", help="Configuration and secret management", parents=[common_parser])
+    config_sub = config_parser.add_subparsers(dest="config_action", required=True)
+
+    c_set = config_sub.add_parser("set", help="Save server URL and secret token to ~/.drinkzen/admin.json", parents=[common_parser])
+    c_set.add_argument("--set-url", dest="config_url", default=None, help="Server Base URL to save")
+    c_set.add_argument("--set-token", dest="config_token", default=None, help="Admin token to save")
+
+    c_show = config_sub.add_parser("show", help="Show active configuration with masked secrets", parents=[common_parser])
+    c_path = config_sub.add_parser("path", help="Print configuration file path", parents=[common_parser])
+
+    # brand
+    brand_parser = subparsers.add_parser("brand", help="Brand operations", parents=[common_parser])
+    brand_sub = brand_parser.add_subparsers(dest="brand_action", required=True)
+
+    b_list = brand_sub.add_parser("list", help="List brands", parents=[common_parser])
+    b_list.add_argument("--search", default=None, help="Filter by brand name or alias")
+    b_list.add_argument("--active-only", action="store_true", help="Filter active brands only")
+
+    b_show = brand_sub.add_parser("show", help="Show brand details", parents=[common_parser])
+    b_show.add_argument("brand", help="Brand ID or name")
+
+    b_update = brand_sub.add_parser("update", help="Update brand information", parents=[common_parser])
+    b_update.add_argument("brand", help="Brand ID or name")
+    b_update.add_argument("--name", default=None, help="New brand name")
+    b_update.add_argument("--alias", action="append", dest="aliases", default=None, help="Brand alias")
+    b_update.add_argument("--active", type=lambda v: v.lower() == "true", dest="is_active", default=None, help="Active status")
+
+    b_logo = brand_sub.add_parser("set-logo", help="Upload and set brand logo", parents=[common_parser])
+    b_logo.add_argument("brand", help="Brand ID or name")
+    b_logo.add_argument("file", help="Path to logo image file")
+    b_logo.add_argument("--source-name", default=None, help="Provenance source name")
+    b_logo.add_argument("--source-url", default=None, help="Provenance source URL")
+    b_logo.add_argument("--confidence", choices=["verified", "high", "medium", "low"], default=None)
+
+    # menu-template
+    menu_parser = subparsers.add_parser("menu-template", help="Menu template operations", parents=[common_parser])
+    menu_sub = menu_parser.add_subparsers(dest="menu_action", required=True)
+
+    m_export = menu_sub.add_parser("export", help="Export brand menu template", parents=[common_parser])
+    m_export.add_argument("brand", help="Brand ID or name")
+    m_export.add_argument("--out", default=None, help="Output file path")
+
+    m_validate = menu_sub.add_parser("validate", help="Validate menu template syntax", parents=[common_parser])
+    m_validate.add_argument("template", help="JSON string or file path")
+
+    m_apply = menu_sub.add_parser("apply", help="Apply menu template to brand", parents=[common_parser])
+    m_apply.add_argument("brand", help="Brand ID or name")
+    m_apply.add_argument("file", help="Template JSON file path")
+
+    # review
+    review_parser = subparsers.add_parser("review", help="Review workflow operations", parents=[common_parser])
+    review_sub = review_parser.add_subparsers(dest="review_action", required=True)
+
+    r_list = review_sub.add_parser("list", help="List review tasks", parents=[common_parser])
+    r_list.add_argument("--status", choices=["pending", "done", "rejected"], default=None)
+    r_list.add_argument("--limit", type=int, default=20)
+
+    r_show = review_sub.add_parser("show", help="Show review task context", parents=[common_parser])
+    r_show.add_argument("task_id", help="Review task ID")
+
+    r_resolve = review_sub.add_parser("resolve", help="Resolve review task", parents=[common_parser])
+    r_resolve.add_argument("task_id", help="Review task ID")
+    r_resolve.add_argument("action", choices=["create", "merge", "supplement", "reject"])
+    r_resolve.add_argument("--target-product-id", default=None)
+    r_resolve.add_argument("--reason", default=None)
+
+    return parser
+
+
+def main(args: list[str] | None = None) -> int:
+    parser = build_parser()
+    parsed = parser.parse_args(args)
+
+    is_json = getattr(parsed, "json", False)
+    dry_run = getattr(parsed, "dry_run", False)
+
+    # Config commands
+    if parsed.subcommand == "config":
+        if parsed.config_action == "set":
+            url = parsed.config_url or parsed.url
+            token = parsed.config_token or parsed.token
+            return cmd_config_set(url=url, token=token, is_json=is_json)
+        if parsed.config_action == "show":
+            return cmd_config_show(is_json=is_json)
+        if parsed.config_action == "path":
+            return cmd_config_path(is_json=is_json)
+
+    client = AdminCLIClient(base_url=parsed.url, token=parsed.token)
+
+    if parsed.subcommand == "brand":
+        if parsed.brand_action == "list":
+            return cmd_brand_list(client, search=parsed.search, active_only=parsed.active_only, is_json=is_json)
+        if parsed.brand_action == "show":
+            return cmd_brand_show(client, brand_id_or_name=parsed.brand, is_json=is_json)
+        if parsed.brand_action == "update":
+            return cmd_brand_update(
+                client,
+                brand_id_or_name=parsed.brand,
+                name=parsed.name,
+                aliases=parsed.aliases,
+                is_active=parsed.is_active,
+                dry_run=dry_run,
+                is_json=is_json,
+            )
+        if parsed.brand_action == "set-logo":
+            return cmd_brand_set_logo(
+                client,
+                brand_id_or_name=parsed.brand,
+                file_path=parsed.file,
+                source_name=parsed.source_name,
+                source_url=parsed.source_url,
+                confidence=parsed.confidence,
+                dry_run=dry_run,
+                is_json=is_json,
+            )
+
+    if parsed.subcommand == "menu-template":
+        if parsed.menu_action == "export":
+            return cmd_menu_template_export(client, brand_id_or_name=parsed.brand, out_file=parsed.out, is_json=is_json)
+        if parsed.menu_action == "validate":
+            return cmd_menu_template_validate(template_data_or_file=parsed.template, is_json=is_json)
+        if parsed.menu_action == "apply":
+            return cmd_menu_template_apply(
+                client,
+                brand_id_or_name=parsed.brand,
+                template_file=parsed.file,
+                dry_run=dry_run,
+                is_json=is_json,
+            )
+
+    if parsed.subcommand == "review":
+        if parsed.review_action == "list":
+            return cmd_review_list(client, status_filter=parsed.status, limit=parsed.limit, is_json=is_json)
+        if parsed.review_action == "show":
+            return cmd_review_show(client, task_id=parsed.task_id, is_json=is_json)
+        if parsed.review_action == "resolve":
+            return cmd_review_resolve(
+                client,
+                task_id=parsed.task_id,
+                action=parsed.action,
+                target_product_id=parsed.target_product_id,
+                reason=parsed.reason,
+                dry_run=dry_run,
+                is_json=is_json,
+            )
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

drinkzen_admin/client.py

@@ -0,0 +1,90 @@
+"""HTTP client for DrinkZen Admin API (Python Standard Library only)."""
+
+from __future__ import annotations
+
+import json
+import os
+import urllib.error
+import urllib.parse
+import urllib.request
+import uuid
+from typing import Any
+
+from .config import load_config
+
+
+class AdminCLIClient:
+    """Client for performing HTTP requests against DrinkZen Admin API."""
+
+    def __init__(self, base_url: str | None = None, token: str | None = None) -> None:
+        file_conf = load_config()
+        resolved_url = (
+            base_url
+            or os.environ.get("DRINKZEN_API_BASE_URL")
+            or file_conf.get("url")
+            or "http://localhost:8000"
+        )
+        resolved_token = (
+            token
+            or os.environ.get("DRINKZEN_ADMIN_TOKEN")
+            or file_conf.get("token")
+            or "local-admin-token"
+        )
+
+        self.base_url = resolved_url.rstrip("/")
+        self.token = resolved_token
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        params: dict[str, Any] | None = None,
+        json_data: dict[str, Any] | list[Any] | None = None,
+        files: dict[str, Any] | None = None,
+    ) -> tuple[int, Any]:
+        """Perform an HTTP request returning (status_code, data_or_dict)."""
+        headers = {"X-Admin-Token": self.token}
+
+        quoted_path = urllib.parse.quote(path, safe="/:?&=#+%,@_~")
+        url = f"{self.base_url}{quoted_path}"
+        if params:
+            query = urllib.parse.urlencode({k: v for k, v in params.items() if v is not None})
+            if query:
+                url = f"{url}?{query}" if "?" not in url else f"{url}&{query}"
+
+        body = None
+        if files:
+            boundary = f"----WebKitFormBoundary{uuid.uuid4().hex}"
+            headers["Content-Type"] = f"multipart/form-data; boundary={boundary}"
+            body_parts = []
+            for field, file_info in files.items():
+                filename, content, mime_type = file_info
+                body_parts.append(f"--{boundary}\r\n".encode("utf-8"))
+                body_parts.append(
+                    f'Content-Disposition: form-data; name="{field}"; filename="{filename}"\r\n'.encode("utf-8")
+                )
+                body_parts.append(f"Content-Type: {mime_type}\r\n\r\n".encode("utf-8"))
+                body_parts.append(content if isinstance(content, bytes) else content.encode("utf-8"))
+                body_parts.append(b"\r\n")
+            body_parts.append(f"--{boundary}--\r\n".encode("utf-8"))
+            body = b"".join(body_parts)
+        elif json_data is not None:
+            body = json.dumps(json_data).encode("utf-8")
+            headers["Content-Type"] = "application/json"
+
+        req = urllib.request.Request(url, data=body, headers=headers, method=method)
+        try:
+            with urllib.request.urlopen(req) as resp:
+                status = resp.status
+                raw = resp.read().decode("utf-8")
+                data = json.loads(raw) if raw else {}
+                return status, data
+        except urllib.error.HTTPError as err:
+            try:
+                raw = err.read().decode("utf-8")
+                data = json.loads(raw) if raw else {"detail": str(err)}
+            except Exception:
+                data = {"detail": str(err)}
+            return err.code, data
+        except urllib.error.URLError as err:
+            return 503, {"detail": f"Failed to connect to API at {self.base_url}: {err.reason}"}

drinkzen_admin/config.py

@@ -0,0 +1,130 @@
+"""Configuration and secret storage management for DrinkZen Admin CLI."""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+from pathlib import Path
+from typing import Any
+
+from .formatting import format_cli_output
+
+DEFAULT_CONFIG_DIR = Path.home() / ".drinkzen"
+DEFAULT_CONFIG_FILE = DEFAULT_CONFIG_DIR / "admin.json"
+
+
+def get_config_path() -> Path:
+    """Return the absolute path to the admin configuration file."""
+    custom = os.environ.get("DRINKZEN_ADMIN_CONFIG_PATH")
+    if custom:
+        return Path(custom).expanduser().resolve()
+    return DEFAULT_CONFIG_FILE
+
+
+def load_config() -> dict[str, str]:
+    """Load configuration from ~/.drinkzen/admin.json if it exists."""
+    path = get_config_path()
+    if not path.is_file():
+        return {}
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+        if isinstance(data, dict):
+            return {
+                "url": str(data.get("url", "")).strip(),
+                "token": str(data.get("token", "")).strip(),
+            }
+    except Exception:
+        pass
+    return {}
+
+
+def save_config(url: str | None = None, token: str | None = None) -> dict[str, str]:
+    """Save URL and Token to ~/.drinkzen/admin.json with chmod 600 permissions."""
+    path = get_config_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+    current = load_config()
+    if url is not None:
+        current["url"] = url.strip()
+    if token is not None:
+        current["token"] = token.strip()
+
+    # Clean empty values
+    clean = {k: v for k, v in current.items() if v}
+    content = json.dumps(clean, ensure_ascii=False, indent=2) + "\n"
+
+    # Write file
+    path.write_text(content, encoding="utf-8")
+
+    # Secure file permissions (POSIX: 0600 - user read/write only)
+    if sys.platform != "win32":
+        try:
+            os.chmod(path, 0o600)
+        except OSError:
+            pass
+
+    return clean
+
+
+def mask_token(token: str) -> str:
+    """Mask secret token for safe terminal output."""
+    if not token:
+        return ""
+    if len(token) <= 8:
+        return "****"
+    return f"{token[:4]}****{token[-4:]}"
+
+
+def cmd_config_set(
+    url: str | None = None,
+    token: str | None = None,
+    is_json: bool = False,
+) -> int:
+    """Save configuration to admin.json."""
+    if url is None and token is None:
+        print(format_cli_output({"error": "Please provide --url or --token to save"}, is_json))
+        return 1
+
+    saved = save_config(url=url, token=token)
+    result = {
+        "message": "Configuration saved successfully",
+        "path": str(get_config_path()),
+        "url": saved.get("url", ""),
+        "token": mask_token(saved.get("token", "")),
+    }
+    print(format_cli_output(result, is_json))
+    return 0
+
+
+def cmd_config_show(is_json: bool = False) -> int:
+    """Show current active configuration and secret masking."""
+    path = get_config_path()
+    file_conf = load_config()
+
+    env_url = os.environ.get("DRINKZEN_API_BASE_URL")
+    env_token = os.environ.get("DRINKZEN_ADMIN_TOKEN")
+
+    active_url = env_url or file_conf.get("url") or "http://localhost:8000"
+    active_token = env_token or file_conf.get("token") or "local-admin-token"
+
+    result = {
+        "config_file": str(path),
+        "file_exists": path.is_file(),
+        "active_url": active_url,
+        "url_source": "environment" if env_url else ("file" if file_conf.get("url") else "default"),
+        "active_token": mask_token(active_token),
+        "token_source": "environment" if env_token else ("file" if file_conf.get("token") else "default"),
+    }
+    print(format_cli_output(result, is_json))
+    return 0
+
+
+def cmd_config_path(is_json: bool = False) -> int:
+    """Print configuration file path."""
+    path = get_config_path()
+    if is_json:
+        print(json.dumps({"path": str(path), "exists": path.is_file()}))
+    else:
+        print(str(path))
+    return 0

drinkzen_admin/formatting.py

@@ -0,0 +1,34 @@
+"""Formatting helpers for DrinkZen Admin CLI."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+
+def format_cli_output(data: Any, is_json: bool) -> str:
+    """Format data as JSON or formatted text."""
+    if is_json:
+        return json.dumps(data, ensure_ascii=False, indent=2)
+
+    if isinstance(data, list):
+        lines = [f"Total: {len(data)}"]
+        for idx, item in enumerate(data, 1):
+            if isinstance(item, dict):
+                name = item.get("name") or item.get("id") or f"Item {idx}"
+                desc = f" (ID: {item.get('id', 'N/A')})" if "id" in item else ""
+                lines.append(f"  {idx}. {name}{desc}")
+            else:
+                lines.append(f"  {idx}. {item}")
+        return "\n".join(lines)
+
+    if isinstance(data, dict):
+        lines = []
+        for k, v in data.items():
+            if isinstance(v, (dict, list)):
+                lines.append(f"{k}: {json.dumps(v, ensure_ascii=False)}")
+            else:
+                lines.append(f"{k}: {v}")
+        return "\n".join(lines)
+
+    return str(data)

drinkzen_admin/menu_options.py

@@ -0,0 +1,76 @@
+"""Standalone validator for brand menu option templates."""
+
+from __future__ import annotations
+
+from copy import deepcopy
+from typing import Any
+
+VALID_SELECTION_TYPES = {"single", "multiple"}
+
+
+def normalize_menu_option_config(value: dict[str, Any] | None) -> dict[str, Any]:
+    """Validate and normalize a brand menu option template.
+
+    Raises ValueError with descriptive message if validation fails.
+    """
+    if not value:
+        return {}
+    if not isinstance(value, dict):
+        raise ValueError("Menu option configuration must be an object")
+
+    normalized = deepcopy(value)
+    groups = normalized.get("optionGroups", [])
+    if not isinstance(groups, list):
+        raise ValueError("optionGroups must be an array")
+
+    seen: set[str] = set()
+    for group in groups:
+        if not isinstance(group, dict):
+            raise ValueError("Each option group must be an object")
+
+        key = str(group.get("key", "")).strip()
+        label = str(group.get("label", "")).strip()
+        values = group.get("values", [])
+
+        if not key or not label:
+            raise ValueError("Each option group requires key and label")
+
+        if key in seen:
+            raise ValueError(f"Duplicate option group key: {key}")
+        seen.add(key)
+
+        if not isinstance(values, list) or not all(
+            isinstance(item, str) and item.strip() for item in values
+        ):
+            raise ValueError(f"Option group {key} requires non-empty string values")
+
+        clean_values = list(dict.fromkeys(item.strip() for item in values))
+        selection_type = group.get("selectionType", "single")
+        if selection_type not in VALID_SELECTION_TYPES:
+            raise ValueError(f"Invalid selectionType for {key}")
+
+        defaults = group.get("defaultValues", [])
+        if not isinstance(defaults, list) or any(item not in clean_values for item in defaults):
+            raise ValueError(f"defaultValues must exist in values for {key}")
+        if selection_type == "single" and bool(group.get("required", False)):
+            defaults = clean_values[:1]
+        elif selection_type == "multiple" and not bool(group.get("required", False)):
+            defaults = []
+
+        minimum = group.get("minSelections")
+        maximum = group.get("maxSelections")
+        if minimum is not None and (not isinstance(minimum, int) or minimum < 0):
+            raise ValueError(f"Invalid minSelections for {key}")
+        if maximum is not None and (not isinstance(maximum, int) or maximum < 1):
+            raise ValueError(f"Invalid maxSelections for {key}")
+        if minimum is not None and maximum is not None and minimum > maximum:
+            raise ValueError(f"minSelections cannot exceed maxSelections for {key}")
+
+        group["key"] = key
+        group["label"] = label
+        group["values"] = clean_values
+        group["selectionType"] = selection_type
+        group["defaultValues"] = defaults
+
+    normalized["optionGroups"] = groups
+    return normalized

drinkzen_admin_cli-0.2.4.dist-info/METADATA

@@ -0,0 +1,181 @@
+Metadata-Version: 2.4
+Name: drinkzen-admin-cli
+Version: 0.2.4
+Summary: Standalone CLI client for DrinkZen Admin operations
+Author: DrinkZen Team
+License: MIT
+Project-URL: Homepage, https://drinkzen.cn
+Project-URL: Source, https://github.com/xiaolinstar/drinkzen
+Project-URL: Issues, https://github.com/xiaolinstar/drinkzen/issues
+Keywords: drinkzen,admin,beverage,operations,cli
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# drinkzen-admin-cli
+
+`drinkzen-admin-cli` 是奶茶仙人（DrinkZen）运营管理后台的轻量级、零外部依赖 Python 命令行工具。
+可由管理员直接在终端使用，也可挂载至用户自己的 AI Agent（如 Antigravity / Claude / Cursor 等）进行安全的辅助审核与菜单数据治理。
+
+> 💡 **命令定位说明**：
+>
+> - `drinkzen-admin`：管理员与数据运营专属 CLI，用于配置管理、品牌管理、菜单模板配置、Logo 上传与用户贡献审核。
+> - `drinkzen`：（规划中）普通用户专属 CLI，用于查询饮品热量、记录饮用与管理每日预算。
+
+---
+
+## 快速安装与分发方式
+
+### 方式 1：通过 PyPI 安装（正式发布后推荐）
+
+```bash
+pipx install drinkzen-admin-cli
+```
+
+### 方式 2：通过 Git URL 一键直接安装（预发布或源码验证）
+
+```bash
+pip install "git+https://github.com/xiaolinstar/drinkzen.git#subdirectory=packages/admin-cli"
+```
+
+### 方式 3：通过 pipx 隔离环境运行 Git 源码（免污染系统 Python）
+
+```bash
+pipx run --spec "git+https://github.com/xiaolinstar/drinkzen.git#subdirectory=packages/admin-cli" drinkzen-admin config show
+```
+
+### 方式 4：在 Monorepo 本地源码开发运行
+
+```bash
+# 可编辑安装
+pip install -e packages/admin-cli
+
+# 或直接通过 Python 模块运行
+PYTHONPATH=packages/admin-cli python3 -m drinkzen_admin.cli config show
+```
+
+---
+
+## 密钥与持久化配置管理 (`config`)
+
+`drinkzen-admin` 提供了内置的密钥持久化管理，避免每次在终端手动输入敏感 Token 或将其留在 Bash 历史记录中。
+
+### 1. 一键保存服务端地址与 Secret
+
+```bash
+# 保存远程生产 API 与 Admin Token
+drinkzen-admin config set --set-url "https://api.drinkzen.cn" --set-token "your-secret-admin-token"
+
+# 保存本地开发 API
+drinkzen-admin config set --set-url "http://api.drinkzen.localhost:8000" --set-token "local-admin-token"
+```
+
+配置文件将保存在 `~/.drinkzen/admin.json`，且在 Unix/macOS 系统上自动设置 **`chmod 600`** 权限（仅当前系统用户可读写）。
+
+### 2. 查看当前生效的配置与 Secret 脱敏展示
+
+```bash
+drinkzen-admin config show --json
+```
+
+输出示例：
+
+```json
+{
+  "config_file": "/Users/admin/.drinkzen/admin.json",
+  "file_exists": true,
+  "active_url": "https://api.drinkzen.cn",
+  "url_source": "file",
+  "active_token": "secr****1234",
+  "token_source": "file"
+}
+```
+
+### 3. 配置加载优先级
+
+当执行命令时，配置按如下优先级依次生效：
+
+1. **显式命令行参数**：`--url "..."` / `--token "..."`
+2. **系统环境变量**：`DRINKZEN_API_BASE_URL` / `DRINKZEN_ADMIN_TOKEN`
+3. **用户配置文件**：`~/.drinkzen/admin.json`
+4. **内置默认值**：`http://localhost:8000` / `local-admin-token`
+
+---
+
+## 常用业务命令速查
+
+配置好 Secret 后，日常执行命令无需再附带 URL 和 Token：
+
+### 1. 品牌管理 (`brand`)
+
+```bash
+# 查看品牌列表（支持 --search 与 --active-only）
+drinkzen-admin brand list --search "霸王" --json
+
+# 查看具体品牌详情
+drinkzen-admin brand show 霸王茶姬 --json
+
+# 更新品牌名称/别名/启用状态（--dry-run 仅预览变更，不真正写库）
+drinkzen-admin brand update 霸王茶姬 --name "霸王茶姬 CHAGEE" --alias "CHAGEE" --dry-run --json
+
+# 上传品牌 Logo 并标注数据置信度
+drinkzen-admin brand set-logo 霸王茶姬 ./logo.png --confidence verified --source-name "官方小程序"
+```
+
+### 2. 菜单模板管理 (`menu-template`)
+
+```bash
+# 导出品牌菜单模板到本地文件
+drinkzen-admin menu-template export 霸王茶姬 --out chagee.json
+
+# 本地离线校验 JSON 模板合法性
+drinkzen-admin menu-template validate chagee.json --json
+
+# 预览应用新模板到指定品牌
+drinkzen-admin menu-template apply 霸王茶姬 chagee.json --dry-run --json
+```
+
+### 3. 审核任务管理 (`review`)
+
+```bash
+# 列出待审核任务
+drinkzen-admin review list --status pending --limit 10 --json
+
+# 查看某个审核任务上下文与用户提交数据
+drinkzen-admin review show 102 --json
+
+# 审核处理（动作支持 create / merge / supplement / reject）
+drinkzen-admin review resolve 102 create --reason "官方菜单确认无误，同意入库" --dry-run --json
+```
+
+---
+
+## 安全设计原则
+
+1. **零外部第三方依赖**：仅使用 Python 标准库，保证极致的安全与跨平台兼容性。
+2. **不直连数据库**：所有写操作通过带有权限校验与审计追踪的 RESTful API 完成。
+3. **Secret 安全隔离**：配置文件自动进行 0600 文件权限保护，`show` 输出自动脱敏，防止日志/录屏泄露。
+4. **全命令支持 `--dry-run` 与 `--json`**：便于 AI Agent 输出结构化建议并在人工确认后再执行真正变更。
+
+---
+
+## 发布维护说明
+
+发布由 GitHub Actions 的 **Publish Admin CLI** workflow 完成，使用 PyPI Trusted Publishing（OIDC），不使用长期 PyPI Token。
+
+首次发布前，项目维护者需要在 PyPI 和 TestPyPI 分别配置对应的 Trusted Publisher：
+
+- Owner：`xiaolinstar`
+- Repository：`drinkzen`
+- Workflow：`publish-admin-cli.yml`
+- Environment：TestPyPI 使用 `testpypi`，正式 PyPI 使用 `pypi`
+
+先通过 workflow 选择 `testpypi` 并填写当前包版本完成安装验证，再选择 `pypi` 发布正式版本。版本不可覆盖；每次发布前必须先提升 `packages/admin-cli/pyproject.toml` 中的版本号。

drinkzen_admin_cli-0.2.4.dist-info/RECORD

@@ -0,0 +1,13 @@
+drinkzen_admin/__init__.py,sha256=oHTfEs6W0YKWJF6Pox7o9CsRqk0zOk3FQrloBqYKSAs,57
+drinkzen_admin/cli.py,sha256=RFXmrAk6BOr31Q9pMXFTkxSxNFXgeD0av0tZTtP_LT0,20568
+drinkzen_admin/client.py,sha256=XRl3bQ0VSqBcy3XWh3NFncxo63iKhD-Oj3Sz4fIISgA,3458
+drinkzen_admin/config.py,sha256=cmTQ9Pjep-L-SPw06tyF1c15nBR0i9KOh04grmVBYC8,3896
+drinkzen_admin/formatting.py,sha256=B2iAN9kyhyP_Yw8_jFABzexDQkFIjgE6_SrahZnZaWY,1089
+drinkzen_admin/menu_options.py,sha256=RDYIugpxB8wu9TbEcIgODZOwSa1MjmRHVt_LH29pDIo,2994
+tests/test_config.py,sha256=3wIgqT-Zj3yEm6IDhnvvXu9HJvvLKTAk9BedsFNaEnU,3239
+tests/test_standalone_cli.py,sha256=kXdYy941pvFXTsRVConygqVe4IorMx3HUM-j5Mf-qb8,4259
+drinkzen_admin_cli-0.2.4.dist-info/METADATA,sha256=rDvt6kPj5wTAXMRJQKUnVtHcx_pR9SxjBwaL8xc1cns,6324
+drinkzen_admin_cli-0.2.4.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+drinkzen_admin_cli-0.2.4.dist-info/entry_points.txt,sha256=0EjRf2gLI4MKsXoTXgHzOjLlVftpq5vNnUL4q_MvjmA,59
+drinkzen_admin_cli-0.2.4.dist-info/top_level.txt,sha256=k_JFdt5MAKU_c2_yjnHXKsNB-6FSFi3CexPyrNMLYKg,21
+drinkzen_admin_cli-0.2.4.dist-info/RECORD,,

drinkzen_admin_cli-0.2.4.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

drinkzen_admin_cli-0.2.4.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+drinkzen-admin = drinkzen_admin.cli:main

drinkzen_admin_cli-0.2.4.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+drinkzen_admin
+tests

tests/test_config.py

@@ -0,0 +1,93 @@
+import io
+import json
+import stat
+import sys
+import tempfile
+import unittest
+from contextlib import redirect_stdout
+from pathlib import Path
+from unittest.mock import patch
+
+from drinkzen_admin.cli import main
+from drinkzen_admin.config import (
+    cmd_config_path,
+    cmd_config_set,
+    cmd_config_show,
+    get_config_path,
+    load_config,
+    mask_token,
+    save_config,
+)
+
+
+class TestAdminConfig(unittest.TestCase):
+    def setUp(self):
+        self.temp_dir = tempfile.TemporaryDirectory()
+        self.config_path = Path(self.temp_dir.name) / "admin.json"
+        self.env_patch = patch.dict("os.environ", {"DRINKZEN_ADMIN_CONFIG_PATH": str(self.config_path)})
+        self.env_patch.start()
+
+    def tearDown(self):
+        self.env_patch.stop()
+        self.temp_dir.cleanup()
+
+    def test_mask_token(self):
+        self.assertEqual(mask_token(""), "")
+        self.assertEqual(mask_token("1234"), "****")
+        self.assertEqual(mask_token("sample_token_value_1234"), "samp****1234")
+
+    def test_save_and_load_config(self):
+        saved = save_config(url="http://api.test:8000", token="dummy-token-xyz")
+        self.assertEqual(saved["url"], "http://api.test:8000")
+        self.assertEqual(saved["token"], "dummy-token-xyz")
+
+        loaded = load_config()
+        self.assertEqual(loaded["url"], "http://api.test:8000")
+        self.assertEqual(loaded["token"], "dummy-token-xyz")
+
+        # Check POSIX file permission
+        if sys.platform != "win32":
+            mode = stat.S_IMODE(self.config_path.stat().st_mode)
+            self.assertEqual(mode, 0o600)
+
+    def test_config_set_cli(self):
+        buf = io.StringIO()
+        with patch("sys.argv", ["drinkzen-admin", "config", "set", "--set-url", "https://api.drinkzen.cn", "--set-token", "dummy-auth-key", "--json"]):
+            with redirect_stdout(buf):
+                exit_code = main()
+
+        self.assertEqual(exit_code, 0)
+        output = json.loads(buf.getvalue())
+        self.assertEqual(output["url"], "https://api.drinkzen.cn")
+        self.assertEqual(output["token"], "dumm****-key")
+
+        loaded = load_config()
+        self.assertEqual(loaded["url"], "https://api.drinkzen.cn")
+        self.assertEqual(loaded["token"], "dummy-auth-key")
+
+    def test_config_show_cli(self):
+        save_config(url="https://api.drinkzen.cn", token="dummy-user-auth-1234")
+        buf = io.StringIO()
+        with patch("sys.argv", ["drinkzen-admin", "config", "show", "--json"]):
+            with redirect_stdout(buf):
+                exit_code = main()
+
+        self.assertEqual(exit_code, 0)
+        output = json.loads(buf.getvalue())
+        self.assertTrue(output["file_exists"])
+        self.assertEqual(output["active_url"], "https://api.drinkzen.cn")
+        self.assertEqual(output["active_token"], "dumm****1234")
+
+    def test_config_path_cli(self):
+        buf = io.StringIO()
+        with patch("sys.argv", ["drinkzen-admin", "config", "path", "--json"]):
+            with redirect_stdout(buf):
+                exit_code = main()
+
+        self.assertEqual(exit_code, 0)
+        output = json.loads(buf.getvalue())
+        self.assertEqual(output["path"], str(self.config_path.resolve()))
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_standalone_cli.py

@@ -0,0 +1,113 @@
+import io
+import json
+import tempfile
+import unittest
+from contextlib import redirect_stdout
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+from drinkzen_admin.cli import main
+from drinkzen_admin.client import AdminCLIClient
+from drinkzen_admin.formatting import format_cli_output
+from drinkzen_admin.menu_options import normalize_menu_option_config
+
+
+class TestStandaloneCLI(unittest.TestCase):
+    def test_format_cli_output(self):
+        data = [{"id": "b-1", "name": "霸王茶姬"}]
+        json_out = format_cli_output(data, is_json=True)
+        self.assertIn('"name": "霸王茶姬"', json_out)
+
+        txt_out = format_cli_output(data, is_json=False)
+        self.assertIn("霸王茶姬", txt_out)
+
+    def test_normalize_menu_option_config(self):
+        valid = {
+            "optionGroups": [
+                {
+                    "key": "sweetness",
+                    "label": "甜度",
+                    "values": ["标准糖", "少糖"],
+                    "selectionType": "single",
+                    "defaultValues": ["少糖"],
+                }
+            ]
+        }
+        res = normalize_menu_option_config(valid)
+        self.assertEqual(res["optionGroups"][0]["key"], "sweetness")
+
+        invalid = {"optionGroups": "invalid_array"}
+        with self.assertRaises(ValueError):
+            normalize_menu_option_config(invalid)
+
+    @patch("drinkzen_admin.cli.AdminCLIClient")
+    def test_brand_list_command(self, mock_client_cls):
+        mock_client = MagicMock()
+        mock_client.request.return_value = (200, [{"id": "b-1", "name": "霸王茶姬"}])
+        mock_client_cls.return_value = mock_client
+
+        buf = io.StringIO()
+        with patch("sys.argv", ["drinkzen-admin", "brand", "list", "--json"]):
+            with redirect_stdout(buf):
+                exit_code = main()
+
+        self.assertEqual(exit_code, 0)
+        output = json.loads(buf.getvalue())
+        self.assertEqual(len(output), 1)
+
+    @patch("drinkzen_admin.cli.AdminCLIClient")
+    def test_brand_update_dry_run(self, mock_client_cls):
+        mock_client = MagicMock()
+        mock_client.request.return_value = (200, {"id": "brand-chagee", "name": "霸王茶姬"})
+        mock_client_cls.return_value = mock_client
+
+        buf = io.StringIO()
+        with patch("sys.argv", ["drinkzen-admin", "brand", "update", "霸王茶姬", "--name", "新名称", "--dry-run", "--json"]):
+            with redirect_stdout(buf):
+                exit_code = main()
+
+        self.assertEqual(exit_code, 0)
+        output = json.loads(buf.getvalue())
+        self.assertTrue(output.get("dry_run"))
+        self.assertEqual(output["proposed"]["name"], "新名称")
+
+    def test_menu_template_validate_command(self):
+        valid_template = json.dumps({
+            "optionGroups": [
+                {
+                    "key": "ice",
+                    "label": "温度",
+                    "values": ["正常冰", "少冰"],
+                    "selectionType": "single",
+                }
+            ]
+        })
+        buf = io.StringIO()
+        with patch("sys.argv", ["drinkzen-admin", "menu-template", "validate", valid_template, "--json"]):
+            with redirect_stdout(buf):
+                exit_code = main()
+
+        self.assertEqual(exit_code, 0)
+        output = json.loads(buf.getvalue())
+        self.assertTrue(output["valid"])
+
+    @patch("drinkzen_admin.cli.AdminCLIClient")
+    def test_review_resolve_dry_run(self, mock_client_cls):
+        mock_client = MagicMock()
+        mock_client.request.return_value = (200, {"task_id": 10, "submission_id": "sub-1"})
+        mock_client_cls.return_value = mock_client
+
+        buf = io.StringIO()
+        with patch("sys.argv", ["drinkzen-admin", "review", "resolve", "10", "create", "--reason", "测试入库", "--dry-run", "--json"]):
+            with redirect_stdout(buf):
+                exit_code = main()
+
+        self.assertEqual(exit_code, 0)
+        output = json.loads(buf.getvalue())
+        self.assertTrue(output.get("dry_run"))
+        self.assertEqual(output["proposed_payload"]["action"], "approve_new")
+        self.assertEqual(output["proposed_payload"]["resolution_note"], "测试入库")
+
+
+if __name__ == "__main__":
+    unittest.main()