@miraiva_test/miravia-order-report 0.1.13

package/dist/scripts/test_v4_render.py

@@ -0,0 +1,322 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Test script for v4 unified dashboard rendering.
+
+Generates mock order data and calls report_v4.render() to produce HTML files.
+Tests three scenarios: business (rich data), refund (high refund rate), and empty data.
+"""
+from __future__ import annotations
+
+import random
+import sys
+from datetime import datetime, timedelta
+from pathlib import Path
+
+# Ensure scripts dir is on path
+THIS_DIR = Path(__file__).resolve().parent
+sys.path.insert(0, str(THIS_DIR))
+
+# Import from export_orders
+from export_orders import EXPORT_COLUMNS, _jinja_env
+import report_v4
+from i18n import SUPPORTED_LANGS
+
+random.seed(42)
+
+# ---------- mock data generators ----------
+
+PRODUCTS = [
+    ("SKU-LED-001", "LED Smart Lamp Aurora", 29.99, "Home & Living"),
+    ("SKU-LED-002", "LED Strip Light 5m RGB", 15.99, "Home & Living"),
+    ("SKU-AUR-001", "Auriculares Bluetooth Pro", 49.99, "Electronics"),
+    ("SKU-AUR-002", "Altavoz Bluetooth Portable", 34.50, "Electronics"),
+    ("SKU-CAR-001", "Cargador USB-C 65W", 24.99, "Electronics"),
+    ("SKU-SAR-001", "Sartén Antiadherente 28cm", 22.00, "Kitchen"),
+    ("SKU-COC-001", "Cafetera Espresso Automática", 89.99, "Kitchen"),
+    ("SKU-MOC-001", "Mochila senderismo 40L", 39.99, "Sports & Outdoors"),
+    ("SKU-CRE-001", "Crema hidratante facial", 12.99, "Beauty & Personal Care"),
+    ("SKU-CAM-001", "Camiseta algodón premium", 14.99, "Fashion & Accessories"),
+    ("SKU-ZAP-001", "Zapato running deportivo", 55.00, "Fashion & Accessories"),
+    ("SKU-BEB-001", "Juguetes educativos bebé", 27.99, "Baby & Toys"),
+    ("SKU-CAR-002", "Coche control remoto RC", 45.00, "Auto Parts"),
+    ("SKU-LAM-001", "Lámpara de mesa madera", 33.50, "Home & Living"),
+    ("SKU-PER-001", "Perfume floral 100ml", 28.99, "Beauty & Personal Care"),
+    ("SKU-COC-002", "Cuchillo chef acero inox", 18.50, "Kitchen"),
+]
+
+CARRIERS = ["CTT Express", "DHL", "SEUR", "MRW", "Correos", "GLS"]
+CITIES = ["Madrid", "Barcelona", "Valencia", "Sevilla", "Bilbao", "Málaga", "Zaragoza"]
+COUNTRIES = ["ES", "PT", "FR", "DE", "IT"]
+PAY_METHODS = ["Credit Card", "PayPal", "Klarna", "Bizum", "Apple Pay"]
+CANCEL_REASONS = ["Out of stock", "Buyer request", "Price error", "Shipping delay", "Address issue"]
+CANCEL_INITIATORS = ["buyer", "seller", "system"]
+REFUND_REASONS = [
+    "Product not as described",
+    "Damaged in transit",
+    "Wrong item received",
+    "Late delivery",
+    "Quality issue",
+    "Buyer changed mind",
+    "Missing parts",
+]
+REFUND_TYPES = ["RETURN_REFUND", "MONEY_ONLY", "RESEND"]
+DUTY_PARTIES = ["buyer", "seller", "pending"]
+SHIPMENT_TYPES = ["standard", "express", "pickup"]
+ITEM_STATUSES = ["shipped", "delivered", "pending", "canceled", "returned"]
+
+
+def _gen_order_id(i):
+    return f"ORD-{20260600 + i:07d}"
+
+
+def _gen_item_id(i):
+    return f"ITM-{30000000 + i:08d}"
+
+
+def _gen_buyer_id(i):
+    return f"BUY-{50000 + i:05d}"
+
+
+def _gen_refund_id(i):
+    return f"RFD-{800000 + i:06d}"
+
+
+def _gen_tracking(i):
+    return f"TRK{100000000 + i:09d}"
+
+
+def gen_mock_rows(n_days=14, n_orders_per_day=8, refund_rate=0.18, cancel_rate=0.12,
+                  miravia_ratio=0.6):
+    """Generate mock sub-order rows for the v4 dashboard."""
+    rows = []
+    idx = 0
+    today = datetime.now().replace(hour=0, minute=0, second=0, microsecond=0)
+
+    for d in range(n_days):
+        date = today - timedelta(days=n_days - 1 - d)
+        date_str = date.strftime("%Y-%m-%d %H:%M:%S")
+
+        for o in range(n_orders_per_day):
+            order_id = _gen_order_id(idx)
+            is_miravia = random.random() < miravia_ratio
+            marketplace = "miravia" if is_miravia else "aliexpress"
+            buyer_id = _gen_buyer_id(idx % 200)  # Some repeat buyers
+            country = random.choice(COUNTRIES)
+            city = random.choice(CITIES)
+            pay_method = random.choice(PAY_METHODS)
+            carrier = random.choice(CARRIERS)
+            ship_type = random.choice(SHIPMENT_TYPES)
+            items_count = random.randint(1, 3)
+
+            for item_i in range(items_count):
+                sku, name, price, cat = random.choice(PRODUCTS)
+                qty = random.randint(1, 2)
+                unit_price = price
+                discount_seller = round(price * random.choice([0, 0, 0, 0.05, 0.10, 0.15]), 2)
+                buyer_paid = round((unit_price - discount_seller) * qty, 2)
+                shipping_paid = round(random.choice([0, 0, 4.99, 6.99, 9.99]), 2)
+                item_status = random.choices(ITEM_STATUSES, weights=[30, 35, 15, 10, 10])[0]
+
+                is_canceled = random.random() < cancel_rate
+                if is_canceled:
+                    item_status = "canceled"
+                    cancel_initiator = random.choice(CANCEL_INITIATORS)
+                    cancel_reason = random.choice(CANCEL_REASONS)
+                else:
+                    cancel_initiator = ""
+                    cancel_reason = ""
+
+                is_refund = (not is_canceled) and (random.random() < refund_rate)
+                if is_refund:
+                    refund_id = _gen_refund_id(idx)
+                    refund_apply_at = date_str
+                    refund_status = random.choice(["SUCCESS", "PROCESSING", "FAILED"])
+                    refund_amount = round(buyer_paid * random.uniform(0.5, 1.0), 2)
+                    refund_reason = random.choice(REFUND_REASONS)
+                    is_fast_refund = random.random() < 0.3
+                    is_instant_refund = random.random() < 0.15
+                    refund_tracking = _gen_tracking(idx) if random.random() < 0.4 else ""
+                    request_type = random.choice(REFUND_TYPES)
+                    duty_party = random.choice(DUTY_PARTIES)
+                    seller_agreed = random.random() < 0.7
+                    refund_payment = random.choice(PAY_METHODS)
+                    reason_code = f"RC{random.randint(1000, 9999)}"
+                else:
+                    refund_id = ""
+                    refund_apply_at = ""
+                    refund_status = ""
+                    refund_amount = ""
+                    refund_reason = ""
+                    is_fast_refund = False
+                    is_instant_refund = False
+                    refund_tracking = ""
+                    request_type = ""
+                    duty_party = ""
+                    seller_agreed = ""
+                    refund_payment = ""
+                    reason_code = ""
+
+                row = {
+                    # Order
+                    "order_id": order_id,
+                    "marketplace": marketplace,
+                    "created_at": date_str,
+                    "items_count": items_count,
+                    "payment_method": pay_method,
+                    "buyer_id": buyer_id,
+                    "buyer_name": f"Customer {buyer_id}",
+                    "ship_address": f"Street {random.randint(1, 999)}, {city}",
+                    "ship_country": country,
+                    "warehouse_code": f"WH-{random.choice(['MAD', 'BCN', 'VAL'])}",
+                    "buyer_remark": random.choice(["", "", "Please ship fast"]),
+                    "seller_remark": random.choice(["", "", "VIP customer"]),
+                    # Item
+                    "order_item_id": _gen_item_id(idx),
+                    "item_status": item_status,
+                    "item_updated_at": date_str,
+                    # Product
+                    "product_id": f"PID-{idx:06d}",
+                    "product_name": name,
+                    "product_url": f"https://miravia.es/p/{idx}",
+                    "sku": sku,
+                    "shop_sku": f"SS-{sku}",
+                    "quantity": qty,
+                    "unit_price": unit_price,
+                    # Amount
+                    "buyer_paid": buyer_paid,
+                    "discount_total": discount_seller,
+                    "discount_platform": round(discount_seller * 0.3, 2),
+                    "discount_seller": discount_seller,
+                    "shipping_paid": shipping_paid,
+                    "shipping_disc_total": round(shipping_paid * 0.5, 2) if shipping_paid > 0 else 0,
+                    "shipping_disc_platform": 0,
+                    "shipping_disc_seller": round(shipping_paid * 0.3, 2) if shipping_paid > 0 else 0,
+                    "currency": "EUR",
+                    # Logistics
+                    "shipment_type": ship_type,
+                    "tracking_no": _gen_tracking(idx) if not is_canceled else "",
+                    "package_id": f"PKG-{idx:06d}",
+                    "shipping_provider": carrier,
+                    # Cancellation
+                    "is_canceled": is_canceled,
+                    "cancel_initiator": cancel_initiator,
+                    "cancel_reason": cancel_reason,
+                    # Refund
+                    "refund_id": refund_id,
+                    "refund_apply_at": refund_apply_at,
+                    "refund_status": refund_status,
+                    "refund_amount": refund_amount,
+                    "refund_reason": refund_reason,
+                    "is_fast_refund": is_fast_refund,
+                    "is_instant_refund": is_instant_refund,
+                    "refund_tracking_no": refund_tracking,
+                    # ---- v4 additions ----
+                    "city": city,
+                    "ship_to": f"Recipient {idx}",
+                    "channel": "online",
+                    "order_flag": random.choice(["", "", "priority", "gift"]),
+                    "is_fbl": 1 if random.random() < 0.25 else 0,
+                    "is_digital": 1 if random.random() < 0.05 else 0,
+                    "is_sof": 1 if random.random() < 0.10 else 0,
+                    "shipping_fee_original": shipping_paid,
+                    "shipping_fee_disc_seller": round(shipping_paid * 0.3, 2) if shipping_paid > 0 else 0,
+                    "voucher_seller_lpi": round(discount_seller, 2) if discount_seller > 0 else 0,
+                    "variation": f"Variant-{random.choice(['A', 'B', 'C'])}",
+                    "returnable": 1 if not is_canceled else 0,
+                    "request_type": request_type,
+                    "duty_party": duty_party,
+                    "is_not_received": 1 if (is_refund and random.random() < 0.3) else 0,
+                    "refund_payment_method": refund_payment,
+                    "reason_code": reason_code,
+                    "ofc_status": random.choice(["", "OK", "WARNING"]),
+                    "refund_currency": "EUR" if is_refund else "",
+                    "seller_sku_id": f"SID-{sku}",
+                    "seller_agreed": seller_agreed,
+                }
+                rows.append(row)
+                idx += 1
+
+    return rows
+
+
+def main():
+    out_dir = THIS_DIR.parent / "out"
+    out_dir.mkdir(exist_ok=True)
+    jinja_env = _jinja_env()
+
+    # ---- Scenario 1: Business (rich data, balanced) — all languages ----
+    print("=" * 60)
+    print("Scenario 1: business (rich data) — multi-language")
+    print("=" * 60)
+    rows = gen_mock_rows(n_days=14, n_orders_per_day=8, refund_rate=0.15, cancel_rate=0.10)
+    for lang in SUPPORTED_LANGS:
+        out_path = out_dir / f"test_v4_business_{lang}.html"
+        report_v4.render(
+            rows=rows, out_path=out_path,
+            range_label="2026-06-08 ~ 2026-06-21",
+            jinja_env=jinja_env, export_columns=EXPORT_COLUMNS,
+            default_max_orders=10000, lang=lang,
+        )
+        print(f"  [{lang}] Generated: {out_path} ({out_path.stat().st_size / 1024:.1f} KB)")
+    print(f"  Rows: {len(rows)}")
+    # Keep reference to en version for browser open
+    out_path = out_dir / "test_v4_business_en.html"
+
+    # ---- Scenario 2: Refund (high refund rate) ----
+    print("\n" + "=" * 60)
+    print("Scenario 2: refund (high refund rate)")
+    print("=" * 60)
+    rows2 = gen_mock_rows(n_days=30, n_orders_per_day=6, refund_rate=0.35, cancel_rate=0.08)
+    out_path2 = out_dir / "test_v4_refund.html"
+    report_v4.render(
+        rows=rows2, out_path=out_path2,
+        range_label="2026-05-23 ~ 2026-06-21",
+        jinja_env=jinja_env, export_columns=EXPORT_COLUMNS,
+        default_max_orders=10000, lang="es",
+    )
+    print(f"  Generated: {out_path2} ({out_path2.stat().st_size / 1024:.1f} KB)")
+    print(f"  Rows: {len(rows2)}")
+
+    # ---- Scenario 3: Empty data (degradation test) ----
+    print("\n" + "=" * 60)
+    print("Scenario 3: empty data (degradation)")
+    print("=" * 60)
+    out_path3 = out_dir / "test_v4_empty.html"
+    report_v4.render(
+        rows=[], out_path=out_path3,
+        range_label="2026-06-15 ~ 2026-06-21",
+        jinja_env=jinja_env, export_columns=EXPORT_COLUMNS,
+        default_max_orders=10000, lang="zh",
+    )
+    print(f"  Generated: {out_path3} ({out_path3.stat().st_size / 1024:.1f} KB)")
+    print(f"  Rows: 0")
+
+    # ---- Scenario 4: Auto (mixed, small dataset) ----
+    print("\n" + "=" * 60)
+    print("Scenario 4: auto (small dataset, 3 days)")
+    print("=" * 60)
+    rows4 = gen_mock_rows(n_days=3, n_orders_per_day=5, refund_rate=0.25, cancel_rate=0.20,
+                          miravia_ratio=0.3)
+    out_path4 = out_dir / "test_v4_auto.html"
+    report_v4.render(
+        rows=rows4, out_path=out_path4,
+        range_label="2026-06-19 ~ 2026-06-21",
+        jinja_env=jinja_env, export_columns=EXPORT_COLUMNS,
+        default_max_orders=10000,
+    )
+    print(f"  Generated: {out_path4} ({out_path4.stat().st_size / 1024:.1f} KB)")
+    print(f"  Rows: {len(rows4)}")
+
+    print("\n" + "=" * 60)
+    print("All scenarios completed! Opening in browser...")
+    print("=" * 60)
+
+    # Open the main business report
+    import webbrowser
+    webbrowser.open(f"file://{out_path}")
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/dist/scripts/trace_logger.py

@@ -0,0 +1,97 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+OpenAPI Trace Logger
+
+Records every Miravia API call with traceId for debugging and tracing.
+Log file: logs/trace-{YYYY-MM-DD}.log (one JSON line per API call)
+Retention: 3 days (auto-cleanup on each write)
+
+Fields per entry:
+  - time      : Request timestamp (ISO format with milliseconds)
+  - api       : API endpoint path (e.g. /orders/get)
+  - params    : Business request parameters (excluding sign/token/common fields)
+  - traceId   : Trace ID returned by the API (may be multiple per session)
+  - success   : Whether the request was successful (true/false)
+"""
+
+import json
+import logging
+from datetime import datetime, timedelta
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+# Skill root directory / logs
+_SKILL_DIR = Path(__file__).resolve().parent.parent
+_LOGS_DIR = _SKILL_DIR / "logs"
+
+# Trace log retention: 5 days
+_TRACE_RETENTION_DAYS = 5
+
+_logger = logging.getLogger("miravia.trace_logger")
+
+
+def _trace_log_path() -> Path:
+    """Return today's trace log file path: logs/trace-{YYYY-MM-DD}.log"""
+    _LOGS_DIR.mkdir(parents=True, exist_ok=True)
+    date_str = datetime.now().strftime("%Y-%m-%d")
+    return _LOGS_DIR / f"trace-{date_str}.log"
+
+
+def _cleanup_old_trace_logs() -> None:
+    """Delete trace log files older than _TRACE_RETENTION_DAYS days."""
+    if not _LOGS_DIR.exists():
+        return
+    cutoff = datetime.now() - timedelta(days=_TRACE_RETENTION_DAYS)
+    for f in _LOGS_DIR.glob("trace-*.log"):
+        try:
+            date_part = f.stem.replace("trace-", "")
+            file_date = datetime.strptime(date_part, "%Y-%m-%d")
+            if file_date < cutoff:
+                f.unlink(missing_ok=True)
+        except (ValueError, OSError):
+            pass
+
+
+# Common/sensitive keys to exclude from logged params
+_EXCLUDED_PARAM_KEYS = {
+    "app_key", "access_token", "sign", "sign_method", "timestamp",
+    "skill_name", "action", "agent_type", "model_name",
+}
+
+
+def record_trace(api: str, trace_id: Optional[str], success: bool,
+                 params: Optional[Dict[str, Any]] = None) -> None:
+    """Write one trace record to logs/trace-{date}.log.
+
+    Args:
+        api: API endpoint path (e.g. "/orders/get")
+        trace_id: Trace ID from API response (may be None if not present)
+        success: Whether the API call was successful
+        params: Request parameters (common/sensitive fields will be filtered out)
+    """
+    # Filter out common/sensitive params, keep only business params
+    biz_params = {}
+    if params:
+        biz_params = {k: v for k, v in params.items() if k not in _EXCLUDED_PARAM_KEYS}
+
+    entry = {
+        "time": datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")[:-3],
+        "api": api,
+        "params": biz_params,
+        "traceId": trace_id or "",
+        "success": success,
+    }
+
+    log_path = _trace_log_path()
+    try:
+        with open(log_path, "a", encoding="utf-8") as f:
+            f.write(json.dumps(entry, ensure_ascii=False) + "\n")
+    except OSError as e:
+        _logger.warning("Failed to write trace log: %s", e)
+
+    # Auto-cleanup expired trace logs
+    try:
+        _cleanup_old_trace_logs()
+    except Exception:
+        pass

package/dist/scripts/validate_render.py

@@ -0,0 +1,101 @@
+#!/usr/bin/env python3
+"""
+Post-injection rendering validator for miravia-order-report HTML reports.
+
+Validates that injected agentInsights JSON conforms to the frontend schema,
+preventing undefined/broken renders in the browser.
+
+Usage:
+    python3 scripts/validate_render.py <report_html_path>
+
+Exit codes:
+    0 - RENDER_CHECK: OK (all presets valid)
+    1 - FAIL: structural errors detected (details printed to stdout)
+"""
+
+import json
+import re
+import sys
+
+
+def validate_report(html_path: str) -> tuple[bool, str]:
+    """Validate agentInsights structure in an HTML report.
+
+    Returns:
+        (success: bool, message: str)
+    """
+    with open(html_path, encoding="utf-8") as f:
+        html = f.read()
+
+    m = re.search(r"const\s+DATA\s*=\s*", html)
+    if not m:
+        return False, "DATA block not found"
+
+    start = m.end()
+    depth = 0
+    i = start
+    while i < len(html):
+        if html[i] == "{":
+            depth += 1
+        elif html[i] == "}":
+            depth -= 1
+            if depth == 0:
+                break
+        i += 1
+
+    try:
+        data = json.loads(html[start : i + 1])
+    except json.JSONDecodeError as e:
+        return False, f"DATA JSON parse error: {e}"
+
+    ai = data.get("agentInsights", {}).get("presets", {})
+    if not ai:
+        return False, "agentInsights.presets is empty"
+
+    errors = []
+    for pk, preset in ai.items():
+        if not isinstance(preset, dict) or not preset.get("summary"):
+            errors.append(f"preset {pk}: missing summary")
+            continue
+        for h in preset.get("highlights", []):
+            if not isinstance(h, dict):
+                errors.append(f"preset {pk}: highlight is not an object")
+            elif "title" not in h or "detail" not in h or "severity" not in h:
+                errors.append(f"preset {pk}: highlight missing title/detail/severity")
+            elif h["severity"] not in ("high", "medium", "low"):
+                errors.append(
+                    f"preset {pk}: highlight severity '{h['severity']}' invalid (must be high/medium/low)"
+                )
+        for ac in preset.get("actions", []):
+            if not isinstance(ac, dict):
+                errors.append(f"preset {pk}: action is not an object")
+            elif "text" not in ac or "priority" not in ac:
+                errors.append(f"preset {pk}: action missing text/priority")
+            elif ac["priority"] not in ("P0", "P1", "P2"):
+                errors.append(
+                    f"preset {pk}: action priority '{ac['priority']}' invalid (must be P0/P1/P2)"
+                )
+
+    if errors:
+        return False, "; ".join(errors)
+    return True, "OK"
+
+
+def main():
+    if len(sys.argv) < 2:
+        print(f"Usage: {sys.argv[0]} <report_html_path>", file=sys.stderr)
+        sys.exit(2)
+
+    html_path = sys.argv[1]
+    success, message = validate_report(html_path)
+
+    if success:
+        print(f"RENDER_CHECK: {message}")
+        sys.exit(0)
+    else:
+        print(f"FAIL: {message}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()