252 lines
8.8 KiB
Python
252 lines
8.8 KiB
Python
"""Business rules and orchestration for repair workflows."""
|
|
|
|
from uuid import UUID
|
|
|
|
from app.repairs.exceptions import (
|
|
ActiveRepairConflict,
|
|
IncompatibleMinerLifecycle,
|
|
InconsistentRepairState,
|
|
RepairActiveMismatch,
|
|
RepairActorRequired,
|
|
RepairCompletionActorRequired,
|
|
RepairMinerNotFound,
|
|
RepairMinerNotInRepair,
|
|
RepairNotActive,
|
|
RepairNotFound,
|
|
RepairPersistenceError,
|
|
)
|
|
from app.repairs.models import (
|
|
BeginRepairRequest,
|
|
BeginRepairResult,
|
|
InitialRepairNotePayload,
|
|
RepairActor,
|
|
RepairCompleteRequest,
|
|
RepairCompletedPayload,
|
|
RepairDetail,
|
|
RepairTimeline,
|
|
RepairTimelineEvent,
|
|
RepairStartedPayload,
|
|
)
|
|
from app.repairs.repository import RepairRepository
|
|
|
|
|
|
ELIGIBLE_LIFECYCLE_STATUSES = frozenset({"active", "spare"})
|
|
ACTIVE_REPAIR_STATUSES = frozenset(
|
|
{"OPEN", "IN_PROGRESS", "WAITING_FOR_PARTS", "READY_FOR_TEST"}
|
|
)
|
|
REPAIR_LIFECYCLE_STATUS = "in_repair"
|
|
|
|
|
|
class RepairService:
|
|
"""Explicit operational repair workflows independent of FastAPI."""
|
|
|
|
def __init__(self, repository: RepairRepository):
|
|
self.repository = repository
|
|
|
|
@staticmethod
|
|
def normalize_note(note: str | None) -> str | None:
|
|
if note is None:
|
|
return None
|
|
normalized = str(note).strip()
|
|
return normalized or None
|
|
|
|
@staticmethod
|
|
def _map_repair_detail(repair: dict) -> RepairDetail:
|
|
closed_by = None
|
|
if repair["closed_by_user_id"] is not None:
|
|
closed_by = RepairActor(
|
|
user_id=repair["closed_by_user_id"],
|
|
display_name=repair["closed_by_display_name"],
|
|
)
|
|
|
|
return RepairDetail(
|
|
repair_id=repair["repair_id"],
|
|
miner_id=repair["miner_id"],
|
|
miner_asset_id=repair["miner_asset_id"],
|
|
status=repair["status"],
|
|
reason=repair["reason"],
|
|
opened_at=repair["opened_at"],
|
|
opened_by=RepairActor(
|
|
user_id=repair["opened_by_user_id"],
|
|
display_name=repair["opened_by_display_name"],
|
|
),
|
|
closed_at=repair["closed_at"],
|
|
closed_by=closed_by,
|
|
miner_lifecycle=repair["miner_lifecycle"],
|
|
latest_event_sequence=repair["latest_event_sequence"],
|
|
)
|
|
|
|
def begin_repair(
|
|
self,
|
|
request: BeginRepairRequest,
|
|
*,
|
|
actor_user_id: UUID | None,
|
|
) -> BeginRepairResult:
|
|
if actor_user_id is None:
|
|
raise RepairActorRequired()
|
|
|
|
note = self.normalize_note(request.notes)
|
|
|
|
with self.repository.transaction() as repository:
|
|
miner = repository.lock_miner_for_update(request.miner_id)
|
|
if not miner:
|
|
raise RepairMinerNotFound(request.miner_id)
|
|
|
|
lifecycle_status = str(miner["lifecycle_status"])
|
|
active_repair = repository.get_active_repair(request.miner_id)
|
|
if active_repair:
|
|
raise ActiveRepairConflict(request.miner_id)
|
|
if lifecycle_status == REPAIR_LIFECYCLE_STATUS:
|
|
raise InconsistentRepairState(request.miner_id)
|
|
if lifecycle_status not in ELIGIBLE_LIFECYCLE_STATUSES:
|
|
raise IncompatibleMinerLifecycle(
|
|
request.miner_id,
|
|
lifecycle_status,
|
|
)
|
|
|
|
repair = repository.create_repair(
|
|
request.miner_id,
|
|
request.reason,
|
|
actor_user_id,
|
|
)
|
|
started_payload = RepairStartedPayload(
|
|
reason=request.reason,
|
|
from_lifecycle=lifecycle_status,
|
|
)
|
|
repository.create_event(
|
|
repair["id"],
|
|
sequence=1,
|
|
event_type="REPAIR_STARTED",
|
|
created_by=actor_user_id,
|
|
payload=started_payload.model_dump(mode="json"),
|
|
)
|
|
if note is not None:
|
|
note_payload = InitialRepairNotePayload(note=note)
|
|
repository.create_event(
|
|
repair["id"],
|
|
sequence=2,
|
|
event_type="INITIAL_NOTE",
|
|
created_by=actor_user_id,
|
|
payload=note_payload.model_dump(mode="json"),
|
|
)
|
|
repository.set_miner_lifecycle(
|
|
request.miner_id,
|
|
REPAIR_LIFECYCLE_STATUS,
|
|
)
|
|
|
|
return BeginRepairResult(
|
|
repair_id=repair["id"],
|
|
miner_id=repair["miner_id"],
|
|
status=repair["status"],
|
|
reason=repair["reason"],
|
|
opened_at=repair["opened_at"],
|
|
opened_by=repair["opened_by"],
|
|
)
|
|
|
|
def complete_repair(
|
|
self,
|
|
repair_id: UUID,
|
|
request: RepairCompleteRequest,
|
|
*,
|
|
actor_user_id: UUID | None,
|
|
) -> RepairDetail:
|
|
if actor_user_id is None:
|
|
raise RepairCompletionActorRequired()
|
|
|
|
completion_summary = self.normalize_note(request.completion_summary)
|
|
|
|
with self.repository.transaction() as repository:
|
|
repair_identity = repository.get_repair_identity(repair_id)
|
|
if repair_identity is None:
|
|
raise RepairNotFound(repair_id)
|
|
|
|
miner_id = repair_identity["miner_id"]
|
|
# Begin Repair also locks the miner first. Keeping this order makes
|
|
# competing lifecycle workflows serialize on the durable asset.
|
|
miner = repository.lock_miner_for_update(miner_id)
|
|
if miner is None:
|
|
raise RepairMinerNotFound(miner_id)
|
|
|
|
repair = repository.lock_repair_for_update(repair_id)
|
|
if repair is None:
|
|
raise RepairNotFound(repair_id)
|
|
if repair["miner_id"] != miner_id:
|
|
raise RepairActiveMismatch(repair_id, miner_id)
|
|
if repair["status"] not in ACTIVE_REPAIR_STATUSES:
|
|
raise RepairNotActive(repair_id, repair["status"])
|
|
|
|
active_repair = repository.get_active_repair(miner_id)
|
|
if active_repair is None or active_repair["id"] != repair_id:
|
|
raise RepairActiveMismatch(repair_id, miner_id)
|
|
|
|
lifecycle_status = str(miner["lifecycle_status"])
|
|
if lifecycle_status != REPAIR_LIFECYCLE_STATUS:
|
|
raise RepairMinerNotInRepair(miner_id, lifecycle_status)
|
|
|
|
next_sequence = repository.get_next_event_sequence(repair_id)
|
|
pre_repair_lifecycle = repository.get_pre_repair_lifecycle(
|
|
repair_id
|
|
)
|
|
completed = repository.complete_repair(
|
|
repair_id,
|
|
completed_by=actor_user_id,
|
|
completion_summary=completion_summary,
|
|
resulting_lifecycle=request.target_lifecycle,
|
|
)
|
|
if completed is None:
|
|
raise RepairNotActive(repair_id, repair["status"])
|
|
|
|
repository.set_miner_lifecycle(
|
|
miner_id,
|
|
request.target_lifecycle,
|
|
)
|
|
payload = RepairCompletedPayload(
|
|
resulting_miner_lifecycle=request.target_lifecycle,
|
|
pre_repair_lifecycle=pre_repair_lifecycle,
|
|
completion_summary=completion_summary,
|
|
)
|
|
repository.create_event(
|
|
repair_id,
|
|
sequence=next_sequence,
|
|
event_type="REPAIR_COMPLETED",
|
|
created_by=actor_user_id,
|
|
payload=payload.model_dump(mode="json", exclude_none=True),
|
|
)
|
|
|
|
detail = repository.get_repair_detail(repair_id)
|
|
if detail is None:
|
|
raise RepairPersistenceError(
|
|
"Completed repair could not be read in its transaction"
|
|
)
|
|
|
|
return self._map_repair_detail(detail)
|
|
|
|
def get_repair(self, repair_id: UUID) -> RepairDetail:
|
|
repair = self.repository.get_repair_detail(repair_id)
|
|
if repair is None:
|
|
raise RepairNotFound(repair_id)
|
|
return self._map_repair_detail(repair)
|
|
|
|
def get_repair_timeline(self, repair_id: UUID) -> RepairTimeline:
|
|
events = self.repository.get_repair_events(repair_id)
|
|
if events is None:
|
|
raise RepairNotFound(repair_id)
|
|
|
|
return RepairTimeline(
|
|
repair_id=repair_id,
|
|
events=[
|
|
RepairTimelineEvent(
|
|
event_id=event["event_id"],
|
|
sequence=event["sequence"],
|
|
event_type=event["event_type"],
|
|
actor=RepairActor(
|
|
user_id=event["actor_user_id"],
|
|
display_name=event["actor_display_name"],
|
|
),
|
|
occurred_at=event["occurred_at"],
|
|
payload=event["payload"],
|
|
)
|
|
for event in events
|
|
],
|
|
)
|