LZH-YS1998
523 lines
26 KiB
Python
523 lines
26 KiB
Python
"""Company work-item read service."""
|
|
|
|
from __future__ import annotations
|
|
|
|
from collections import Counter, defaultdict
|
|
from typing import Any
|
|
|
|
from opc.layer2_organization.phase import coerce_phase, kanban_column, should_hide_work_item_from_company_kanban
|
|
from opc.layer2_organization.work_item_links import task_by_linked_work_item_id
|
|
|
|
from .context import OfficeServiceContext
|
|
from .models import ServiceError, ServiceResult
|
|
|
|
|
|
class WorkItemService:
|
|
def __init__(self, context: OfficeServiceContext) -> None:
|
|
self.context = context
|
|
|
|
async def list(
|
|
self,
|
|
*,
|
|
project_id: str,
|
|
session_id: str | None = None,
|
|
role_id: str | None = None,
|
|
status: str | None = None,
|
|
limit: int = 100,
|
|
kanban_visible_only: bool = False,
|
|
) -> ServiceResult:
|
|
session_id = str(session_id or "").strip()
|
|
engine = await self.context.engine_for_project(project_id)
|
|
store = getattr(engine, "store", None)
|
|
if not self.context.store_is_ready(store):
|
|
raise ServiceError("store_not_ready", "store_not_ready", {"project_id": project_id})
|
|
runs = await self._runs(store, project_id, session_id=session_id or None)
|
|
tasks = await store.get_tasks(project_id=project_id) if hasattr(store, "get_tasks") else []
|
|
hydrate = getattr(store, "hydrate_task_work_item_links", None)
|
|
if callable(hydrate):
|
|
await hydrate(tasks)
|
|
linked_tasks = task_by_linked_work_item_id(tasks)
|
|
|
|
rows: list[dict[str, Any]] = []
|
|
for run in runs:
|
|
run_id = str(getattr(run, "run_id", "") or "")
|
|
if not run_id:
|
|
continue
|
|
for item in await store.list_delegation_work_items(run_id):
|
|
linked_task = linked_tasks.get(str(getattr(item, "work_item_id", "") or ""))
|
|
if session_id and not self._matches_session_scope(session_id, run=run, item=item, linked_task=linked_task):
|
|
continue
|
|
if kanban_visible_only and not self._is_company_kanban_visible(item):
|
|
continue
|
|
payload = self._work_item_payload(item, run=run, linked_task=linked_task)
|
|
if role_id and payload.get("role_id") != role_id:
|
|
continue
|
|
if status and payload.get("phase") != status and payload.get("kanban_column") != status:
|
|
continue
|
|
rows.append(payload)
|
|
rows.sort(key=lambda item: str(item.get("updated_at", "")), reverse=True)
|
|
return ServiceResult({
|
|
"project_id": project_id,
|
|
"session_id": session_id,
|
|
"work_items": rows[: max(1, int(limit or 100))],
|
|
})
|
|
|
|
async def show(self, *, project_id: str, work_item_id: str, limit: int = 100) -> ServiceResult:
|
|
engine = await self.context.engine_for_project(project_id)
|
|
store = getattr(engine, "store", None)
|
|
if not self.context.store_is_ready(store):
|
|
raise ServiceError("store_not_ready", "store_not_ready", {"project_id": project_id})
|
|
runs = await self._runs(store, project_id)
|
|
tasks = await store.get_tasks(project_id=project_id) if hasattr(store, "get_tasks") else []
|
|
hydrate = getattr(store, "hydrate_task_work_item_links", None)
|
|
if callable(hydrate):
|
|
await hydrate(tasks)
|
|
linked_tasks = task_by_linked_work_item_id(tasks)
|
|
target = None
|
|
target_run = None
|
|
for run in runs:
|
|
run_id = str(getattr(run, "run_id", "") or "")
|
|
for item in await store.list_delegation_work_items(run_id):
|
|
if str(getattr(item, "work_item_id", "") or "") == work_item_id:
|
|
target = item
|
|
target_run = run
|
|
break
|
|
if target is not None:
|
|
break
|
|
if target is None:
|
|
raise ServiceError("work_item_not_found", "Work item not found", {"work_item_id": work_item_id})
|
|
linked_task = linked_tasks.get(work_item_id)
|
|
logs = await self.logs(project_id=project_id, work_item_id=work_item_id, limit=limit)
|
|
return ServiceResult({
|
|
"project_id": project_id,
|
|
"work_item": self._work_item_payload(target, run=target_run, linked_task=linked_task),
|
|
"logs": logs.payload,
|
|
})
|
|
|
|
async def logs(
|
|
self,
|
|
*,
|
|
project_id: str,
|
|
session_id: str | None = None,
|
|
work_item_id: str = "",
|
|
role_id: str = "",
|
|
limit: int = 100,
|
|
) -> ServiceResult:
|
|
session_id = str(session_id or "").strip()
|
|
work_item_id = str(work_item_id or "").strip()
|
|
role_id = str(role_id or "").strip()
|
|
engine = await self.context.engine_for_project(project_id)
|
|
store = getattr(engine, "store", None)
|
|
if not self.context.store_is_ready(store):
|
|
raise ServiceError("store_not_ready", "store_not_ready", {"project_id": project_id})
|
|
runs = await self._runs(store, project_id, session_id=session_id or None)
|
|
tasks = await store.get_tasks(project_id=project_id) if hasattr(store, "get_tasks") else []
|
|
hydrate = getattr(store, "hydrate_task_work_item_links", None)
|
|
if callable(hydrate):
|
|
await hydrate(tasks)
|
|
linked_tasks = task_by_linked_work_item_id(tasks)
|
|
|
|
target_items: list[tuple[Any, Any, Any | None]] = []
|
|
target_work_item_ids: set[str] = set()
|
|
for run in runs:
|
|
run_id = str(getattr(run, "run_id", "") or "")
|
|
if not run_id:
|
|
continue
|
|
for item in await store.list_delegation_work_items(run_id):
|
|
item_id = str(getattr(item, "work_item_id", "") or "")
|
|
if work_item_id and item_id != work_item_id:
|
|
continue
|
|
if role_id and str(getattr(item, "role_id", "") or "") != role_id:
|
|
continue
|
|
linked_task = linked_tasks.get(item_id)
|
|
target_items.append((item, run, linked_task))
|
|
if item_id:
|
|
target_work_item_ids.add(item_id)
|
|
|
|
events: list[dict[str, Any]] = []
|
|
target_run_ids = {str(getattr(run, "run_id", "") or "") for run in runs}
|
|
for run_id in target_run_ids:
|
|
if hasattr(store, "list_delegation_events"):
|
|
for event in await store.list_delegation_events(run_id):
|
|
event_work_item_id = str(getattr(event, "work_item_id", "") or "")
|
|
event_role_id = str(getattr(event, "role_id", "") or "")
|
|
if work_item_id and event_work_item_id != work_item_id:
|
|
continue
|
|
if role_id and event_role_id != role_id and event_work_item_id not in target_work_item_ids:
|
|
continue
|
|
events.append(self._event_payload(event))
|
|
|
|
runtime_sessions: list[dict[str, Any]] = []
|
|
external_sessions: list[dict[str, Any]] = []
|
|
runtime_events: list[dict[str, Any]] = []
|
|
runtime_transcript_entries: list[dict[str, Any]] = []
|
|
runtime_tool_calls: list[dict[str, Any]] = []
|
|
runtime_tool_results: list[dict[str, Any]] = []
|
|
runtime_permission_grants: list[dict[str, Any]] = []
|
|
transcript: list[Any] = []
|
|
handoffs: list[Any] = []
|
|
|
|
runtime_rows_by_id: dict[str, dict[str, Any]] = {}
|
|
runtime_ids: set[str] = set()
|
|
external_keys: set[tuple[str, str, str]] = set()
|
|
|
|
def add_runtime_row(row: Any) -> None:
|
|
payload = self._model_payload(row)
|
|
runtime_id = str(payload.get("runtime_session_id", "") or "").strip()
|
|
if not runtime_id:
|
|
return
|
|
runtime_rows_by_id[runtime_id] = payload
|
|
runtime_ids.add(runtime_id)
|
|
|
|
def add_runtime_id(runtime_id: Any, *, task: Any = None, role_session: Any = None, source: str = "") -> None:
|
|
runtime_id = str(runtime_id or "").strip()
|
|
if not runtime_id:
|
|
return
|
|
runtime_ids.add(runtime_id)
|
|
if runtime_id in runtime_rows_by_id:
|
|
return
|
|
metadata = {"source": source} if source else {}
|
|
if role_session is not None:
|
|
metadata.update({"source": source or "role_runtime_session", "role_id": str(getattr(role_session, "role_id", "") or "")})
|
|
runtime_rows_by_id[runtime_id] = {
|
|
"runtime_session_id": runtime_id,
|
|
"project_id": project_id,
|
|
"session_id": str(getattr(task, "session_id", "") or session_id or ""),
|
|
"task_id": str(getattr(task, "id", "") or ""),
|
|
"status": str(getattr(role_session, "status", "") or ""),
|
|
"metadata": metadata,
|
|
"created_at": self._date_value(getattr(role_session, "created_at", None)),
|
|
"updated_at": self._date_value(getattr(role_session, "updated_at", None)),
|
|
}
|
|
|
|
def add_external_session(row: Any) -> None:
|
|
payload = self._model_payload(row)
|
|
key = (
|
|
str(payload.get("agent_type", "") or ""),
|
|
str(payload.get("session_id", "") or ""),
|
|
str(payload.get("task_id", "") or ""),
|
|
)
|
|
if key in external_keys:
|
|
return
|
|
external_keys.add(key)
|
|
external_sessions.append(payload)
|
|
metadata = dict(payload.get("metadata", {}) or {})
|
|
add_runtime_id(metadata.get("runtime_session_id"), source="external_session")
|
|
add_runtime_id(metadata.get("delegation_role_session_id"), source="external_role_session")
|
|
add_runtime_id(payload.get("opc_session_id"), source="external_opc_session")
|
|
|
|
for item, run, linked_task in target_items:
|
|
item_id = str(getattr(item, "work_item_id", "") or "")
|
|
if linked_task is not None:
|
|
linked_session_id = str(getattr(linked_task, "session_id", "") or "")
|
|
if linked_session_id and hasattr(store, "get_session_transcript"):
|
|
transcript.extend((await store.get_session_transcript(linked_session_id))[-limit:])
|
|
if hasattr(store, "list_runtime_sessions"):
|
|
for row in await store.list_runtime_sessions(project_id=project_id, task_id=getattr(linked_task, "id", ""), limit=limit):
|
|
add_runtime_row(row)
|
|
if linked_session_id:
|
|
for row in await store.list_runtime_sessions(project_id=project_id, session_id=linked_session_id, limit=limit):
|
|
add_runtime_row(row)
|
|
if hasattr(store, "list_external_sessions"):
|
|
for row in await store.list_external_sessions(project_id=project_id, task_id=getattr(linked_task, "id", ""), limit=limit):
|
|
add_external_session(row)
|
|
for runtime_id in self._task_runtime_session_ids(linked_task):
|
|
add_runtime_id(runtime_id, task=linked_task, source="task_metadata")
|
|
for runtime_id in self._work_item_runtime_session_ids(item):
|
|
add_runtime_id(runtime_id, task=linked_task, source="work_item")
|
|
if hasattr(store, "get_handoff_records") and item_id:
|
|
handoffs.extend(await store.get_handoff_records(project_id=project_id, target_work_item_id=item_id, limit=limit))
|
|
|
|
if hasattr(store, "list_role_runtime_sessions"):
|
|
for run in runs:
|
|
run_id = str(getattr(run, "run_id", "") or "")
|
|
if not run_id:
|
|
continue
|
|
try:
|
|
role_sessions = await store.list_role_runtime_sessions(run_id, role_id=role_id or None)
|
|
except TypeError:
|
|
role_sessions = await store.list_role_runtime_sessions(run_id)
|
|
if role_id:
|
|
role_sessions = [item for item in role_sessions if str(getattr(item, "role_id", "") or "") == role_id]
|
|
for role_session in role_sessions:
|
|
role_session_id = str(getattr(role_session, "role_session_id", "") or "")
|
|
focused = str(getattr(role_session, "focused_work_item_id", "") or "")
|
|
related = {focused}
|
|
related.update(str(item or "").strip() for item in list(getattr(role_session, "background_work_item_ids", []) or []))
|
|
related.update(str(item or "").strip() for item in list(getattr(role_session, "pending_work_item_ids", []) or []))
|
|
if work_item_id and work_item_id not in related:
|
|
continue
|
|
add_runtime_id(role_session_id, role_session=role_session, source="role_runtime_session")
|
|
if hasattr(store, "list_external_sessions") and role_session_id:
|
|
for row in await store.list_external_sessions(project_id=project_id, opc_session_id=role_session_id, limit=limit):
|
|
add_external_session(row)
|
|
|
|
for runtime_id in sorted(runtime_ids):
|
|
if hasattr(store, "list_runtime_events"):
|
|
runtime_events.extend(await store.list_runtime_events(runtime_id, limit=limit))
|
|
if hasattr(store, "list_runtime_transcript_entries"):
|
|
runtime_transcript_entries.extend((await store.list_runtime_transcript_entries(runtime_id))[-limit:])
|
|
if hasattr(store, "list_runtime_tool_calls"):
|
|
runtime_tool_calls.extend((await store.list_runtime_tool_calls(runtime_id))[-limit:])
|
|
if hasattr(store, "list_runtime_tool_results"):
|
|
runtime_tool_results.extend((await store.list_runtime_tool_results(runtime_id))[-limit:])
|
|
if hasattr(store, "list_runtime_permission_grants"):
|
|
runtime_permission_grants.extend((await store.list_runtime_permission_grants(runtime_session_id=runtime_id))[-limit:])
|
|
|
|
events.sort(key=lambda item: str(item.get("created_at", "")))
|
|
runtime_sessions = list(runtime_rows_by_id.values())
|
|
runtime_sessions.sort(key=lambda item: str(item.get("updated_at", "")), reverse=True)
|
|
return ServiceResult({
|
|
"project_id": project_id,
|
|
"session_id": session_id,
|
|
"work_item_id": work_item_id,
|
|
"role_id": role_id,
|
|
"work_items": [
|
|
self._work_item_payload(item, run=run, linked_task=linked_task)
|
|
for item, run, linked_task in target_items
|
|
][:limit],
|
|
"events": events[-limit:],
|
|
"runtime_sessions": runtime_sessions[:limit],
|
|
"external_sessions": external_sessions[-limit:],
|
|
"runtime_events": runtime_events[-limit:],
|
|
"runtime_transcript_entries": runtime_transcript_entries[-limit:],
|
|
"runtime_tool_calls": runtime_tool_calls[-limit:],
|
|
"runtime_tool_results": runtime_tool_results[-limit:],
|
|
"runtime_permission_grants": runtime_permission_grants[-limit:],
|
|
"transcript": transcript,
|
|
"handoffs": [self._model_payload(item) for item in handoffs],
|
|
})
|
|
|
|
async def status_by_role(self, *, project_id: str, session_id: str | None = None) -> ServiceResult:
|
|
listing = await self.list(project_id=project_id, session_id=session_id, limit=10000)
|
|
by_role: dict[str, Counter[str]] = defaultdict(Counter)
|
|
for item in listing.payload.get("work_items", []):
|
|
role_id = str(item.get("role_id") or "unassigned")
|
|
by_role[role_id][str(item.get("kanban_column") or item.get("phase") or "unknown")] += 1
|
|
return ServiceResult({
|
|
"project_id": project_id,
|
|
"session_id": str(session_id or "").strip(),
|
|
"roles": [
|
|
{"role_id": role_id, "counts": dict(counts), "total": sum(counts.values())}
|
|
for role_id, counts in sorted(by_role.items())
|
|
],
|
|
})
|
|
|
|
async def role_detail(self, *, project_id: str, role_id: str, limit: int = 100) -> ServiceResult:
|
|
role_id = str(role_id or "").strip()
|
|
if not role_id:
|
|
raise ServiceError("role_id_required", "role_id required")
|
|
listing = await self.list(project_id=project_id, role_id=role_id, limit=limit)
|
|
logs = await self.logs(project_id=project_id, role_id=role_id, limit=limit)
|
|
counts: Counter[str] = Counter()
|
|
for item in listing.payload.get("work_items", []):
|
|
counts[str(item.get("kanban_column") or item.get("phase") or "unknown")] += 1
|
|
return ServiceResult({
|
|
"project_id": project_id,
|
|
"role_id": role_id,
|
|
"counts": dict(counts),
|
|
"work_items": listing.payload.get("work_items", []),
|
|
"logs": logs.payload,
|
|
})
|
|
|
|
async def _runs(self, store: Any, project_id: str, *, session_id: str | None = None) -> list[Any]:
|
|
session_id = str(session_id or "").strip()
|
|
if hasattr(store, "list_open_delegation_runs"):
|
|
runs = await store.list_open_delegation_runs(project_id=project_id)
|
|
if session_id:
|
|
matched = [run for run in runs if self._session_id_matches(session_id, getattr(run, "session_id", ""))]
|
|
if matched:
|
|
return list(matched)
|
|
elif runs:
|
|
return list(runs)
|
|
if hasattr(store, "list_delegation_runs"):
|
|
if session_id:
|
|
for candidate_session_id in self._session_scope_candidates(session_id):
|
|
try:
|
|
runs = await store.list_delegation_runs(project_id=project_id, session_id=candidate_session_id)
|
|
except TypeError:
|
|
break
|
|
if runs:
|
|
return list(runs)
|
|
runs = list(await store.list_delegation_runs(project_id=project_id))
|
|
if session_id:
|
|
return [run for run in runs if self._session_id_matches(session_id, getattr(run, "session_id", ""))]
|
|
return runs
|
|
return []
|
|
|
|
@staticmethod
|
|
def _is_company_kanban_visible(item: Any) -> bool:
|
|
metadata = dict(getattr(item, "metadata", {}) or {})
|
|
return bool(
|
|
str(getattr(item, "parent_work_item_id", "") or "").strip()
|
|
and not bool(metadata.get("attention_work_item", False))
|
|
and not should_hide_work_item_from_company_kanban(metadata)
|
|
)
|
|
|
|
@classmethod
|
|
def _matches_session_scope(cls, session_id: str, *, run: Any = None, item: Any = None, linked_task: Any = None) -> bool:
|
|
session_id = str(session_id or "").strip()
|
|
if not session_id:
|
|
return True
|
|
for candidate in cls._session_candidates(run=run, item=item, linked_task=linked_task):
|
|
if cls._session_id_matches(session_id, candidate):
|
|
return True
|
|
return False
|
|
|
|
@staticmethod
|
|
def _session_scope_candidates(session_id: str) -> list[str]:
|
|
session_id = str(session_id or "").strip()
|
|
if not session_id:
|
|
return []
|
|
candidates = [session_id]
|
|
if ":" in session_id:
|
|
candidates.append(session_id.split(":", 1)[0])
|
|
return list(dict.fromkeys(candidates))
|
|
|
|
@classmethod
|
|
def _session_candidates(cls, *, run: Any = None, item: Any = None, linked_task: Any = None) -> list[str]:
|
|
values: list[str] = []
|
|
|
|
def add(value: Any) -> None:
|
|
text = str(value or "").strip()
|
|
if text:
|
|
values.append(text)
|
|
|
|
def add_from_mapping(mapping: Any) -> None:
|
|
if not isinstance(mapping, dict):
|
|
return
|
|
for key in (
|
|
"session_id",
|
|
"parent_session_id",
|
|
"root_session_id",
|
|
"origin_session_id",
|
|
"opc_session_id",
|
|
"company_runtime_root_session_id",
|
|
):
|
|
add(mapping.get(key))
|
|
|
|
if run is not None:
|
|
add(getattr(run, "session_id", ""))
|
|
add_from_mapping(getattr(run, "metadata", {}) or {})
|
|
add_from_mapping(getattr(run, "recovery_pointer", {}) or {})
|
|
if item is not None:
|
|
add_from_mapping(getattr(item, "metadata", {}) or {})
|
|
if linked_task is not None:
|
|
add(getattr(linked_task, "session_id", ""))
|
|
add(getattr(linked_task, "parent_session_id", ""))
|
|
add_from_mapping(getattr(linked_task, "metadata", {}) or {})
|
|
return list(dict.fromkeys(values))
|
|
|
|
@staticmethod
|
|
def _session_id_matches(scope_session_id: str, candidate_session_id: Any) -> bool:
|
|
scope = str(scope_session_id or "").strip()
|
|
candidate = str(candidate_session_id or "").strip()
|
|
if not scope or not candidate:
|
|
return False
|
|
return (
|
|
scope == candidate
|
|
or candidate.startswith(f"{scope}:")
|
|
or scope.startswith(f"{candidate}:")
|
|
)
|
|
|
|
@classmethod
|
|
def _task_runtime_session_ids(cls, task: Any) -> list[str]:
|
|
metadata = dict(getattr(task, "metadata", {}) or {})
|
|
context_snapshot = dict(getattr(task, "context_snapshot", {}) or {})
|
|
values = [
|
|
(metadata.get("runtime_v2", {}) or {}).get("runtime_session_id") if isinstance(metadata.get("runtime_v2"), dict) else "",
|
|
(context_snapshot.get("runtime_resume", {}) or {}).get("runtime_session_id") if isinstance(context_snapshot.get("runtime_resume"), dict) else "",
|
|
metadata.get("_permission_bridge_runtime_session_id"),
|
|
metadata.get("delegation_role_session_id"),
|
|
metadata.get("assigned_role_runtime_id"),
|
|
metadata.get("role_runtime_session_id"),
|
|
metadata.get("runtime_session_id"),
|
|
]
|
|
return cls._dedupe_text(values)
|
|
|
|
@classmethod
|
|
def _work_item_runtime_session_ids(cls, item: Any) -> list[str]:
|
|
metadata = dict(getattr(item, "metadata", {}) or {})
|
|
values = [
|
|
getattr(item, "role_runtime_session_id", ""),
|
|
getattr(item, "claimed_by_role_runtime_session_id", ""),
|
|
metadata.get("assigned_role_runtime_id"),
|
|
metadata.get("role_runtime_session_id"),
|
|
metadata.get("claimed_by_role_runtime_session_id"),
|
|
metadata.get("delegation_role_session_id"),
|
|
metadata.get("runtime_session_id"),
|
|
]
|
|
return cls._dedupe_text(values)
|
|
|
|
@staticmethod
|
|
def _dedupe_text(values: list[Any]) -> list[str]:
|
|
result: list[str] = []
|
|
seen: set[str] = set()
|
|
for value in values:
|
|
text = str(value or "").strip()
|
|
if not text or text in seen:
|
|
continue
|
|
seen.add(text)
|
|
result.append(text)
|
|
return result
|
|
|
|
def _work_item_payload(self, item: Any, *, run: Any = None, linked_task: Any = None) -> dict[str, Any]:
|
|
phase = coerce_phase(getattr(item, "phase", ""))
|
|
phase_value = phase.value if hasattr(phase, "value") else str(phase or "")
|
|
return {
|
|
"work_item_id": str(getattr(item, "work_item_id", "") or ""),
|
|
"run_id": str(getattr(item, "run_id", "") or ""),
|
|
"project_id": str(getattr(run, "project_id", "") or ""),
|
|
"title": str(getattr(item, "title", "") or ""),
|
|
"summary": str(getattr(item, "summary", "") or ""),
|
|
"role_id": str(getattr(item, "role_id", "") or ""),
|
|
"seat_id": str(getattr(item, "seat_id", "") or ""),
|
|
"manager_role_id": str(getattr(item, "manager_role_id", "") or ""),
|
|
"parent_work_item_id": str(getattr(item, "parent_work_item_id", "") or ""),
|
|
"role_runtime_session_id": str(getattr(item, "role_runtime_session_id", "") or ""),
|
|
"claimed_by_role_runtime_session_id": str(getattr(item, "claimed_by_role_runtime_session_id", "") or ""),
|
|
"phase": phase_value,
|
|
"kanban_column": kanban_column(phase),
|
|
"deliverable_summary": str(getattr(item, "deliverable_summary", "") or ""),
|
|
"blocked_reason": str(getattr(item, "blocked_reason", "") or ""),
|
|
"handoff_status": str(getattr(item, "handoff_status", "") or ""),
|
|
"metadata": dict(getattr(item, "metadata", {}) or {}),
|
|
"runtime_task_id": str(getattr(linked_task, "id", "") or "") if linked_task is not None else "",
|
|
"session_id": str(getattr(linked_task, "session_id", "") or "") if linked_task is not None else "",
|
|
"runtime_status": (
|
|
getattr(getattr(linked_task, "status", None), "value", getattr(linked_task, "status", ""))
|
|
if linked_task is not None else ""
|
|
),
|
|
"created_at": self._date_value(getattr(item, "created_at", None)),
|
|
"updated_at": self._date_value(getattr(item, "updated_at", None)),
|
|
}
|
|
|
|
@staticmethod
|
|
def _event_payload(event: Any) -> dict[str, Any]:
|
|
return {
|
|
"event_id": str(getattr(event, "event_id", "") or ""),
|
|
"run_id": str(getattr(event, "run_id", "") or ""),
|
|
"work_item_id": str(getattr(event, "work_item_id", "") or ""),
|
|
"cell_id": str(getattr(event, "cell_id", "") or ""),
|
|
"role_id": str(getattr(event, "role_id", "") or ""),
|
|
"event_type": str(getattr(event, "event_type", "") or ""),
|
|
"payload": dict(getattr(event, "payload", {}) or {}),
|
|
"created_at": WorkItemService._date_value(getattr(event, "created_at", None)),
|
|
}
|
|
|
|
@staticmethod
|
|
def _model_payload(value: Any) -> dict[str, Any]:
|
|
if hasattr(value, "model_dump"):
|
|
return value.model_dump()
|
|
if hasattr(value, "__dict__"):
|
|
return dict(value.__dict__)
|
|
if isinstance(value, dict):
|
|
return dict(value)
|
|
return {"value": value}
|
|
|
|
@staticmethod
|
|
def _date_value(value: Any) -> Any:
|
|
if hasattr(value, "isoformat"):
|
|
return value.isoformat()
|
|
return value
|