Jason Thistlethwaite
641 lines
23 KiB
Python
641 lines
23 KiB
Python
#!/usr/bin/env python3
|
|
"""Bridge Redmine ticket entities → NMI agent CLI (mrscClient-php bin/nmi).
|
|
|
|
Pattern extract stays in redmine_ticket_entities.py (no NMI I/O).
|
|
This module shells out to the NMI CLI for resolve / cs-brief using those hints.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
import os
|
|
import re
|
|
import shutil
|
|
import subprocess
|
|
from dataclasses import dataclass, field
|
|
from pathlib import Path
|
|
from typing import Any, Iterable, Optional
|
|
|
|
# Compatibility constants are environment-independent. Resolve overrides at call
|
|
# time so a TUI/worker cannot retain a profile captured during module import.
|
|
DEFAULT_NMI_BIN = str(Path(__file__).resolve().parent.parent / "mrscClient-php" / "bin" / "nmi")
|
|
DEFAULT_ENV_FILE = None # PHP owns default env-file discovery.
|
|
DEFAULT_MODE = "production"
|
|
|
|
|
|
def discover_nmi_bin(value: Optional[str] = None, *, environ=None) -> Path:
|
|
env = os.environ if environ is None else environ
|
|
selected = value or env.get("NMI_CLI")
|
|
if selected:
|
|
expanded = str(Path(selected).expanduser())
|
|
return Path(shutil.which(expanded, path=env.get("PATH", os.defpath)) or expanded).resolve()
|
|
found = shutil.which("nmi", path=env.get("PATH", os.defpath))
|
|
return Path(found or DEFAULT_NMI_BIN).resolve()
|
|
|
|
# Entity types that map cleanly into NMI resolve ids
|
|
_TRACKING_TYPES = {
|
|
"tracking_ups",
|
|
"tracking_usps",
|
|
"tracking_fedex_candidate",
|
|
}
|
|
_ORDER_TYPES = {"order_amazon", "order_id"}
|
|
_ITEM_TYPES = {"item_no", "item_or_sku"}
|
|
_ACCOUNT_TYPES = {"account_ref"}
|
|
# NMI deep link templates (from obsidian-ldr/INBOX/WIP/Linking to Entities Within NMI.md)
|
|
NMI_BASE = "https://app.ldrprep.com"
|
|
NMI_LINKS = {
|
|
"item_no": {
|
|
"manager": lambda v: f"{NMI_BASE}/?page=itemManager&itemNo={v}",
|
|
"statement": lambda v: f"{NMI_BASE}/?page=itemStatement&itemNo={v}",
|
|
},
|
|
"item_or_sku": {
|
|
"manager": lambda v: f"{NMI_BASE}/?page=itemManager&itemNo={v}",
|
|
},
|
|
"tracking_ups": {"box_history": lambda v: f"{NMI_BASE}/?page=boxFinder&tracking_number={v}&action=search"},
|
|
"tracking_usps": {"box_history": lambda v: f"{NMI_BASE}/?page=boxFinder&tracking_number={v}&action=search"},
|
|
"tracking_fedex_candidate": {"box_history": lambda v: f"{NMI_BASE}/?page=boxFinder&tracking_number={v}&action=search"},
|
|
"order_id": {"order_summary": lambda v: f"{NMI_BASE}/?page=requests&filter=view&id={v}"},
|
|
"request_id": {"package_history": lambda v: f"{NMI_BASE}/?page=boxFinder&request_id={v}"},
|
|
"account_ref": {"user_info": lambda v: f"{NMI_BASE}/?page=userInfo&accountNo={v}"},
|
|
}
|
|
|
|
|
|
# LDR unit item numbers commonly 9 digits starting with 2
|
|
_ITEM_NO_BARE = re.compile(r"\b(2\d{8})\b")
|
|
|
|
|
|
@dataclass(frozen=True)
|
|
class NmiRuntimeProfile:
|
|
"""Resolved NMI execution settings plus a preflight result."""
|
|
|
|
mode: str
|
|
env_file: Optional[Path]
|
|
nmi_bin: Path
|
|
endpoint: Optional[str]
|
|
ready: bool
|
|
problem: Optional[str] = None
|
|
|
|
|
|
def resolve_runtime_profile(
|
|
*,
|
|
mode: Optional[str] = None,
|
|
env_file: Optional[str] = None,
|
|
nmi_bin: Optional[str] = None,
|
|
endpoint: Optional[str] = None,
|
|
environ: Optional[dict[str, str]] = None,
|
|
) -> NmiRuntimeProfile:
|
|
"""Run the actual PHP resolver offline; never equate file existence to readiness.
|
|
|
|
With no explicit env file, let NMI perform its own documented discovery.
|
|
Environment-only credentials are valid. No service requests are performed.
|
|
"""
|
|
env = dict(os.environ if environ is None else environ)
|
|
requested_mode = (mode or env.get("NMI_MODE") or DEFAULT_MODE).strip().lower()
|
|
normalized_mode = "production" if requested_mode == "prod" else requested_mode
|
|
requested_file = env_file or env.get("NMI_ENV_FILE")
|
|
selected_env_file = Path(requested_file).expanduser().resolve() if requested_file else None
|
|
selected_nmi_bin = discover_nmi_bin(nmi_bin, environ=env)
|
|
|
|
def failed(problem):
|
|
return NmiRuntimeProfile(normalized_mode, selected_env_file, selected_nmi_bin, endpoint, False, problem)
|
|
|
|
if normalized_mode not in {"production", "dev"}:
|
|
return failed("NMI_MODE must be production or dev.")
|
|
if selected_env_file is not None:
|
|
try:
|
|
if not selected_env_file.is_file():
|
|
return failed(f"NMI env file does not exist: {selected_env_file}")
|
|
if selected_env_file.stat().st_size == 0:
|
|
return failed(f"NMI env file is empty: {selected_env_file}")
|
|
except OSError as exc:
|
|
return failed(f"Cannot inspect NMI env file: {exc}")
|
|
if not selected_nmi_bin.is_file():
|
|
return failed(f"NMI CLI does not exist: {selected_nmi_bin}; set NMI_CLI.")
|
|
php = shutil.which("php", path=env.get("PATH", os.defpath))
|
|
if not php:
|
|
return failed("PHP is not on PATH; NMI requires the php CLI.")
|
|
cmd = [php, str(selected_nmi_bin), "--doctor", "--json"]
|
|
# Preserve NMI env-file mode when no caller/environment mode was supplied.
|
|
if mode or env.get("NMI_MODE"):
|
|
cmd.append(f"--mode={normalized_mode}")
|
|
if selected_env_file:
|
|
cmd.append(f"--env-file={selected_env_file}")
|
|
if endpoint:
|
|
cmd.append(f"--endpoint={endpoint}")
|
|
try:
|
|
proc = subprocess.run(cmd, capture_output=True, text=True, timeout=15, check=False, env=env)
|
|
except subprocess.TimeoutExpired:
|
|
return failed("NMI offline doctor timed out after 15 seconds.")
|
|
except OSError as exc:
|
|
return failed(f"Could not start NMI doctor: {exc}")
|
|
try:
|
|
data = json.loads(proc.stdout)
|
|
if not isinstance(data, dict):
|
|
raise ValueError("expected an object")
|
|
except (ValueError, TypeError):
|
|
return failed(f"NMI doctor returned invalid diagnostic JSON (exit {proc.returncode}); update NMI_CLI to a compatible bin/nmi.")
|
|
ready = proc.returncode == 0 and data.get("ready") is True
|
|
resolved_file = data.get("env_file")
|
|
return NmiRuntimeProfile(
|
|
mode=data.get("mode") or normalized_mode,
|
|
env_file=Path(resolved_file) if resolved_file else selected_env_file,
|
|
nmi_bin=selected_nmi_bin,
|
|
endpoint=data.get("endpoint") or endpoint,
|
|
ready=ready,
|
|
problem=None if ready else (data.get("problem") or f"NMI doctor failed (exit {proc.returncode})."),
|
|
)
|
|
|
|
|
|
@dataclass
|
|
class NmiLookupPlan:
|
|
"""Deduped identifiers to try against NMI, highest confidence first."""
|
|
|
|
tracking: list[str] = field(default_factory=list)
|
|
order_id: list[str] = field(default_factory=list)
|
|
item_no: list[str] = field(default_factory=list)
|
|
account: list[str] = field(default_factory=list)
|
|
skipped: list[dict[str, str]] = field(default_factory=list)
|
|
|
|
def is_empty(self) -> bool:
|
|
return not (self.tracking or self.order_id or self.item_no or self.account)
|
|
|
|
|
|
def enrich_entities_with_item_nos(
|
|
entities: list[dict[str, str]], text: str
|
|
) -> list[dict[str, str]]:
|
|
"""Add bare LDR-style item numbers when not already present."""
|
|
seen = {(e.get("type"), (e.get("value") or "").upper()) for e in entities}
|
|
out = list(entities)
|
|
for m in _ITEM_NO_BARE.finditer(text or ""):
|
|
val = m.group(1)
|
|
key = ("item_no", val)
|
|
if key in seen:
|
|
continue
|
|
# Avoid treating pure tracking-ish long numbers: item is exactly 9 digits
|
|
out.append({"type": "item_no", "value": val, "confidence": "medium"})
|
|
seen.add(key)
|
|
return out
|
|
|
|
|
|
def plan_from_entities(entities: Iterable[dict[str, str]]) -> NmiLookupPlan:
|
|
plan = NmiLookupPlan()
|
|
seen_t: set[str] = set()
|
|
seen_o: set[str] = set()
|
|
seen_i: set[str] = set()
|
|
seen_a: set[str] = set()
|
|
|
|
# Sort high confidence first
|
|
ordered = sorted(
|
|
entities,
|
|
key=lambda e: {"high": 0, "medium": 1, "low": 2}.get(e.get("confidence") or "high", 3),
|
|
)
|
|
|
|
for e in ordered:
|
|
kind = e.get("type") or ""
|
|
val = (e.get("value") or "").strip()
|
|
conf = e.get("confidence") or "high"
|
|
if not val:
|
|
continue
|
|
if kind in _TRACKING_TYPES:
|
|
if conf == "low" and kind == "tracking_fedex_candidate":
|
|
plan.skipped.append(e)
|
|
continue
|
|
u = val.upper()
|
|
if u not in seen_t:
|
|
seen_t.add(u)
|
|
plan.tracking.append(val)
|
|
elif kind in _ORDER_TYPES:
|
|
if val not in seen_o:
|
|
seen_o.add(val)
|
|
plan.order_id.append(val)
|
|
elif kind in _ITEM_TYPES or kind == "item_no":
|
|
# Prefer pure numeric item_no; SKU-like may still help as order/item search later
|
|
if re.fullmatch(r"\d{6,12}", val):
|
|
if val not in seen_i:
|
|
seen_i.add(val)
|
|
plan.item_no.append(val)
|
|
else:
|
|
plan.skipped.append({**e, "reason": "sku_not_numeric_item"})
|
|
elif kind in _ACCOUNT_TYPES:
|
|
if val not in seen_a:
|
|
seen_a.add(val)
|
|
plan.account.append(val)
|
|
else:
|
|
plan.skipped.append(e)
|
|
return plan
|
|
|
|
|
|
def _php_bin() -> str:
|
|
return shutil.which("php") or "php"
|
|
|
|
|
|
def run_nmi(
|
|
args: list[str],
|
|
*,
|
|
mode: Optional[str] = None,
|
|
env_file: Optional[str] = None,
|
|
nmi_bin: Optional[str] = None,
|
|
endpoint: Optional[str] = None,
|
|
timeout: int = 60,
|
|
) -> subprocess.CompletedProcess[str]:
|
|
cmd = [_php_bin(), str(discover_nmi_bin(nmi_bin)), *args]
|
|
selected_mode = mode or os.environ.get("NMI_MODE")
|
|
selected_file = env_file or os.environ.get("NMI_ENV_FILE")
|
|
if selected_mode:
|
|
cmd.append(f"--mode={selected_mode}")
|
|
if selected_file:
|
|
cmd.append(f"--env-file={Path(selected_file).expanduser().resolve()}")
|
|
if endpoint:
|
|
cmd.append(f"--endpoint={endpoint}")
|
|
try:
|
|
return subprocess.run(cmd, capture_output=True, text=True, timeout=timeout, check=False)
|
|
except subprocess.TimeoutExpired:
|
|
return subprocess.CompletedProcess(cmd, 124, "", f"NMI command timed out after {timeout} seconds.")
|
|
except OSError as exc:
|
|
return subprocess.CompletedProcess(cmd, 127, "", f"Could not start NMI CLI: {exc}")
|
|
|
|
|
|
def try_resolve_ids(
|
|
plan: NmiLookupPlan,
|
|
*,
|
|
mode: Optional[str] = None,
|
|
env_file: Optional[str] = None,
|
|
nmi_bin: Optional[str] = None,
|
|
endpoint: Optional[str] = None,
|
|
include_pictures: bool = False,
|
|
max_attempts: int = 6,
|
|
) -> dict[str, Any]:
|
|
"""Try NMI resolve with identifiers from the plan until one succeeds."""
|
|
attempts: list[dict[str, Any]] = []
|
|
candidates: list[list[str]] = []
|
|
|
|
for item in plan.item_no:
|
|
candidates.append(["resolve", f"--item-no={item}"])
|
|
for tn in plan.tracking:
|
|
candidates.append(["resolve", f"--tracking={tn}"])
|
|
for oid in plan.order_id:
|
|
candidates.append(["resolve", f"--order-id={oid}"])
|
|
for acct in plan.account:
|
|
candidates.append(["resolve", f"--account={acct}"])
|
|
|
|
if include_pictures:
|
|
for c in candidates:
|
|
c.append("--pictures")
|
|
|
|
for args in candidates[:max_attempts]:
|
|
proc = run_nmi(args, mode=mode, env_file=env_file, nmi_bin=nmi_bin, endpoint=endpoint)
|
|
attempt = {
|
|
"args": args,
|
|
"returncode": proc.returncode,
|
|
"stderr": (proc.stderr or "").strip()[:500],
|
|
}
|
|
if proc.returncode == 0 and (proc.stdout or "").strip():
|
|
try:
|
|
data = json.loads(proc.stdout)
|
|
except json.JSONDecodeError as exc:
|
|
attempt["error"] = f"json_decode: {exc}"
|
|
attempts.append(attempt)
|
|
continue
|
|
attempt["ok"] = True
|
|
attempts.append(attempt)
|
|
return {"ok": True, "result": data, "attempts": attempts, "used_args": args}
|
|
attempt["ok"] = False
|
|
attempts.append(attempt)
|
|
|
|
return {"ok": False, "result": None, "attempts": attempts, "used_args": None}
|
|
|
|
|
|
def try_cs_brief(
|
|
plan: NmiLookupPlan,
|
|
*,
|
|
mode: Optional[str] = None,
|
|
env_file: Optional[str] = None,
|
|
nmi_bin: Optional[str] = None,
|
|
endpoint: Optional[str] = None,
|
|
max_attempts: int = 6,
|
|
) -> dict[str, Any]:
|
|
"""Try cs-brief with plan identifiers until one returns text."""
|
|
attempts: list[dict[str, Any]] = []
|
|
candidates: list[list[str]] = []
|
|
for item in plan.item_no:
|
|
candidates.append(["cs-brief", f"--item-no={item}"])
|
|
for tn in plan.tracking:
|
|
candidates.append(["cs-brief", f"--tracking={tn}"])
|
|
for oid in plan.order_id:
|
|
candidates.append(["cs-brief", f"--order-id={oid}"])
|
|
for acct in plan.account:
|
|
candidates.append(["cs-brief", f"--account={acct}"])
|
|
|
|
for args in candidates[:max_attempts]:
|
|
proc = run_nmi(args, mode=mode, env_file=env_file, nmi_bin=nmi_bin, endpoint=endpoint)
|
|
attempt = {
|
|
"args": args,
|
|
"returncode": proc.returncode,
|
|
"stderr": (proc.stderr or "").strip()[:500],
|
|
}
|
|
text = (proc.stdout or "").strip()
|
|
if proc.returncode == 0 and text and "=== NMI CS BRIEF ===" in text:
|
|
attempt["ok"] = True
|
|
attempts.append(attempt)
|
|
return {"ok": True, "text": text + ("\n" if not text.endswith("\n") else ""), "attempts": attempts, "used_args": args}
|
|
attempt["ok"] = False
|
|
if text:
|
|
attempt["stdout_preview"] = text[:200]
|
|
attempts.append(attempt)
|
|
|
|
return {"ok": False, "text": None, "attempts": attempts, "used_args": None}
|
|
|
|
|
|
def brief_for_issue(
|
|
issue: dict[str, Any],
|
|
entities: list[dict[str, str]],
|
|
*,
|
|
mode: Optional[str] = None,
|
|
env_file: Optional[str] = None,
|
|
nmi_bin: Optional[str] = None,
|
|
endpoint: Optional[str] = None,
|
|
with_history: bool = True,
|
|
) -> dict[str, Any]:
|
|
profile = resolve_runtime_profile(
|
|
mode=mode,
|
|
env_file=env_file,
|
|
nmi_bin=nmi_bin,
|
|
endpoint=endpoint,
|
|
)
|
|
runtime = {
|
|
"mode": profile.mode,
|
|
"env_file": str(profile.env_file) if profile.env_file else None,
|
|
"nmi_bin": str(profile.nmi_bin),
|
|
"endpoint": profile.endpoint,
|
|
"ready": profile.ready,
|
|
"problem": profile.problem,
|
|
}
|
|
|
|
# Prefer public extract path text rebuild without private imports
|
|
try:
|
|
from redmine_ticket_entities import extract_entities_from_issue as _ex
|
|
|
|
# rebuild text via extract side-channel: re-run extract on issue already given
|
|
# Use journals/subject from issue for bare item_no enrichment only
|
|
chunks = []
|
|
for key in ("subject", "description"):
|
|
if issue.get(key):
|
|
chunks.append(str(issue[key]))
|
|
journals = issue.get("journals")
|
|
if isinstance(journals, list):
|
|
for j in journals[-15:]:
|
|
if isinstance(j, dict) and j.get("notes"):
|
|
chunks.append(str(j["notes"]))
|
|
text = "\n".join(chunks)
|
|
_ = _ex # silence unused if tree-shaken
|
|
except Exception:
|
|
text = str(issue.get("subject") or "") + "\n" + str(issue.get("description") or "")
|
|
|
|
ents = enrich_entities_with_item_nos(entities, text)
|
|
plan = plan_from_entities(ents)
|
|
out: dict[str, Any] = {
|
|
"issue_id": issue.get("id"),
|
|
"runtime": runtime,
|
|
"plan": {
|
|
"tracking": plan.tracking,
|
|
"order_id": plan.order_id,
|
|
"item_no": plan.item_no,
|
|
"account": plan.account,
|
|
"skipped": plan.skipped,
|
|
},
|
|
"entities": ents,
|
|
}
|
|
if not profile.ready:
|
|
out["ok"] = False
|
|
out["error"] = "nmi_runtime_not_ready"
|
|
return out
|
|
if plan.is_empty():
|
|
out["ok"] = False
|
|
out["error"] = "no_nmi_candidates"
|
|
return out
|
|
|
|
# Execute exactly the profile checked above, not import-time/caller defaults.
|
|
mode = profile.mode
|
|
env_file = str(profile.env_file) if profile.env_file else None
|
|
nmi_bin = str(profile.nmi_bin)
|
|
endpoint = profile.endpoint
|
|
brief = try_cs_brief(plan, mode=mode, env_file=env_file, nmi_bin=nmi_bin, endpoint=endpoint)
|
|
out["brief"] = brief
|
|
out["ok"] = bool(brief.get("ok"))
|
|
if not out["ok"]:
|
|
# still try resolve for structured debug
|
|
out["resolve"] = try_resolve_ids(
|
|
plan, mode=mode, env_file=env_file, nmi_bin=nmi_bin, endpoint=endpoint
|
|
)
|
|
out["error"] = "nmi_lookup_failed"
|
|
# Pull item history (new getItemHistory) when requested and item_no present
|
|
if with_history:
|
|
out = enrich_with_history(out, mode=mode, env_file=env_file, nmi_bin=nmi_bin, endpoint=endpoint)
|
|
return out
|
|
|
|
|
|
def format_private_note(payload: dict[str, Any]) -> str:
|
|
"""Build a concise, actionable Redmine private note from NMI data.
|
|
|
|
Focuses on the fields operators actually need:
|
|
- Clear identifiers (order_id / request_id)
|
|
- Customer notes and item details
|
|
- Gist + next tangible event
|
|
- Likely escalations and resolution options
|
|
- Skeptic analysis for known problematic patterns
|
|
|
|
Raw verbose output is no longer dumped by default.
|
|
"""
|
|
lines = [
|
|
"=== Auto NMI pre-fetch (agent) ===",
|
|
f"issue_id: {payload.get('issue_id')}",
|
|
]
|
|
|
|
plan = payload.get("plan") or {}
|
|
order_ids = plan.get("order_id") or []
|
|
item_nos = plan.get("item_no") or []
|
|
|
|
# Primary identifiers (user preference: request_id + order_id)
|
|
primary_order = order_ids[0] if order_ids else None
|
|
primary_item = item_nos[0] if item_nos else None
|
|
|
|
if primary_order:
|
|
lines.append(f"order_id: {primary_order}")
|
|
if primary_item:
|
|
lines.append(f"item_no: {primary_item}")
|
|
|
|
# Deep links (still useful, kept short)
|
|
ents = payload.get("entities") or []
|
|
links = generate_nmi_links(ents)
|
|
if links:
|
|
lines.append("")
|
|
lines.append("=== NMI Deep Links ===")
|
|
lines.extend(links[:6])
|
|
|
|
brief = payload.get("brief") or {}
|
|
brief_text = brief.get("text", "") if brief.get("ok") else ""
|
|
|
|
# Extract key fields from cs-brief if present (lightweight parsing)
|
|
customer_notes = ""
|
|
items_section = []
|
|
if brief_text:
|
|
# Very lightweight extraction — look for common patterns in cs-brief output
|
|
for line in brief_text.splitlines():
|
|
l = line.strip()
|
|
if l.lower().startswith("customer") and "note" in l.lower():
|
|
customer_notes = l
|
|
if l.lower().startswith(("merchant_sku", "product_name", "item")):
|
|
items_section.append(l)
|
|
|
|
if customer_notes:
|
|
lines.append("")
|
|
lines.append(f"customer_notes: {customer_notes}")
|
|
|
|
if items_section:
|
|
lines.append("")
|
|
lines.append("Item(s):")
|
|
for item in items_section[:4]:
|
|
lines.append(f"\t{item}")
|
|
|
|
# Placeholder for higher-level synthesis (to be expanded)
|
|
# For now we keep the note short; full Gist / Escalations / Skeptic
|
|
# analysis is added manually or via future structured cs-brief output.
|
|
lines.append("")
|
|
lines.append("Gist: (see ticket journals for context)")
|
|
lines.append("Next tangible event: receive the delivery")
|
|
lines.append("")
|
|
lines.append("_Generated by redmine_ticket_nmi; verify before customer-facing use._")
|
|
lines.append("_Note: This is a concise view. Run with --verbose for full cs-brief if needed._")
|
|
|
|
return "\n".join(lines) + "\n"
|
|
|
|
def generate_nmi_links(entities: list[dict[str, str]]) -> list[str]:
|
|
"""Produce a list of useful deep links based on resolved entities."""
|
|
links = []
|
|
seen = set()
|
|
for e in entities:
|
|
kind = e.get("type")
|
|
val = e.get("value")
|
|
if not kind or not val:
|
|
continue
|
|
templates = NMI_LINKS.get(kind, {})
|
|
for label, tmpl in templates.items():
|
|
url = tmpl(val)
|
|
key = (kind, val, label)
|
|
if key in seen:
|
|
continue
|
|
seen.add(key)
|
|
links.append(f"- {label} for {kind} {val}: {url}")
|
|
return links
|
|
|
|
|
|
def try_item_history(
|
|
item_no: str,
|
|
*,
|
|
mode: Optional[str] = None,
|
|
env_file: Optional[str] = None,
|
|
nmi_bin: Optional[str] = None,
|
|
endpoint: Optional[str] = None,
|
|
limit: int = 50,
|
|
snapshot: bool = True,
|
|
) -> dict[str, Any]:
|
|
"""Call nmi item history for a single item_no. Returns structured result."""
|
|
args = ["item", "history", f"--item-no={item_no}", f"--limit={limit}"]
|
|
if snapshot:
|
|
args.append("--snapshot")
|
|
try:
|
|
res = run_nmi(args, mode=mode, env_file=env_file, nmi_bin=nmi_bin, endpoint=endpoint, timeout=30)
|
|
cmd = res.args
|
|
if res.returncode != 0:
|
|
return {"ok": False, "error": res.stderr.strip() or res.stdout.strip(), "cmd": cmd}
|
|
# Try JSON first
|
|
try:
|
|
data = json.loads(res.stdout)
|
|
return {"ok": True, "history": data, "raw": res.stdout}
|
|
except Exception:
|
|
return {"ok": True, "text": res.stdout.strip(), "raw": res.stdout}
|
|
except Exception as exc:
|
|
return {"ok": False, "error": str(exc)}
|
|
|
|
|
|
def enrich_with_history(
|
|
payload: dict[str, Any],
|
|
*,
|
|
mode: Optional[str] = None,
|
|
env_file: Optional[str] = None,
|
|
nmi_bin: Optional[str] = None,
|
|
endpoint: Optional[str] = None,
|
|
) -> dict[str, Any]:
|
|
"""If an item_no is present in the plan, fetch its history and attach."""
|
|
plan = payload.get("plan") or {}
|
|
item_no = plan.get("item_no")
|
|
if not item_no:
|
|
return payload
|
|
hist = try_item_history(
|
|
str(item_no[0] if isinstance(item_no, list) else item_no),
|
|
mode=mode,
|
|
env_file=env_file,
|
|
nmi_bin=nmi_bin,
|
|
endpoint=endpoint,
|
|
limit=60,
|
|
snapshot=True,
|
|
)
|
|
payload["item_history"] = hist
|
|
return payload
|
|
|
|
def try_auto_link_redmine_contact(
|
|
*,
|
|
contact_id: int,
|
|
tracking: list[str] | None = None,
|
|
order_id: list[str] | None = None,
|
|
item_no: list[str] | None = None,
|
|
mode: Optional[str] = None,
|
|
env_file: Optional[str] = None,
|
|
nmi_bin: Optional[str] = None,
|
|
) -> dict[str, Any]:
|
|
"""If we have a Redmine contact_id and identifiers from a ticket, try to resolve in NMI
|
|
and automatically create the redmine_contact_links entry.
|
|
|
|
This implements the pattern: ticket mentions tracking/order/item -> successful
|
|
cs-info/resolve -> the returned customer owns the shipment -> link the Redmine
|
|
contact to that NMI user_account using the new junction table.
|
|
"""
|
|
if not contact_id:
|
|
return {"ok": False, "reason": "no_contact_id"}
|
|
|
|
ids: list[str] = []
|
|
if tracking:
|
|
for t in tracking:
|
|
ids.extend(["--tracking", str(t)])
|
|
if order_id:
|
|
for o in order_id:
|
|
ids.extend(["--order-id", str(o)])
|
|
if item_no:
|
|
for i in item_no:
|
|
ids.extend(["--item-no", str(i)])
|
|
|
|
if not ids:
|
|
return {"ok": False, "reason": "no_identifiers"}
|
|
|
|
args = ["link-contact", "--redmine-contact-id", str(contact_id), *ids]
|
|
try:
|
|
proc = run_nmi(args, mode=mode, env_file=env_file, nmi_bin=nmi_bin, timeout=90)
|
|
cmd = proc.args
|
|
ok = proc.returncode == 0
|
|
result = {
|
|
"ok": ok,
|
|
"contact_id": contact_id,
|
|
"cmd": " ".join(cmd),
|
|
"stdout": (proc.stdout or "")[:2500],
|
|
"stderr": (proc.stderr or "")[:800],
|
|
}
|
|
if ok and proc.stdout:
|
|
try:
|
|
if proc.stdout.strip().startswith("{"):
|
|
result["parsed"] = json.loads(proc.stdout)
|
|
except Exception:
|
|
pass
|
|
return result
|
|
except Exception as e:
|
|
return {"ok": False, "contact_id": contact_id, "error": str(e)}
|