138 lines
4.2 KiB
Python
138 lines
4.2 KiB
Python
from __future__ import annotations
|
|
|
|
from datetime import datetime
|
|
from uuid import UUID, uuid4
|
|
|
|
from fastapi import HTTPException
|
|
from sqlalchemy import select, update
|
|
from sqlalchemy.orm import Session
|
|
|
|
from fastapi_demo.app.infrastructure.db.models import (
|
|
Asset as AssetORM,
|
|
AssetEvent as AssetEventORM,
|
|
)
|
|
from fastapi_demo.app.domain.status import AssetStatus
|
|
from fastapi_demo.app.schemas.asset import AssetOut, AssetEventOut
|
|
|
|
|
|
class SqlAssetsRepo:
|
|
def __init__(self, db: Session) -> None:
|
|
self.db = db
|
|
|
|
def create(self, asset: AssetOut) -> None:
|
|
row = AssetORM(
|
|
id=str(asset.id),
|
|
name=asset.name,
|
|
serial=asset.serial,
|
|
status=str(asset.status),
|
|
revision=asset.revision, # <-- wichtig
|
|
created_at=asset.updated_at, # MVP: created_at == updated_at
|
|
updated_at=asset.updated_at,
|
|
)
|
|
self.db.add(row)
|
|
self.db.commit()
|
|
|
|
def get(self, asset_id: UUID) -> AssetOut | None:
|
|
row = self.db.get(AssetORM, str(asset_id))
|
|
if not row:
|
|
return None
|
|
return AssetOut(
|
|
id=UUID(row.id),
|
|
name=row.name,
|
|
serial=row.serial,
|
|
status=AssetStatus(row.status),
|
|
revision=row.revision, # <-- wichtig
|
|
updated_at=row.updated_at,
|
|
)
|
|
|
|
def transition_with_revision(
|
|
self,
|
|
asset_id: UUID,
|
|
expected_revision: int,
|
|
to_status: AssetStatus,
|
|
at: datetime,
|
|
note: str | None,
|
|
) -> tuple[AssetOut, AssetEventOut]:
|
|
|
|
with self.db.begin(): # <-- begin ganz nach oben
|
|
current = self.db.get(AssetORM, str(asset_id))
|
|
if not current:
|
|
raise HTTPException(status_code=404, detail="Asset nicht gefunden")
|
|
|
|
from_status = AssetStatus(current.status)
|
|
|
|
stmt = (
|
|
update(AssetORM)
|
|
.where(
|
|
AssetORM.id == str(asset_id),
|
|
AssetORM.revision == expected_revision,
|
|
)
|
|
.values(
|
|
status=str(to_status),
|
|
updated_at=at,
|
|
revision=expected_revision + 1,
|
|
)
|
|
)
|
|
|
|
res = self.db.execute(stmt)
|
|
if res.rowcount != 1:
|
|
# aktuelle Revision für saubere Fehlermeldung neu lesen
|
|
latest = self.db.get(AssetORM, str(asset_id))
|
|
raise HTTPException(
|
|
status_code=409,
|
|
detail={
|
|
"message": "Revision-Konflikt",
|
|
"expected_revision": expected_revision,
|
|
"current_revision": latest.revision if latest else None,
|
|
},
|
|
)
|
|
|
|
event_row = AssetEventORM(
|
|
id=str(uuid4()),
|
|
asset_id=str(asset_id),
|
|
from_status=str(from_status),
|
|
to_status=str(to_status),
|
|
at=at,
|
|
note=note,
|
|
)
|
|
self.db.add(event_row)
|
|
|
|
# nach Commit: updated Asset laden
|
|
updated = self.db.get(AssetORM, str(asset_id))
|
|
assert updated is not None
|
|
|
|
asset_out = AssetOut(
|
|
id=UUID(updated.id),
|
|
name=updated.name,
|
|
serial=updated.serial,
|
|
status=AssetStatus(updated.status),
|
|
revision=updated.revision,
|
|
updated_at=updated.updated_at,
|
|
)
|
|
event_out = AssetEventOut(
|
|
asset_id=asset_out.id,
|
|
from_status=from_status,
|
|
to_status=to_status,
|
|
at=at,
|
|
note=note,
|
|
)
|
|
return asset_out, event_out
|
|
|
|
def list_events(self, asset_id: UUID) -> list[AssetEventOut]:
|
|
stmt = (
|
|
select(AssetEventORM)
|
|
.where(AssetEventORM.asset_id == str(asset_id))
|
|
.order_by(AssetEventORM.at.asc())
|
|
)
|
|
rows = self.db.execute(stmt).scalars().all()
|
|
return [
|
|
AssetEventOut(
|
|
asset_id=UUID(r.asset_id),
|
|
from_status=AssetStatus(r.from_status),
|
|
to_status=AssetStatus(r.to_status),
|
|
at=r.at,
|
|
note=r.note,
|
|
)
|
|
for r in rows
|
|
]
|