Primer commit

scripts/apply_custom_field_layout.py

@@ -0,0 +1,388 @@
+#!/usr/bin/env python3
+"""Aplica un LAYOUT explícito (folder + orden) a los custom fields de cada cuenta.
+
+A diferencia de align_custom_field_order.py (que usa Marca como referencia), aquí
+el orden lo define una tabla declarativa `LAYOUT` editable abajo: por cada objeto
+(contact/opportunity) y folder, la lista ordenada de campos por NOMBRE.
+
+Para cada campo listado se asigna:
+  - parentId = el folder destino (resuelto por NOMBRE en cada cuenta), moviéndolo
+    de folder si hace falta.
+  - position = posición incremental según su orden en la lista (100, 200, 300…).
+
+Reglas:
+  - Los campos NO listados en el LAYOUT no se tocan (quedan en su folder/posición).
+  - Match por nombre normalizado (case + acentos + espacios insensitive).
+  - Campos estándar (First Name, Phone, Email…) NO los expone la API → no se tocan.
+  - Si un campo o folder del LAYOUT no existe en la cuenta, se reporta y se omite.
+
+Verificado contra la API V2 de GHL: `PUT /locations/{loc}/customFields/{id}` con
+`{"parentId": ..., "position": N}` aplica ambos (la `position` sola es ignorada).
+Cambio puramente organizacional (UI): no afecta valores, workflows ni formularios.
+
+Uso:
+    python scripts/apply_custom_field_layout.py --location <id>            # dry-run
+    python scripts/apply_custom_field_layout.py --location <id> --apply --run-id <uuid>
+    python scripts/apply_custom_field_layout.py --all --apply --run-id <uuid>
+"""
+
+import argparse
+import datetime
+import json
+import os
+import sys
+import time
+import unicodedata
+import warnings
+
+warnings.filterwarnings("ignore", message=r"urllib3 .* doesn't match a supported version!")
+import requests
+
+ROOT_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+if ROOT_DIR not in sys.path:
+    sys.path.insert(0, ROOT_DIR)
+
+import sync_engine  # noqa: E402
+import script_audit  # noqa: E402
+from paths import MIGRATIONS_DIR  # noqa: E402
+
+BASE_URL = "https://services.leadconnectorhq.com"
+API_VERSION = "2021-07-28"
+BRAND_LOCATION_ID = "GbKkBpCmKu2QmloKFHy3"
+DEMO_LOCATION_IDS = ["Vf7qQl3L9vakJ8hDtQ8e", "Z64WQKORPVwXb5mn68Ef"]
+POSITION_STEP = 100  # separación entre campos consecutivos dentro de un folder
+
+# ───────────────────────────────────────────────────────────────────────────
+# LAYOUT declarativo — editar aquí el orden deseado.
+# Estructura: { object_key: [ (folder_name, [field_name_en_orden, ...]), ... ] }
+# Solo se tocan los campos listados. Los demás quedan intactos.
+# ───────────────────────────────────────────────────────────────────────────
+
+LAYOUT = {
+    "opportunity": [
+        ("Opportunity Details", [
+            "Persona que atendió al prospecto",
+            "Vehículo",
+            "Modalidad de Empeño",
+            "Fuente de Prospecto",
+            "Visita a Sucursal",
+            "Fecha de ultima visita a sucursal",
+            "Lead Descartado",
+            "CANAL DE ORIGEN",
+            "Sucursal",
+            "TIENDA",
+            "ID Oportunidad Sucursal",
+        ]),
+    ],
+    "contact": [
+        ("Contact", [
+            "Marca del Vehículo",
+            "Versión del Vehículo",
+            "Año del Vehículo",
+            "¿Qué modalidad prefieres?",
+            "TIENDA",
+        ]),
+        # Campos sacados del folder "Contact" hacia "Additional Info" (después de
+        # los que ya viven ahí). Se listan los existentes para fijar el orden.
+        ("Additional Info", [
+            "Descripción",
+            "Presupuesto",
+            "Archivos Adicionales",
+            "Sucursal",
+            "Información Adicional",
+            "Fuente de Prospecto",
+            "ID Contacto Monte Providencia",
+            "ID Contacto Sucursal",
+        ]),
+    ],
+}
+
+_last_request_by_token: dict = {}
+
+
+def normalize_name(value):
+    s = str(value or "").strip().lower()
+    s = unicodedata.normalize("NFKD", s)
+    s = "".join(c for c in s if not unicodedata.combining(c))
+    return " ".join(s.split())
+
+
+def wait_for_rate_limit(token):
+    elapsed = time.time() - _last_request_by_token.get(token, 0)
+    if elapsed < 0.110:
+        time.sleep(0.110 - elapsed)
+    _last_request_by_token[token] = time.time()
+
+
+def ghl_request(method, endpoint, token, *, params=None, json_body=None,
+                version=API_VERSION, retries=3):
+    wait_for_rate_limit(token)
+    url = endpoint if endpoint.startswith("http") else f"{BASE_URL}{endpoint}"
+    headers = {
+        "Accept": "application/json",
+        "Authorization": f"Bearer {token}",
+        "Version": version,
+        "Content-Type": "application/json",
+    }
+    last_exc = None
+    for attempt in range(retries):
+        try:
+            resp = requests.request(method, url, headers=headers, params=params,
+                                    json=json_body, timeout=30)
+        except requests.RequestException as exc:
+            last_exc = exc
+            time.sleep(0.5 * (attempt + 1))
+            continue
+        if resp.status_code == 429:
+            time.sleep(1.0 * (attempt + 1))
+            continue
+        if resp.status_code >= 500:
+            time.sleep(1.0 * (attempt + 1))
+            continue
+        resp.raise_for_status()
+        if resp.status_code == 204:
+            return {}
+        return resp.json()
+    if last_exc:
+        raise last_exc
+
+
+def list_fields_and_folders(account, model):
+    data = ghl_request("GET", f"/locations/{account['location_id']}/customFields",
+                       account["token"], params={"model": model})
+    items = data.get("customFields") or []
+    fields = [f for f in items if f.get("documentType") != "folder"]
+    parent_ids = {f.get("parentId") for f in fields if f.get("parentId")}
+    folders_by_id = {}
+    for pid in parent_ids:
+        try:
+            d = ghl_request("GET", f"/locations/{account['location_id']}/customFields/{pid}",
+                            account["token"])
+            cf = d.get("customField") or d
+            if cf.get("documentType") == "folder":
+                folders_by_id[pid] = cf
+        except Exception as exc:
+            print(f"  ⚠ No pude leer folder {pid}: {exc}")
+    return fields, folders_by_id
+
+
+def plan_account_model(account, model, folder_specs):
+    """folder_specs: lista [(folder_name, [field_name,...]), ...]."""
+    actions = []
+    fields, folders_by_id = list_fields_and_folders(account, model)
+    field_by_norm = {}
+    for f in fields:
+        field_by_norm.setdefault(normalize_name(f.get("name")), f)
+    folder_id_by_norm = {normalize_name(fo.get("name")): pid
+                         for pid, fo in folders_by_id.items()}
+
+    # Posición máxima de los campos ESTÁNDAR por folder. Los estándar (First
+    # Name, Phone, Email, Pipeline, Stage…) no los expone el endpoint legacy de
+    # customFields, pero SÍ el schema V2, y comparten folder y position con los
+    # custom. Colocamos los custom DESPUÉS del último estándar del folder para
+    # que no queden intercalados (p.ej. Marca del Vehículo debajo de Phone).
+    std_max_by_pid = {}
+    try:
+        v2 = sync_engine.ghl_client.get_object_schema_fields(
+            account["token"], account["location_id"], model)
+        for f in v2:
+            if f.get("dataType") == "STANDARD_FIELD" or f.get("standard"):
+                pid = f.get("parentId")
+                pos = f.get("position") or 0
+                if pid and pos > std_max_by_pid.get(pid, -1):
+                    std_max_by_pid[pid] = pos
+    except Exception as exc:
+        print(f"  ⚠ No pude leer schema V2 (posiciones estándar): {exc}")
+
+    for folder_name, field_names in folder_specs:
+        target_pid = folder_id_by_norm.get(normalize_name(folder_name))
+        if not target_pid:
+            actions.append({
+                "status": "folder_missing", "object": model,
+                "folder": folder_name,
+                "details": f"Folder {folder_name!r} no existe en la cuenta.",
+            })
+            continue
+        base = std_max_by_pid.get(target_pid, 0)
+        for idx, fname in enumerate(field_names):
+            target_pos = base + (idx + 1) * POSITION_STEP
+            f = field_by_norm.get(normalize_name(fname))
+            if not f:
+                actions.append({
+                    "status": "field_missing", "object": model,
+                    "folder": folder_name, "field_name": fname,
+                    "details": f"Campo {fname!r} no existe en {model}.",
+                })
+                continue
+            cur_pid = f.get("parentId")
+            cur_pos = f.get("position")
+            cur_folder = (folders_by_id.get(cur_pid) or {}).get("name")
+            if cur_pid == target_pid and cur_pos == target_pos:
+                actions.append({
+                    "status": "already_ok", "object": model,
+                    "field_name": f.get("name"), "folder": folder_name,
+                })
+                continue
+            actions.append({
+                "status": "to_set", "object": model,
+                "field_id": f.get("id"), "field_name": f.get("name"),
+                "from": {"folder": cur_folder, "parentId": cur_pid, "position": cur_pos},
+                "to": {"folder": folder_name, "parentId": target_pid, "position": target_pos},
+            })
+    return actions
+
+
+def apply_actions(account, actions, *, dry_run, run_id):
+    stats = {"set": 0, "skipped": 0, "errors": []}
+    snap = {
+        "account": account["nombre"], "location_id": account["location_id"],
+        "timestamp_utc": datetime.datetime.now(datetime.timezone.utc).isoformat(),
+        "dry_run": dry_run, "actions": actions,
+    }
+    os.makedirs(MIGRATIONS_DIR, exist_ok=True)
+    ts = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+    safe = "".join(c if c.isalnum() else "_" for c in account["nombre"])[:40]
+    snap_path = os.path.join(MIGRATIONS_DIR, f"layout_{safe}_{ts}.json")
+    with open(snap_path, "w", encoding="utf-8") as fh:
+        json.dump(snap, fh, ensure_ascii=False, indent=2, default=str)
+
+    for a in actions:
+        if a["status"] != "to_set":
+            stats["skipped"] += 1
+            continue
+        if dry_run:
+            continue
+        change_id = None
+        if run_id:
+            change_id = script_audit.record_change(
+                run_id, account["location_id"], "__schema__",
+                a["field_id"], a["field_id"], a["field_name"],
+                {"parentId": a["from"]["parentId"], "position": a["from"]["position"]},
+                {"parentId": a["to"]["parentId"], "position": a["to"]["position"]},
+            )
+        try:
+            ghl_request("PUT",
+                        f"/locations/{account['location_id']}/customFields/{a['field_id']}",
+                        account["token"],
+                        json_body={"parentId": a["to"]["parentId"],
+                                   "position": a["to"]["position"]})
+            if change_id:
+                script_audit.mark_change(change_id, "applied")
+            stats["set"] += 1
+        except Exception as exc:
+            if change_id:
+                script_audit.mark_change(change_id, "failed", str(exc))
+            stats["errors"].append({"field_id": a["field_id"], "error": str(exc)})
+
+    return stats, snap_path
+
+
+def print_plan(account, actions):
+    to_set = [a for a in actions if a["status"] == "to_set"]
+    ok = sum(1 for a in actions if a["status"] == "already_ok")
+    miss = [a for a in actions if a["status"] in ("field_missing", "folder_missing")]
+    print(f"\n[Plan] {account['nombre']} ({account['location_id']})")
+    print(f"  ya ok={ok}  a aplicar={len(to_set)}  faltantes={len(miss)}")
+    for a in to_set:
+        fr, to = a["from"], a["to"]
+        moved = "" if fr["folder"] == to["folder"] else f"  [MUEVE folder {fr['folder']!r} → {to['folder']!r}]"
+        print(f"  ▸ {a['object']}.{a['field_name']!r}  pos {fr['position']}→{to['position']} en {to['folder']!r}{moved}")
+    for a in miss:
+        print(f"  ✗ {a['status']}  {a.get('field_name') or a.get('folder')!r}: {a['details']}")
+
+
+def select_targets(args, accounts):
+    if args.location:
+        m = [a for a in accounts if a["location_id"] == args.location]
+        if not m:
+            raise SystemExit(f"Location {args.location} no encontrada.")
+        return m
+    if args.demos:
+        return [a for a in accounts if a["location_id"] in DEMO_LOCATION_IDS]
+    if args.all_productive:
+        return [a for a in accounts
+                if a["location_id"] not in DEMO_LOCATION_IDS
+                and a["location_id"] != BRAND_LOCATION_ID]
+    if args.all:
+        return [a for a in accounts if a["location_id"] != BRAND_LOCATION_ID]
+    raise SystemExit("Especifica --location <id>, --demos, --all-productive o --all.")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Aplica un LAYOUT explícito de folder+orden a los custom fields.")
+    parser.add_argument("--location", help="Procesar solo esta cuenta.")
+    parser.add_argument("--demos", action="store_true", help="Solo las 2 cuentas DEMO.")
+    parser.add_argument("--all-productive", dest="all_productive", action="store_true",
+                        help="Todas las sucursales productivas (excluye Marca y DEMOs).")
+    parser.add_argument("--all", action="store_true", help="Todas las sucursales (excluye Marca).")
+    parser.add_argument("--object", choices=["contact", "opportunity", "both"], default="both",
+                        help="Objeto a procesar. Default both.")
+    parser.add_argument("--apply", action="store_true",
+                        help="Ejecuta los cambios. Sin este flag corre en DRY-RUN.")
+    parser.add_argument("--run-id", help="ID para registrar en script_audit (rollback).")
+    args = parser.parse_args()
+
+    if hasattr(sys.stdout, "reconfigure"):
+        sys.stdout.reconfigure(encoding="utf-8")
+
+    dry_run = not args.apply
+    models = ["contact", "opportunity"] if args.object == "both" else [args.object]
+    accounts = sync_engine.parse_accounts_csv()
+    targets = select_targets(args, accounts)
+
+    if args.run_id:
+        script_audit.create_run(
+            args.run_id, "apply_custom_field_layout.py",
+            arguments=" ".join(sys.argv[1:]),
+            locations=[t["location_id"] for t in targets],
+        )
+
+    print(f"Modo: {'DRY-RUN' if dry_run else 'APPLY'}")
+    print(f"Objetos: {', '.join(models)}")
+    print(f"Cuentas en scope: {len(targets)}")
+    for model in models:
+        for folder_name, names in LAYOUT.get(model, []):
+            print(f"  {model} / {folder_name}: {len(names)} campos")
+
+    total_set = total_skipped = 0
+    errors_global = []
+    for acc in targets:
+        if not script_audit.wait_if_paused_or_stopped(args.run_id):
+            print("Detención solicitada. Saliendo.")
+            break
+        all_actions = []
+        try:
+            for model in models:
+                if model in LAYOUT:
+                    all_actions.extend(plan_account_model(acc, model, LAYOUT[model]))
+        except Exception as exc:
+            print(f"  [{acc['nombre']}] ERROR plan: {exc}")
+            errors_global.append({"account": acc["nombre"], "error": str(exc)})
+            continue
+        print_plan(acc, all_actions)
+        try:
+            stats, snap_path = apply_actions(acc, all_actions, dry_run=dry_run, run_id=args.run_id)
+            total_set += stats["set"]
+            total_skipped += stats["skipped"]
+            errors_global.extend(stats["errors"])
+            print(f"  snapshot: {snap_path}")
+            if not dry_run:
+                print(f"  ✓ set={stats['set']}  skipped={stats['skipped']}  errors={len(stats['errors'])}")
+        except Exception as exc:
+            print(f"  ✗ apply falló: {exc}")
+            errors_global.append({"account": acc["nombre"], "error": str(exc)})
+
+    print("\n" + "=" * 60)
+    if dry_run:
+        print("DRY-RUN — no se modificó nada. Revisa el plan y vuelve a correr con --apply.")
+    print(f"Cuentas procesadas : {len(targets)}")
+    print(f"Campos colocados   : {total_set}")
+    print(f"Acciones saltadas  : {total_skipped}")
+    print(f"Errores            : {len(errors_global)}")
+    for e in errors_global[:20]:
+        print(f"   - {e}")
+
+
+if __name__ == "__main__":
+    main()