makea-cli 0.2.24__py3-none-any.whl → 0.2.26__py3-none-any.whl

makea_cli/__init__.py

@@ -1 +1 @@
-__version__ = "0.2.24"
+__version__ = "0.2.26"

makea_cli/api_client.py

@@ -1282,6 +1282,131 @@ def admin_playbook_preview(
     return get_json("/admin/playbook/preview", params=params)
 
 
+# --- admin: what the admin page does by hand (orders, products, people, flags) -----
+# None of these move money: order statuses that record a payment are refused by
+# the commands, and change_step refuses money steps server-side.
+
+
+def admin_get_supplier(supplier_id: str) -> Any:
+    """GET /admin/supplier/get_supplier_by_id?supplier_id= — profile plus financial documents."""
+    return get_json("/admin/supplier/get_supplier_by_id", params={"supplier_id": supplier_id})
+
+
+def admin_get_user_profile(user_id: str) -> Any:
+    """GET /admin/user-profiles/{user_id}"""
+    return get_json(f"/admin/user-profiles/{quote(user_id, safe='')}")
+
+
+def admin_update_sampling_order_status(sampling_order_id: str, status: str) -> Any:
+    """PUT /admin/sampling_orders/{id}/status"""
+    return put_json(f"/admin/sampling_orders/{sampling_order_id}/status", {"status": status})
+
+
+def admin_update_production_order_status(production_order_id: str, status: str) -> Any:
+    """PUT /admin/production_orders/{id}/status"""
+    return put_json(f"/admin/production_orders/{production_order_id}/status", {"status": status})
+
+
+def admin_set_sampling_order_tracking(sampling_order_id: str, body: dict[str, Any]) -> Any:
+    """PUT /admin/sampling_orders/{id}/tracking — tracking_number / tracking_url /
+    shipping_method / carrier_id, flat in the body."""
+    return put_json(f"/admin/sampling_orders/{sampling_order_id}/tracking", body)
+
+
+def admin_set_production_order_tracking(production_order_id: str, body: dict[str, Any]) -> Any:
+    """POST /admin/production_orders/{id}/tracking — as sampling, plus cartons and
+    gross_weight_kg (absent = unchanged, empty string = cleared)."""
+    return post_json(f"/admin/production_orders/{production_order_id}/tracking", body)
+
+
+def admin_get_product_status(product_id: str) -> Any:
+    """GET /admin/products/{id}/status — the product's stage · step · owner per supplier,
+    with the step catalog."""
+    return get_json(f"/admin/products/{product_id}/status")
+
+
+def admin_get_change_step(product_id: str, supplier_id: str) -> Any:
+    """GET /admin/products/{id}/suppliers/{sid}/change_step — where the factory is
+    and which steps can be picked."""
+    return get_json(f"/admin/products/{product_id}/suppliers/{supplier_id}/change_step")
+
+
+def admin_change_step(product_id: str, supplier_id: str, body: dict[str, Any]) -> Any:
+    """POST /admin/products/{id}/suppliers/{sid}/change_step —
+    {stage, step, note?, notify_brand?, notify_supplier?}."""
+    return post_json(f"/admin/products/{product_id}/suppliers/{supplier_id}/change_step", body)
+
+
+def admin_list_product_notes(product_id: str) -> Any:
+    """GET /admin/products/{id}/notes — the product's customer notes."""
+    return get_json(f"/admin/products/{product_id}/notes")
+
+
+def admin_add_product_note(product_id: str, content: str, *, internal: bool) -> Any:
+    """POST /admin/products/{id}/notes — {content, is_internal}. The backend reads
+    ``is_internal``; a customer note (the default) is emailed to the brand."""
+    return post_json(
+        f"/admin/products/{product_id}/notes",
+        {"content": content, "is_internal": internal},
+    )
+
+
+def admin_update_product_basic_info(product_id: str, body: dict[str, Any]) -> Any:
+    """PUT /admin/products/{id}/basic-info — only the fields given are changed."""
+    return put_json(f"/admin/products/{product_id}/basic-info", body)
+
+
+def admin_update_product_document_status(product_id: str, document_id: str, status: str) -> Any:
+    """POST /admin/designer/update_document_status — {product_id, document_id, status}."""
+    return post_json(
+        "/admin/designer/update_document_status",
+        {"product_id": product_id, "document_id": document_id, "status": status},
+    )
+
+
+def admin_link_supplier(body: dict[str, Any]) -> Any:
+    """POST /admin/product/link_supplier — a bare assignment (no price, so not a quote)."""
+    return post_json("/admin/product/link_supplier", body)
+
+
+def admin_unlink_supplier(
+    product_id: str, *, link_id: str | None = None, supplier_id: str | None = None
+) -> Any:
+    """POST /admin/product/unlink_supplier?product_id=&link_id=|supplier_id= (query, no body)."""
+    params: dict[str, Any] = {"product_id": product_id}
+    if link_id:
+        params["link_id"] = link_id
+    if supplier_id:
+        params["supplier_id"] = supplier_id
+    return _request("POST", "/admin/product/unlink_supplier", params=params)
+
+
+def admin_reply_quote_request(quote_request_id: str, body: dict[str, Any]) -> Any:
+    """POST /admin/quote_requests/{id}/reply_status_note — {status_note, notification_kind}."""
+    return post_json(f"/admin/quote_requests/{quote_request_id}/reply_status_note", body)
+
+
+def admin_list_feature_flags() -> Any:
+    """GET /admin/feature-flags — every flag with its allow-list resolved."""
+    return get_json("/admin/feature-flags")
+
+
+def admin_create_feature_flag(body: dict[str, Any]) -> Any:
+    """POST /admin/feature-flags — {key, description?, enabled?, value?}."""
+    return post_json("/admin/feature-flags", body)
+
+
+def admin_update_feature_flag(key: str, body: dict[str, Any]) -> Any:
+    """PATCH /admin/feature-flags/{key} — enabled / description / value /
+    add_user_id / remove_user_id, one account at a time."""
+    return patch_json(f"/admin/feature-flags/{quote(key, safe='')}", body)
+
+
+def admin_delete_feature_flag(key: str) -> Any:
+    """DELETE /admin/feature-flags/{key} — every check of the flag then reads false."""
+    return delete_json(f"/admin/feature-flags/{quote(key, safe='')}")
+
+
 # --- supplier persona: a factory acting on its own RFQs, quotes and orders --------
 
 
@@ -1734,6 +1859,13 @@ def designer_approve_proposal(note_id: str, proposal_id: str) -> Any:
     )
 
 
+def designer_create_proposals(product_id: str, proposals: list[dict[str, Any]]) -> Any:
+    """POST /designer/products/{id}/tech_spec/proposals — change cards on the tech pack."""
+    return post_json(
+        f"/designer/products/{product_id}/tech_spec/proposals", {"proposals": proposals}
+    )
+
+
 def designer_bulk_accept_actions(channel_id: str, actions: list[dict[str, str]]) -> Any:
     """POST /designer/channels/{id}/suggested_actions/bulk_accept — accept several at once."""
     return post_json(

makea_cli/commands/__init__.py

@@ -11,6 +11,7 @@ from makea_cli.commands.directory.cmd import register as register_directory
 from makea_cli.commands.document.cmd import register as register_document
 from makea_cli.commands.email.cmd import register as register_email
 from makea_cli.commands.factory.cmd import register as register_factory
+from makea_cli.commands.flags.cmd import register as register_flags
 from makea_cli.commands.library.cmd import register as register_library
 from makea_cli.commands.metrics.cmd import register as register_metrics
 from makea_cli.commands.orders.cmd import register as register_orders
@@ -41,3 +42,4 @@ def register_all(app: typer.Typer) -> None:
     register_playbook(app)
     register_about(app)
     register_tasks(app)
+    register_flags(app)

makea_cli/commands/brand/cmd.py

@@ -666,6 +666,90 @@ def register(app: typer.Typer) -> None:
         """Approve one assistant proposal."""
         print_json_or_exit(console, lambda: api_client.designer_approve_proposal(note, proposal_id))
 
+    @command(
+        app,
+        "designer",
+        "create",
+        "proposal",
+        api="POST /designer/products/{product_id}/tech_spec/proposals",
+        side_effects=[
+            "puts a change card on the tech pack; the pack changes only when the user applies it"
+        ],
+        approval="auto",
+        help=(
+            "POST /designer/products/{id}/tech_spec/proposals — propose a tech-pack change as a "
+            "card on the field it changes. Name the section and field as `get tech-pack "
+            "--readable` shows them; pick a row with --item (a value it holds) or --entry, a line "
+            "with --was. A refusal lists the sections, fields, rows or lines that exist. "
+            "--file takes a JSON list of the same keys for several changes at once."
+        ),
+    )
+    def create_proposal(
+        product: str = typer.Option(..., "--product", "-p", help="Product id."),
+        section: str | None = typer.Option(
+            None, "--section", help='Section, by label or key (e.g. "Trims & hardware").'
+        ),
+        field: str | None = typer.Option(
+            None, "--field", help="Field, by label or key (field-based packs)."
+        ),
+        value: str | None = typer.Option(None, "--value", help="The new value or line."),
+        reason: str | None = typer.Option(
+            None, "--reason", help="One line the user reads on the card."
+        ),
+        action: str = typer.Option(
+            "update", "--action", help="update (default), add (a new row or line) or delete."
+        ),
+        entry: int | None = typer.Option(
+            None, "--entry", help="Row number in a repeating section, 0 = first."
+        ),
+        item: str | None = typer.Option(
+            None, "--item", help='Pick the row that holds this value now (e.g. "cord lock").'
+        ),
+        was: str | None = typer.Option(
+            None, "--was", help="Current text of the line to change (line-based packs)."
+        ),
+        kind: str | None = typer.Option(
+            None, "--kind", help="For a new line: spec (default) or note."
+        ),
+        replaces: list[str] = typer.Option(
+            [], "--replaces", help="line_id a new line replaces (repeat)."
+        ),
+        document: list[str] = typer.Option(
+            [], "--document", help="document_id the change comes from (repeat)."
+        ),
+        file: Path | None = typer.Option(
+            None,
+            "--file",
+            "-f",
+            exists=True,
+            dir_okay=False,
+            help="JSON list of proposals with the keys above, instead of the flags.",
+        ),
+    ) -> None:
+        """Propose tech-pack changes."""
+        if file is not None:
+            items = json.loads(file.read_text(encoding="utf-8"))
+            if not isinstance(items, list):
+                raise typer.BadParameter("--file must hold a JSON list of proposals")
+        else:
+            if not section or not reason:
+                raise typer.BadParameter("--section and --reason are required (or --file)")
+            one: dict[str, Any] = {
+                "section": section,
+                "field": field,
+                "value": value,
+                "reason": reason,
+                "action": action,
+                "entry": entry,
+                "item": item,
+                "was": was,
+                "kind": kind,
+                "replaces": replaces or None,
+                "documents": document or None,
+            }
+            items = [{k: v for k, v in one.items() if v is not None}]
+        print_json_or_exit(console, lambda: api_client.designer_create_proposals(product, items))
+
     @command(
         app,
         "designer",

makea_cli/commands/directory/cmd.py

@@ -54,6 +54,20 @@ def register(app: typer.Typer) -> None:
         """
         print_json_or_exit(console, lambda: api_client.get_all_users(limit=limit, offset=offset))
 
+    @command(
+        app,
+        "admin",
+        "get",
+        "user",
+        api="GET /admin/user-profiles/{user_id}",
+        help="GET /admin/user-profiles/{user_id} — one account's profile (Cognito sub as id).",
+    )
+    def get_user(
+        user_id: str = typer.Argument(..., help="Cognito sub (user_id) of the account."),
+    ) -> None:
+        """Show one user's profile."""
+        print_json_or_exit(console, lambda: api_client.admin_get_user_profile(user_id))
+
     @command(
         app,
         "admin",

makea_cli/commands/flags/cmd.py

@@ -0,0 +1,157 @@
+"""Admin feature flags: the switches on the admin page's Flags tab.
+
+A flag is on globally, or, while the global switch is off, on for the accounts
+on its allow-list. The allow-list holds user ids (Cognito sub), never emails.
+Every change reaches prod users at once, so every write asks first.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Any
+
+import typer
+from rich.console import Console
+
+from makea_cli import api_client
+from makea_cli.commands._util import print_json_or_exit
+from makea_cli.registry import command
+
+console = Console()
+
+# Mirrors garmentby_service.common.feature_flags (FLAG_KEY_PATTERN, MAX_FLAG_KEY_CHARS).
+_FLAG_KEY = re.compile(r"^[A-Z][A-Z0-9_]*$")
+_FLAG_KEY_MAX = 64
+
+
+def _flag_key(raw: str) -> str:
+    key = raw.strip().upper()
+    if not _FLAG_KEY.match(key) or len(key) > _FLAG_KEY_MAX:
+        raise typer.BadParameter(
+            f"flag key must be ALL_CAPS with underscores, at most {_FLAG_KEY_MAX} characters"
+        )
+    return key
+
+
+def register(app: typer.Typer) -> None:
+    @command(
+        app,
+        "admin",
+        "list",
+        "feature-flag",
+        api="GET /admin/feature-flags",
+        help=(
+            "GET /admin/feature-flags — every flag: global switch, default value, and the "
+            "accounts it is on for (id, email, name)."
+        ),
+    )
+    def list_feature_flags() -> None:
+        """List feature flags."""
+        print_json_or_exit(console, api_client.admin_list_feature_flags)
+
+    @command(
+        app,
+        "admin",
+        "create",
+        "feature-flag",
+        api="POST /admin/feature-flags",
+        side_effects=["with --enabled the flag is on for every account at once"],
+        approval="ask",
+        reversible=True,
+        idempotent=False,
+        help=(
+            "POST /admin/feature-flags — add a flag (off unless --enabled). An existing key "
+            "is refused."
+        ),
+    )
+    def create_feature_flag(
+        key: str = typer.Argument(..., help="Flag key, ALL_CAPS_WITH_UNDERSCORES."),
+        description: str | None = typer.Option(None, "--description", help="What it gates."),
+        enabled: bool = typer.Option(False, "--enabled", help="Turn it on globally now."),
+        value: str | None = typer.Option(
+            None,
+            "--value",
+            help="Default value, for flags that name a choice (e.g. DEEPSEEK).",
+        ),
+    ) -> None:
+        """Create a feature flag."""
+        body: dict[str, Any] = {"key": _flag_key(key), "enabled": enabled}
+        if description is not None:
+            body["description"] = description.strip()
+        if value is not None:
+            body["value"] = value.strip()
+        print_json_or_exit(console, lambda: api_client.admin_create_feature_flag(body))
+
+    @command(
+        app,
+        "admin",
+        "update",
+        "feature-flag",
+        api="PATCH /admin/feature-flags/{key}",
+        side_effects=["the change reaches the affected accounts at once"],
+        approval="ask",
+        reversible=True,
+        idempotent=True,
+        help=(
+            "PATCH /admin/feature-flags/{key} — flip the global switch, edit the description "
+            "or default value, or add / remove one account on the allow-list (by user id; "
+            "find it with admin list user)."
+        ),
+    )
+    def update_feature_flag(
+        key: str = typer.Argument(..., help="Flag key."),
+        enabled: bool | None = typer.Option(
+            None, "--enabled/--disabled", help="The global switch."
+        ),
+        description: str | None = typer.Option(None, "--description"),
+        value: str | None = typer.Option(
+            None, "--value", help="Default value; an empty string clears it."
+        ),
+        add_user: str | None = typer.Option(
+            None, "--add-user", help="User id (Cognito sub) to put on the allow-list."
+        ),
+        remove_user: str | None = typer.Option(
+            None, "--remove-user", help="User id to take off the allow-list."
+        ),
+    ) -> None:
+        """Change a feature flag."""
+        body: dict[str, Any] = {}
+        if enabled is not None:
+            body["enabled"] = enabled
+        if description is not None:
+            body["description"] = description.strip()
+        if value is not None:
+            body["value"] = value.strip()
+        if add_user and add_user.strip():
+            body["add_user_id"] = add_user.strip()
+        if remove_user and remove_user.strip():
+            body["remove_user_id"] = remove_user.strip()
+        if not body:
+            raise typer.BadParameter(
+                "pass at least one of --enabled/--disabled, --description, --value, "
+                "--add-user, --remove-user"
+            )
+        flag = _flag_key(key)
+        print_json_or_exit(console, lambda: api_client.admin_update_feature_flag(flag, body))
+
+    @command(
+        app,
+        "admin",
+        "delete",
+        "feature-flag",
+        api="DELETE /admin/feature-flags/{key}",
+        side_effects=["every check of the flag reads false from then on"],
+        approval="ask",
+        reversible=False,
+        idempotent=True,
+        help=(
+            "DELETE /admin/feature-flags/{key} — remove a flag. Every check of it then reads "
+            "false, so delete it only once the code that reads it is gone."
+        ),
+    )
+    def delete_feature_flag(
+        key: str = typer.Argument(..., help="Flag key."),
+    ) -> None:
+        """Delete a feature flag."""
+        flag = _flag_key(key)
+        print_json_or_exit(console, lambda: api_client.admin_delete_feature_flag(flag))