Cheng Zhou
121 lines
4.2 KiB
Python
121 lines
4.2 KiB
Python
import uuid
|
|
from datetime import date, timedelta
|
|
from typing import Sequence
|
|
|
|
from sqlalchemy import select, update as sa_update
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
|
|
from app.models.ae import AdverseEvent
|
|
from app.models.site import Site
|
|
from app.models.subject import Subject
|
|
from app.schemas.ae import AECreate, AEUpdate
|
|
|
|
|
|
def _calc_due_date(onset: date | None, seriousness: str) -> date | None:
|
|
if onset is None:
|
|
return None
|
|
delta = 1 if seriousness == "SERIOUS" else 7
|
|
return onset + timedelta(days=delta)
|
|
|
|
|
|
async def _validate_site_subject(db: AsyncSession, study_id: uuid.UUID, site_id: uuid.UUID | None, subject_id: uuid.UUID | None):
|
|
if site_id:
|
|
result = await db.execute(select(Site).where(Site.id == site_id))
|
|
site = result.scalar_one_or_none()
|
|
if not site or site.study_id != study_id:
|
|
raise ValueError("Site not found in study")
|
|
if subject_id:
|
|
result = await db.execute(select(Subject).where(Subject.id == subject_id))
|
|
subj = result.scalar_one_or_none()
|
|
if not subj or subj.study_id != study_id:
|
|
raise ValueError("Subject not found in study")
|
|
|
|
|
|
async def create_ae(
|
|
db: AsyncSession,
|
|
study_id: uuid.UUID,
|
|
ae_in: AECreate,
|
|
*,
|
|
created_by: uuid.UUID,
|
|
) -> AdverseEvent:
|
|
await _validate_site_subject(db, study_id, ae_in.site_id, ae_in.subject_id)
|
|
due_date = _calc_due_date(ae_in.onset_date, ae_in.seriousness)
|
|
ae = AdverseEvent(
|
|
study_id=study_id,
|
|
site_id=ae_in.site_id,
|
|
subject_id=ae_in.subject_id,
|
|
visit_id=ae_in.visit_id,
|
|
term=ae_in.term,
|
|
onset_date=ae_in.onset_date,
|
|
resolution_date=None,
|
|
seriousness=ae_in.seriousness,
|
|
severity=ae_in.severity,
|
|
causality=ae_in.causality,
|
|
action_taken=None,
|
|
outcome=ae_in.outcome,
|
|
reported_to_sponsor=False,
|
|
report_due_date=due_date,
|
|
status="NEW",
|
|
description=ae_in.description,
|
|
created_by=created_by,
|
|
)
|
|
db.add(ae)
|
|
await db.commit()
|
|
await db.refresh(ae)
|
|
return ae
|
|
|
|
|
|
async def get_ae(db: AsyncSession, ae_id: uuid.UUID) -> AdverseEvent | None:
|
|
result = await db.execute(select(AdverseEvent).where(AdverseEvent.id == ae_id))
|
|
return result.scalar_one_or_none()
|
|
|
|
|
|
async def list_ae(
|
|
db: AsyncSession,
|
|
study_id: uuid.UUID,
|
|
status: str | None = None,
|
|
seriousness: str | None = None,
|
|
site_id: uuid.UUID | None = None,
|
|
subject_id: uuid.UUID | None = None,
|
|
overdue: bool | None = None,
|
|
) -> Sequence[AdverseEvent]:
|
|
stmt = select(AdverseEvent).where(AdverseEvent.study_id == study_id)
|
|
if status:
|
|
stmt = stmt.where(AdverseEvent.status == status)
|
|
if seriousness:
|
|
stmt = stmt.where(AdverseEvent.seriousness == seriousness)
|
|
if site_id:
|
|
stmt = stmt.where(AdverseEvent.site_id == site_id)
|
|
if subject_id:
|
|
stmt = stmt.where(AdverseEvent.subject_id == subject_id)
|
|
if overdue is True:
|
|
stmt = stmt.where(AdverseEvent.report_due_date < date.today(), AdverseEvent.status != "CLOSED")
|
|
if overdue is False:
|
|
stmt = stmt.where((AdverseEvent.report_due_date >= date.today()) | (AdverseEvent.report_due_date.is_(None)) | (AdverseEvent.status == "CLOSED"))
|
|
result = await db.execute(stmt)
|
|
return result.scalars().all()
|
|
|
|
|
|
async def update_ae(db: AsyncSession, study_id: uuid.UUID, ae: AdverseEvent, ae_in: AEUpdate) -> AdverseEvent:
|
|
update_data = ae_in.model_dump(exclude_unset=True)
|
|
if "subject_id" in update_data:
|
|
await _validate_site_subject(db, study_id, None, update_data["subject_id"])
|
|
if "onset_date" in update_data or "seriousness" in update_data:
|
|
onset = update_data.get("onset_date", ae.onset_date)
|
|
seriousness = update_data.get("seriousness", ae.seriousness)
|
|
update_data["report_due_date"] = _calc_due_date(onset, seriousness)
|
|
if update_data:
|
|
await db.execute(
|
|
sa_update(AdverseEvent)
|
|
.where(AdverseEvent.id == ae.id)
|
|
.values(**update_data)
|
|
)
|
|
await db.commit()
|
|
await db.refresh(ae)
|
|
return ae
|
|
|
|
|
|
async def delete_ae(db: AsyncSession, ae: AdverseEvent) -> None:
|
|
await db.delete(ae)
|
|
await db.commit()
|