Files
Shubhankar45 4e5e95775d --
2026-10-27 12:03:31 +00:00

214 lines
8.0 KiB
Python

import uuid
from datetime import date
from sqlalchemy import select
from sqlalchemy.exc import IntegrityError
from sqlalchemy.ext.asyncio import AsyncSession
from app.audit.service import AuditService
from app.auth.dependencies import assert_can_view_hq, visible_hq_ids
from app.common import master_approval
from app.common.enums import AuditAction, EntityType, MasterApproval, Role, FIELD_ROLES
from app.common.exceptions import ConflictError, NotFoundError, ValidationError
from app.common.utils import snapshot
from app.doctors.models import Doctor, DoctorAssignment
from app.doctors.schemas import DoctorCreate, DoctorUpdate
from app.users.models import User
_AUDIT_FIELDS = [
"name",
"clinic_address",
"speciality",
"date_of_birth",
"is_core_doctor",
"is_active",
]
class DoctorService:
def __init__(self, db: AsyncSession) -> None:
self.db = db
self.audit = AuditService(db)
async def create(self, data: DoctorCreate, actor: User, ip: str | None = None) -> Doctor:
# A2/A3 — masters belong to a headquarters. An MR may add one only to their own.
await assert_can_view_hq(self.db, actor, data.headquarters_id)
values = data.model_dump()
# Added by an MR: it waits for the Area Manager. One they were refused is sent again.
twin = None
if actor.role in FIELD_ROLES:
twin = await master_approval.rejected_twin(
self.db, Doctor, {k: values[k] for k in ('headquarters_id', 'name', 'clinic_address')}
)
if twin is not None:
await master_approval.resubmit(self.db, twin, values, actor, DoctorAssignment, "doctor_id")
await self.audit.log(
actor_user_id=actor.id,
entity_type=EntityType.DOCTOR,
entity_id=twin.id,
action=AuditAction.SUBMIT,
after=snapshot(twin, _AUDIT_FIELDS),
ip_address=ip,
)
await self.db.commit()
await self.db.refresh(twin)
return twin
doctor = Doctor(
**values,
approval_status=master_approval.initial_status(actor),
requested_by_user_id=actor.id if actor.role in FIELD_ROLES else None,
)
self.db.add(doctor)
try:
await self.db.flush()
except IntegrityError as exc:
await self.db.rollback()
raise ConflictError(
"A doctor with this name already exists at this clinic in this headquarters",
{"cause": "uq_doctor_hq_name_clinic"},
) from exc
await self.audit.log(
actor_user_id=actor.id,
entity_type=EntityType.DOCTOR,
entity_id=doctor.id,
action=AuditAction.CREATE,
after=snapshot(doctor, _AUDIT_FIELDS),
ip_address=ip,
)
# An MR only sees assigned doctors, so the one they add is assigned to them.
if actor.role in FIELD_ROLES:
start = date.today()
self.db.add(
DoctorAssignment(doctor_id=doctor.id, mr_user_id=actor.id, effective_from=start)
)
await self.audit.log(
actor_user_id=actor.id,
entity_type=EntityType.DOCTOR,
entity_id=doctor.id,
action=AuditAction.ASSIGN,
after={"mr_user_id": str(actor.id), "effective_from": start.isoformat()},
ip_address=ip,
)
await self.db.commit()
await self.db.refresh(doctor)
return doctor
async def update(
self, doctor_id: uuid.UUID, data: DoctorUpdate, actor: User, ip: str | None = None
) -> Doctor:
doctor = await self.db.get(Doctor, doctor_id)
if doctor is None:
raise NotFoundError("Doctor not found")
await assert_can_view_hq(self.db, actor, doctor.headquarters_id)
before = snapshot(doctor, _AUDIT_FIELDS)
for field, value in data.model_dump(exclude_unset=True).items():
setattr(doctor, field, value)
await self.audit.log(
actor_user_id=actor.id,
entity_type=EntityType.DOCTOR,
entity_id=doctor.id,
action=AuditAction.UPDATE,
before=before,
after=snapshot(doctor, _AUDIT_FIELDS),
ip_address=ip,
)
await self.db.commit()
return doctor
async def list_for(self, actor: User) -> list[Doctor]:
"""An MR sees ONLY doctors currently assigned to them (R5)."""
if actor.role in FIELD_ROLES:
stmt = (
select(Doctor)
.join(DoctorAssignment, DoctorAssignment.doctor_id == Doctor.id)
.where(
DoctorAssignment.mr_user_id == actor.id,
DoctorAssignment.effective_to.is_(None),
Doctor.is_active.is_(True),
Doctor.approval_status == MasterApproval.APPROVED,
)
.order_by(Doctor.name)
)
return list((await self.db.execute(stmt)).scalars().all())
allowed = await visible_hq_ids(self.db, actor)
stmt = select(Doctor).where(Doctor.approval_status == MasterApproval.APPROVED).order_by(Doctor.name)
if allowed is not None:
stmt = stmt.where(Doctor.headquarters_id.in_(allowed or [None]))
return list((await self.db.execute(stmt)).scalars().all())
async def assign_to_mr(
self,
doctor_id: uuid.UUID,
mr_user_id: uuid.UUID,
effective_from: date | None,
actor: User,
ip: str | None = None,
) -> DoctorAssignment:
doctor = await self.db.get(Doctor, doctor_id)
if doctor is None:
raise NotFoundError("Doctor not found")
await assert_can_view_hq(self.db, actor, doctor.headquarters_id)
if doctor.approval_status != MasterApproval.APPROVED:
raise ValidationError("This doctor is still waiting for the Area Manager's approval")
mr = await self.db.get(User, mr_user_id)
if mr is None:
raise NotFoundError("MR not found")
if mr.role not in FIELD_ROLES:
raise ValidationError("Doctors can only be assigned to an MR")
# An MR may only be given doctors from their own headquarters.
if doctor.headquarters_id not in mr.covered_headquarter_ids:
raise ValidationError(
"MR and doctor belong to different headquarters",
{
"mr_headquarters_id": str(mr.headquarters_id),
"doctor_headquarters_id": str(doctor.headquarters_id),
},
)
start = effective_from or date.today()
existing = (
await self.db.execute(
select(DoctorAssignment).where(
DoctorAssignment.doctor_id == doctor_id,
DoctorAssignment.effective_to.is_(None),
)
)
).scalars().all()
for row in existing:
if row.mr_user_id == mr_user_id:
return row
row.effective_to = start
await self.db.flush()
assignment = DoctorAssignment(
doctor_id=doctor_id, mr_user_id=mr_user_id, effective_from=start
)
self.db.add(assignment)
await self.audit.log(
actor_user_id=actor.id,
entity_type=EntityType.DOCTOR,
entity_id=doctor_id,
action=AuditAction.ASSIGN,
after={"mr_user_id": str(mr_user_id), "effective_from": start.isoformat()},
ip_address=ip,
)
await self.db.commit()
return assignment
async def requests_for(self, actor: User) -> list[Doctor]:
return await master_approval.requests_for(self.db, Doctor, actor)
async def review(
self, doctor_id: uuid.UUID, approve: bool, reason: str | None, actor: User, ip: str | None = None
) -> Doctor:
return await master_approval.review(
self.db, Doctor, EntityType.DOCTOR, doctor_id, approve, reason, actor, ip
)