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

makea_cli/__init__.py

@@ -1 +1 @@
-__version__ = "0.2.25"
+__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 --------
 
 

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/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))

makea_cli/commands/orders/cmd.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+from typing import Any
+
 import typer
 from rich.console import Console
 
@@ -10,6 +12,62 @@ from makea_cli.commands._util import print_json_or_exit
 
 console = Console()
 
+# What an admin may set by hand, mirrored from the backend's SamplingOrderStatus /
+# ProductionOrderStatus. The statuses that record a payment (PAID, DEPOSIT_PAID,
+# FINAL_PAYMENT_PAID) are left out on purpose: money steps are recorded by the
+# payment, never by a command.
+SAMPLING_ORDER_STATUSES = (
+    "DRAFT",
+    "IN_PROGRESS",
+    "SAMPLING_COMPLETED",
+    "APPROVAL",
+    "SHIPPED",
+    "DELIVERED",
+    "CANCELLED",
+)
+PRODUCTION_ORDER_STATUSES = (
+    "DRAFT",
+    "IN_REVIEW",
+    "READY_FOR_PRODUCTION",
+    "PRODUCTION_IN_PROGRESS",
+    "PRODUCTION_COMPLETED",
+    "SHIPPED",
+    "DELIVERED",
+    "COMPLETED",
+    "CANCELLED",
+)
+PAID_STATUSES = ("PAID", "DEPOSIT_PAID", "FINAL_PAYMENT_PAID")
+
+
+def _order_status(value: str, allowed: tuple[str, ...]) -> str:
+    v = value.strip().upper()
+    if v in PAID_STATUSES:
+        raise typer.BadParameter(
+            f"{v} is recorded by the payment itself; the CLI does not mark orders paid"
+        )
+    if v not in allowed:
+        raise typer.BadParameter(f"--status must be one of {', '.join(allowed)}")
+    return v
+
+
+def _tracking_body(
+    tracking_number: str | None,
+    tracking_url: str | None,
+    shipping_method: str | None,
+    carrier_id: int | None,
+) -> dict[str, Any]:
+    """Only the fields given: the backend leaves an absent field unchanged."""
+    body: dict[str, Any] = {}
+    if tracking_number is not None:
+        body["tracking_number"] = tracking_number.strip()
+    if tracking_url is not None:
+        body["tracking_url"] = tracking_url.strip()
+    if shipping_method is not None:
+        body["shipping_method"] = shipping_method.strip()
+    if carrier_id is not None:
+        body["carrier_id"] = carrier_id
+    return body
+
 
 def register(app: typer.Typer) -> None:
     @command(
@@ -386,3 +444,197 @@ def register(app: typer.Typer) -> None:
                 },
             ),
         )
+
+    @command(
+        app,
+        "admin",
+        "get",
+        "production-order",
+        api="GET /admin/production_orders/{production_order_id}/details",
+        help=(
+            "GET /admin/production_orders/{id}/details — one production (or restock) order in "
+            "full: items, status, progress steps, tracking, notes, documents and linked "
+            "suppliers. For only its pricing use admin get production-pricing."
+        ),
+    )
+    def get_production_order(
+        production_order_id: str = typer.Argument(..., help="Production (or restock) order id."),
+    ) -> None:
+        """Show one production order."""
+        print_json_or_exit(
+            console,
+            lambda: api_client.get_production_order_details(production_order_id),
+        )
+
+    @command(
+        app,
+        "admin",
+        "update",
+        "sampling-order",
+        api="PUT /admin/sampling_orders/{sampling_order_id}/status",
+        side_effects=[
+            "records the status change in the order's history",
+            "the brand and the factory see the new status",
+            "SAMPLING_COMPLETED stamps completed_at, adds the completed progress step and "
+            "starts the sample analysis",
+        ],
+        approval="ask",
+        reversible=True,
+        idempotent=True,
+        help=(
+            "PUT /admin/sampling_orders/{id}/status — move a sampling order to another status "
+            f"({', '.join(SAMPLING_ORDER_STATUSES)}). PAID is recorded by the payment and "
+            "is refused here. Prefer admin update product-step, which moves the same "
+            "statuses through the step model."
+        ),
+    )
+    def update_sampling_order(
+        sampling_order_id: str = typer.Argument(..., help="Sampling order id."),
+        status: str = typer.Option(
+            ..., "--status", help=f"One of {', '.join(SAMPLING_ORDER_STATUSES)}."
+        ),
+    ) -> None:
+        """Change a sampling order's status."""
+        value = _order_status(status, SAMPLING_ORDER_STATUSES)
+        print_json_or_exit(
+            console,
+            lambda: api_client.admin_update_sampling_order_status(sampling_order_id, value),
+        )
+
+    @command(
+        app,
+        "admin",
+        "update",
+        "production-order",
+        api="PUT /admin/production_orders/{production_order_id}/status",
+        side_effects=[
+            "records the status change in the order's history",
+            "SHIPPED / DELIVERED / PRODUCTION_COMPLETED / COMPLETED notify the brand in-app",
+            "READY_FOR_PRODUCTION runs the ready transition (quote flow and product status)",
+        ],
+        approval="ask",
+        reversible=True,
+        idempotent=True,
+        help=(
+            "PUT /admin/production_orders/{id}/status — move a production order to another "
+            f"status ({', '.join(PRODUCTION_ORDER_STATUSES)}). The paid statuses (PAID, "
+            "DEPOSIT_PAID, FINAL_PAYMENT_PAID) are recorded by the payment and are refused "
+            "here."
+        ),
+    )
+    def update_production_order(
+        production_order_id: str = typer.Argument(..., help="Production (or restock) order id."),
+        status: str = typer.Option(
+            ..., "--status", help=f"One of {', '.join(PRODUCTION_ORDER_STATUSES)}."
+        ),
+    ) -> None:
+        """Change a production order's status."""
+        value = _order_status(status, PRODUCTION_ORDER_STATUSES)
+        print_json_or_exit(
+            console,
+            lambda: api_client.admin_update_production_order_status(production_order_id, value),
+        )
+
+    @command(
+        app,
+        "admin",
+        "set",
+        "sampling-order-tracking",
+        api="PUT /admin/sampling_orders/{sampling_order_id}/tracking",
+        side_effects=[
+            "a new tracking number marks the order SHIPPED and tells the brand it shipped",
+            "the parcel is followed by the carrier sweep",
+        ],
+        approval="ask",
+        reversible=True,
+        idempotent=True,
+        help=(
+            "PUT /admin/sampling_orders/{id}/tracking — the sample's parcel: tracking number, "
+            "URL, shipping method, carrier. Only what you pass is changed; an empty string "
+            "clears a field."
+        ),
+    )
+    def set_sampling_order_tracking(
+        sampling_order_id: str = typer.Argument(..., help="Sampling order id."),
+        tracking_number: str | None = typer.Option(None, "--tracking-number"),
+        tracking_url: str | None = typer.Option(None, "--tracking-url"),
+        shipping_method: str | None = typer.Option(
+            None, "--shipping-method", help="e.g. DHL Express, FedEx, Sea freight."
+        ),
+        carrier_id: int | None = typer.Option(
+            None, "--carrier-id", help="17track carrier code (number)."
+        ),
+    ) -> None:
+        """Set a sampling order's tracking information."""
+        body = _tracking_body(tracking_number, tracking_url, shipping_method, carrier_id)
+        if not any(body.get(k) for k in ("tracking_number", "tracking_url", "shipping_method")):
+            raise typer.BadParameter(
+                "pass at least one of --tracking-number, --tracking-url, --shipping-method"
+            )
+        print_json_or_exit(
+            console,
+            lambda: api_client.admin_set_sampling_order_tracking(sampling_order_id, body),
+        )
+
+    @command(
+        app,
+        "admin",
+        "set",
+        "production-order-tracking",
+        api="POST /admin/production_orders/{production_order_id}/tracking",
+        side_effects=[
+            "a new tracking number marks the order SHIPPED and tells the brand it shipped",
+            "the parcel is followed by the carrier sweep",
+        ],
+        approval="ask",
+        reversible=True,
+        idempotent=True,
+        help=(
+            "POST /admin/production_orders/{id}/tracking — the bulk parcel: tracking number, "
+            "URL, shipping method, carrier, plus cartons and gross weight off the packing "
+            "list. Only what you pass is changed; an empty string clears a field."
+        ),
+    )
+    def set_production_order_tracking(
+        production_order_id: str = typer.Argument(..., help="Production (or restock) order id."),
+        tracking_number: str | None = typer.Option(None, "--tracking-number"),
+        tracking_url: str | None = typer.Option(None, "--tracking-url"),
+        shipping_method: str | None = typer.Option(
+            None, "--shipping-method", help="e.g. DHL Express, FedEx, Sea freight."
+        ),
+        carrier_id: int | None = typer.Option(
+            None, "--carrier-id", help="17track carrier code (number)."
+        ),
+        cartons: str | None = typer.Option(
+            None,
+            "--cartons",
+            help="Number of cartons on the packing list (empty clears).",
+        ),
+        gross_weight_kg: str | None = typer.Option(
+            None, "--gross-weight-kg", help="Gross weight in kg (empty clears)."
+        ),
+    ) -> None:
+        """Set a production order's tracking information, cartons and gross weight."""
+        body = _tracking_body(tracking_number, tracking_url, shipping_method, carrier_id)
+        if cartons is not None:
+            body["cartons"] = cartons.strip()
+        if gross_weight_kg is not None:
+            body["gross_weight_kg"] = gross_weight_kg.strip()
+        if not any(
+            str(body.get(k) or "").strip()
+            for k in (
+                "tracking_number",
+                "tracking_url",
+                "shipping_method",
+                "cartons",
+                "gross_weight_kg",
+            )
+        ):
+            raise typer.BadParameter(
+                "pass at least one of --tracking-number, --tracking-url, --shipping-method, "
+                "--cartons, --gross-weight-kg"
+            )
+        print_json_or_exit(
+            console,
+            lambda: api_client.admin_set_production_order_tracking(production_order_id, body),
+        )