makea-cli 0.1.1__py3-none-any.whl

makea_cli/commands/orders/cmd.py

@@ -0,0 +1,202 @@
+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-product-orders",
+        help=(
+            "GET get_all_product_orders — designer product (SKU) list. "
+            "For 大货 use list-all-production-orders or list-production-orders-by-product."
+        ),
+    )
+    def list_product_orders(
+        limit: int | None = typer.Option(
+            None,
+            "--limit",
+            "-n",
+            help="Optional page size.",
+        ),
+        offset: int = typer.Option(0, "--offset", help="Pagination offset."),
+        user_id: str | None = typer.Option(
+            None,
+            "--user-id",
+            help="If set, only product orders for this designer user id.",
+        ),
+        searchby: str | None = typer.Option(
+            None,
+            "--searchby",
+            help="Optional search string (server-defined matching).",
+        ),
+    ) -> None:
+        """
+        List designer product orders (admin “product” / project rows).
+
+        This is NOT the same as production (bulk) orders: ``get_all_product_orders`` returns
+        product-order records. To see **大货 / production orders**, use
+        ``list-all-production-orders`` or ``list-production-orders-by-product <product_id>`` —
+        production POs are exposed on ``/admin/production_orders``, not only via this list.
+
+        Input: optional --limit, --offset, --user-id, --searchby on
+        GET /admin/designer/get_all_product_orders.
+
+        Output: JSON with success, result (serialized product rows), and pagination
+        (total, limit, offset, has_more).
+        """
+        print_json_or_exit(
+            console,
+            lambda: api_client.get_all_product_orders(
+                limit=limit,
+                offset=offset,
+                user_id=user_id,
+                searchby=searchby,
+            ),
+        )
+
+    @app.command(
+        "list-all-sampling-orders",
+        help="GET /admin/sampling_orders/get_all — paginated list of all sampling orders (admin).",
+    )
+    def list_all_sampling_orders(
+        limit: int | None = typer.Option(
+            None,
+            "--limit",
+            "-n",
+            help="Optional page size.",
+        ),
+        offset: int = typer.Option(0, "--offset", help="Pagination offset."),
+        no_document_metadata: bool = typer.Option(
+            False,
+            "--no-document-metadata",
+            help="Set include_document_metadata=false (default on API is true).",
+        ),
+    ) -> None:
+        """
+        List all sampling orders across products (admin).
+
+        Input: optional --limit, --offset, and --no-document-metadata (query
+        include_document_metadata, default true when omitted).
+
+        Output: JSON from GET /admin/sampling_orders/get_all (success, orders, pagination, etc.).
+        """
+        include_meta: bool | None = False if no_document_metadata else None
+        print_json_or_exit(
+            console,
+            lambda: api_client.get_all_sampling_orders(
+                limit=limit,
+                offset=offset,
+                include_document_metadata=include_meta,
+            ),
+        )
+
+    @app.command(
+        "list-all-production-orders",
+        help="GET /admin/production_orders — paginated list of production / restock orders (admin).",
+    )
+    def list_all_production_orders(
+        limit: int | None = typer.Option(
+            None,
+            "--limit",
+            "-n",
+            help="Optional page size.",
+        ),
+        offset: int = typer.Option(0, "--offset", help="Pagination offset."),
+        order_type: str | None = typer.Option(
+            None,
+            "--type",
+            help="Filter: PRODUCTION or RESTOCK (omit for all types the API returns).",
+        ),
+    ) -> None:
+        """
+        List all production (bulk) orders (admin).
+
+        Use this (or list-production-orders-by-product) for **大货** PO data — not
+        list-product-orders alone.
+
+        Input: optional --limit, --offset, --type (PRODUCTION | RESTOCK).
+
+        Output: JSON from GET /admin/production_orders.
+        """
+        if order_type is not None:
+            ot = order_type.strip().upper()
+            if ot not in ("PRODUCTION", "RESTOCK"):
+                console.print(
+                    "[red]--type must be PRODUCTION or RESTOCK (or omit).[/red]"
+                )
+                raise typer.Exit(1)
+            order_type = ot
+        print_json_or_exit(
+            console,
+            lambda: api_client.get_all_production_orders(
+                limit=limit,
+                offset=offset,
+                order_type=order_type,
+            ),
+        )
+
+    @app.command(
+        "list-sampling-orders-by-product",
+        help="GET /admin/products/{id}/sampling_orders — sampling orders for one product (admin).",
+    )
+    def list_sampling_orders_by_product(
+        product_reference_id: str = typer.Argument(
+            ...,
+            help="Product / product-order reference id (UUID path segment).",
+        ),
+    ) -> None:
+        """
+        List sampling orders for one product (admin).
+
+        Input: product_reference_id as URL path on
+        GET /admin/products/{product_reference_id}/sampling_orders.
+
+        Output: JSON { success, result } where result is a list of sampling order payloads.
+        """
+        print_json_or_exit(
+            console,
+            lambda: api_client.get_sampling_orders_by_product(product_reference_id),
+        )
+
+    @app.command(
+        "list-production-orders-by-product",
+        help=(
+            "GET /admin/products/{id}/production_orders — 大货 POs for one product; "
+            "see also list-all-production-orders."
+        ),
+    )
+    def list_production_orders_by_product(
+        product_reference_id: str = typer.Argument(
+            ...,
+            help="Product / product-order reference id (UUID path segment).",
+        ),
+        limit: int | None = typer.Option(
+            None,
+            "--limit",
+            "-n",
+            help="Optional page size.",
+        ),
+        offset: int = typer.Option(0, "--offset", help="Pagination offset."),
+    ) -> None:
+        """
+        List production orders for one product (admin).
+
+        Input: product_reference_id (path) and optional --limit / --offset query params on
+        GET /admin/products/{product_reference_id}/production_orders.
+
+        Output: JSON { success, production_orders, count, product_id }.
+        """
+        print_json_or_exit(
+            console,
+            lambda: api_client.get_production_orders_by_product(
+                product_reference_id,
+                limit=limit,
+                offset=offset,
+            ),
+        )

makea_cli/commands/product/__init__.py

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

makea_cli/commands/product/cmd.py

@@ -0,0 +1,160 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+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
+
+console = Console()
+
+
+def _technical_specifications_for_persist(specs: list[Any]) -> list[dict[str, Any]]:
+    """Strip extract-only fields; keep the shape expected by POST technical-specifications."""
+    out: list[dict[str, Any]] = []
+    for raw in specs:
+        if not isinstance(raw, dict):
+            continue
+        if "component" not in raw:
+            continue
+        out.append(
+            {
+                "component": raw["component"],
+                "specification": list(raw.get("specification") or []),
+                "notes_and_quality_expectations": list(
+                    raw.get("notes_and_quality_expectations") or []
+                ),
+                "need_proposal_from_supplier": bool(
+                    raw.get("need_proposal_from_supplier", False)
+                ),
+                "documents": list(raw.get("documents") or []),
+            }
+        )
+    return out
+
+
+def _load_technical_specifications_array(raw: Any) -> list[Any]:
+    """Accept root JSON as [...] or {\"technical_specifications\": [...]} or extract-shaped dict."""
+    if isinstance(raw, list):
+        return raw
+    if isinstance(raw, dict):
+        inner = raw.get("technical_specifications")
+        if isinstance(inner, list):
+            return inner
+    raise ValueError(
+        "JSON must be a list of specification objects, or an object with key "
+        "'technical_specifications' (e.g. output from extract-ai-tech-spec)."
+    )
+
+
+def register(app: typer.Typer) -> None:
+    @app.command(
+        "extract-ai-tech-spec",
+        help="GET /admin/products/{id}/extract-tech-specifications — AI-generate specs (not saved).",
+    )
+    def extract_ai_tech_spec(
+        product_reference_id: str = typer.Argument(
+            ...,
+            help="Product / product-order reference id (UUID in the URL path).",
+        ),
+        timeout: float = typer.Option(
+            300.0,
+            "--timeout",
+            "-t",
+            help="HTTP client timeout in seconds (AI extraction can be slow).",
+            min=30.0,
+            max=3600.0,
+        ),
+    ) -> None:
+        """
+        Run the admin AI pipeline to build Technical Specifications for one product.
+
+        This calls GET /admin/products/{product_reference_id}/extract-tech-specifications only.
+        Results are not written to the product; use save-product-tech-spec to persist.
+
+        Input: product_reference_id (path). Optional --timeout (default 300s).
+
+        Output: JSON with success, product_reference_id, technical_specifications, count,
+        optional review_notes; or success=false with error.
+        """
+        print_json_or_exit(
+            console,
+            lambda: api_client.extract_ai_tech_specifications(
+                product_reference_id,
+                timeout=timeout,
+            ),
+        )
+
+    @app.command(
+        "save-product-tech-spec",
+        help="POST /admin/products/{id}/technical-specifications — persist specs from a JSON file.",
+    )
+    def save_product_tech_spec(
+        product_reference_id: str = typer.Argument(
+            ...,
+            help="Product / product-order reference id (UUID in the URL path).",
+        ),
+        file: Path = typer.Option(
+            ...,
+            "--file",
+            "-f",
+            exists=True,
+            dir_okay=False,
+            readable=True,
+            help=(
+                "UTF-8 JSON: a list of spec objects, or an object with "
+                "'technical_specifications' (e.g. saved extract-ai-tech-spec output)."
+            ),
+        ),
+        timeout: float = typer.Option(
+            120.0,
+            "--timeout",
+            "-t",
+            help="HTTP client timeout in seconds for the multipart POST.",
+            min=30.0,
+            max=600.0,
+        ),
+    ) -> None:
+        """
+        Save technical specifications onto the product (admin).
+
+        Calls POST /admin/products/{product_reference_id}/technical-specifications with
+        multipart form field ``technical_specifications`` set to a JSON array string, matching
+        the admin API contract.
+
+        Input: product_reference_id and --file. The file may be:
+        - a JSON array of component rows (same shape as ``technical_specifications`` in extract output);
+        - or a JSON object that includes ``technical_specifications`` (e.g. full response from
+          extract-ai-tech-spec redirected to a file).
+
+        Output: JSON from the API (success, technical_specifications, updated_by, message, etc.).
+        """
+        try:
+            raw = json.loads(file.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError) as e:
+            console.print(f"[red]Invalid JSON file: {e}[/red]")
+            raise typer.Exit(1) from e
+        try:
+            arr = _load_technical_specifications_array(raw)
+        except ValueError as e:
+            console.print(f"[red]{e}[/red]")
+            raise typer.Exit(1) from e
+        specs = _technical_specifications_for_persist(arr)
+        if not specs:
+            console.print(
+                "[red]No valid specification rows after parsing (need 'component' on each).[/red]"
+            )
+            raise typer.Exit(1)
+
+        print_json_or_exit(
+            console,
+            lambda: api_client.update_product_technical_specifications(
+                product_reference_id,
+                specs,
+                timeout=timeout,
+            ),
+        )

makea_cli/commands/supplier/__init__.py

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

makea_cli/commands/supplier/cmd.py

@@ -0,0 +1,305 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+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 _normalize_add_supplier_body(raw: dict) -> dict:
+    """API expects {"supplier": {...}}; allow file root to be the inner supplier object only."""
+    inner = raw.get("supplier")
+    if isinstance(inner, dict):
+        return raw
+    return {"supplier": raw}
+
+
+def register(app: typer.Typer) -> None:
+    @app.command(
+        "list-suppliers",
+        help="GET /admin/supplier/get_all_suppliers — list all suppliers (admin).",
+    )
+    def list_suppliers() -> None:
+        """
+        List all suppliers (admin).
+
+        Input: none (GET /admin/supplier/get_all_suppliers).
+
+        Output: JSON body (typically success, result).
+        """
+        print_json_or_exit(console, api_client.get_all_suppliers)
+
+    @app.command(
+        "add-supplier",
+        help="POST /admin/supplier/add_supplier — create supplier from JSON file (admin).",
+    )
+    def add_supplier(
+        file: Path = typer.Option(
+            ...,
+            "--file",
+            "-f",
+            exists=True,
+            dir_okay=False,
+            readable=True,
+            help='Path to UTF-8 JSON: either the supplier object alone or {"supplier": {...}}.',
+        ),
+    ) -> None:
+        """
+        Create a supplier (admin).
+
+        HTTP: POST /admin/supplier/add_supplier with JSON body {\"supplier\": <object>}.
+
+        Input file
+        - Root may be the supplier fields object only (recommended), or the full envelope
+          {\"supplier\": {...}}.
+        - The server parses this with Supplier.to_domain; omitted supplier_id is assigned a
+          new UUID; created_at / updated_at are set server-side when missing.
+
+        Supplier object — fields the backend understands (all optional unless you need them
+        in the UI; empty strings are accepted for several core fields):
+
+        - Identity / classification: supplier_id (omit to auto-generate), name or
+          supplier_name, type or supplier_type, location or supplier_location,
+          manufacturer_type (string or list), sub_categories, status, website,
+          supplier_user_id (Cognito user id if the supplier logs in).
+        - Profile: specialization or specialisation, description, internal_notes,
+          rating_internal, number_of_employees or factory_size, year_established or
+          established_in, machinery_equipment, monthly_capacity, leadtime_guidance,
+          sample_leadtime_guidance, MOQ_guidance, MOQ_guidance_type, moq_by_category,
+          trade_terms, sourcing_support, tech_pack_support, impexp_license,
+          impexp_license_experience, customs_experience, stock_availabilities,
+          number_of_in_stock_product, product_update_methods, payment_terms_guidance
+          (string or list), currency (string or list), primary_markets, clients,
+          end_consumer_focus, material_system, qc_options, has_inhouse_product_development_team,
+          product_development_structure, has_sourcing_support, business_registration_number,
+          parent_company, extra_info, onboard_source.
+        - Primary contact: contact_name, contact_email, contact_phone, contact_title,
+          contact_whatsapp_wechat_id.
+        - point_of_contact: list of {name, email, phone, title?, whatsapp_wechat_id?}.
+        - certificates: list of {name, id_number, file_url?}.
+        - Documents (each item a Document-shaped dict): catalogue, images, videos,
+          business_license, tax_registration_certificate, insurance_certificate.
+        - banking_details (optional object): bank_region (CHINA|EUROPE|INDIA|USA|OTHER),
+          beneficiary_name, beneficiary_address, bank_name, bank_address, swift_code;
+          iban (EU), account_number (USA/China/India/Other), routing_number (USA),
+          ifsc_code (India), phone_number (China), banking_info_files (document list).
+
+        Output: JSON {success, result} with HTTP 201 on success; result is the stored supplier
+        as a flat dict (dataclass asdict), including the assigned supplier_id.
+        """
+        try:
+            raw = json.loads(file.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError) as e:
+            console.print(f"[red]Invalid JSON file: {e}[/red]")
+            raise typer.Exit(1) from e
+        if not isinstance(raw, dict):
+            console.print("[red]JSON root must be an object.[/red]")
+            raise typer.Exit(1)
+        body = _normalize_add_supplier_body(raw)
+        print_json_or_exit(console, lambda: api_client.add_supplier(body))
+
+    @app.command(
+        "backfill-supplier-id",
+        help=(
+            "Migrate supplier_id from a wrong UUID to the Cognito user sub (user_id): "
+            "profile + Cognito supplierReferenceId, optional S3/DOCUMENT#, patch product "
+            "supplier_links, link→quote-request backfill (archived migration QRs), "
+            "sampling/production order supplier fields, optional delete old SUPPLIER# "
+            "partition. Default is dry-run; use --apply to write. "
+            "HTTP: POST /admin/supplier/backfill_supplier_id_with_quote_requests."
+        ),
+    )
+    def backfill_supplier_id(
+        user_id: str = typer.Option(
+            ...,
+            "--user-id",
+            help=(
+                "Cognito sub of the supplier user — this becomes the canonical supplier_id "
+                "after migration."
+            ),
+        ),
+        old_supplier_id: str = typer.Option(
+            ...,
+            "--old-supplier-id",
+            help=(
+                "Current wrong supplier_id stored on SUPPLIER#.../METADATA and links "
+                "(the UUID to migrate away from)."
+            ),
+        ),
+        dry_run: bool = typer.Option(
+            True,
+            "--dry-run/--apply",
+            help=(
+                "Default: --dry-run (server previews only). "
+                "--apply sends dry_run=false and performs Dynamo/Cognito/S3 writes per flags."
+            ),
+        ),
+        skip_s3_documents: bool = typer.Option(
+            False,
+            "--skip-s3-documents",
+            help=(
+                "Skip server step 2b: copy suppliers/{old}/documents/* in S3, rewrite "
+                "METADATA s3_key paths, migrate DOCUMENT# rows to SUPPLIER#{user_id}."
+            ),
+        ),
+        skip_quote_request_backfill: bool = typer.Option(
+            False,
+            "--skip-quote-request-backfill",
+            help=(
+                "Skip per-product link→quote_request backfill AND step 5b (no automatic "
+                "archiving of QRs still keyed by old_supplier_id from this run)."
+            ),
+        ),
+        quote_request_only: bool = typer.Option(
+            False,
+            "--quote-request-only",
+            help=(
+                "Server skips profile creation, Cognito, link supplier_id patch, and "
+                "order patches; only scans products and runs link→QR backfill (+ 5b). "
+                "Use when profile/links are already fixed."
+            ),
+        ),
+        delete_old_supplier_at_end: bool = typer.Option(
+            False,
+            "--delete-old-supplier-at-end",
+            help=(
+                "After a successful full run, delete all items with PK=SUPPLIER#{old_id}. "
+                "Server refuses if old METADATA is not marked migrated or if QRs still "
+                "use old_supplier_id. Non-dry-run requires --confirm-delete-old-supplier."
+            ),
+        ),
+        confirm_delete_old_supplier: bool = typer.Option(
+            False,
+            "--confirm-delete-old-supplier",
+            help=(
+                "Acknowledge destructive delete of the old supplier partition. Required "
+                "with --delete-old-supplier-at-end when using --apply (server enforces too)."
+            ),
+        ),
+    ) -> None:
+        """
+        Consolidated supplier **user_id ↔ supplier_id** migration (admin).
+
+        **When to use**
+
+        Production expects ``supplier_id`` to equal the supplier's Cognito ``sub``
+        (``user_id``). If the DynamoDB profile was created under a random UUID
+        (``old_supplier_id``), this command runs the full migration on the server.
+
+        **What runs on the server** (same as ``manage.py backfill_supplier_id``)
+
+        - Write new profile under ``SUPPLIER#{user_id}``, mark old as migrated.
+        - Set Cognito ``custom:supplierReferenceId`` → ``user_id``.
+        - Unless ``--skip-s3-documents``: S3 document copy + ``DOCUMENT#`` row migration.
+        - Patch ``supplier_links[].supplier_id`` from old → ``user_id``.
+        - Link→quote-request backfill (unless skipped); migration QRs are archived.
+        - Patch sampling/production orders referencing the old id.
+        - Optionally delete the old ``SUPPLIER#{old_supplier_id}`` partition at end.
+
+        **Not available through this API** (use garmentby-service venv + ``manage.py``):
+
+        - ``--s3-documents-only``
+        - ``--delete-old-supplier-only``
+
+        **Output**
+
+        JSON includes ``output`` (server command stdout) and ``errors`` (stderr). Read
+        them after dry-run before ``--apply``.
+
+        **After migration**
+
+        If quote request **stage/status** still look wrong, repair with
+        ``manage.py reconcile_quote_request_stage_status`` on **garmentby-service**
+        for the **new** supplier id (usually ``user_id``).
+
+        **Skill**
+
+        Operator runbook: ``.claude/skills/supplier-user-id-migration/SKILL.md`` in this repo.
+        """
+        if (
+            delete_old_supplier_at_end
+            and not confirm_delete_old_supplier
+            and not dry_run
+        ):
+            console.print(
+                "[red]--confirm-delete-old-supplier is required with "
+                "--delete-old-supplier-at-end when using --apply.[/red]"
+            )
+            raise typer.Exit(1)
+
+        print_json_or_exit(
+            console,
+            lambda: api_client.backfill_supplier_id_with_quote_requests(
+                user_id=user_id,
+                old_supplier_id=old_supplier_id,
+                dry_run=dry_run,
+                skip_s3_documents=skip_s3_documents,
+                skip_quote_request_backfill=skip_quote_request_backfill,
+                quote_request_only=quote_request_only,
+                delete_old_supplier_at_end=delete_old_supplier_at_end,
+                confirm_delete_old_supplier=confirm_delete_old_supplier,
+            ),
+        )
+
+    @app.command(
+        "get-quote-requests-by-supplier-id",
+        help=(
+            "GET /admin/quote_requests/supplier/{supplier_id} — direct backend query."
+        ),
+    )
+    def get_quote_requests_by_supplier_id(
+        supplier_id: str = typer.Argument(..., help="Supplier id to filter by."),
+        status: str | None = typer.Option(
+            None,
+            "--status",
+            help="Optional quote request status filter.",
+        ),
+        limit: int | None = typer.Option(
+            None,
+            "--limit",
+            "-n",
+            help="Optional max quote requests to return (backend-enforced).",
+        ),
+    ) -> None:
+        """
+        Direct backend lookup by supplier id.
+        """
+        print_json_or_exit(
+            console,
+            lambda: api_client.get_quote_requests_by_supplier_id(
+                supplier_id=supplier_id,
+                status=status,
+                limit=limit,
+            ),
+        )
+
+    @app.command(
+        "get-supplier-links-by-supplier-id",
+        help=(
+            "GET /admin/product/linked_suppliers/by_supplier/{supplier_id} — direct backend query."
+        ),
+    )
+    def get_supplier_links_by_supplier_id(
+        supplier_id: str = typer.Argument(..., help="Supplier id to filter by."),
+        link_type: str | None = typer.Option(
+            None,
+            "--link-type",
+            help="Optional filter: SAMPLING or PRODUCTION.",
+        ),
+    ) -> None:
+        """
+        Direct backend lookup by supplier id.
+        """
+        print_json_or_exit(
+            console,
+            lambda: api_client.get_supplier_links_by_supplier_id(
+                supplier_id=supplier_id,
+                link_type=link_type,
+            ),
+        )