Files
celtic-life-science/app/common/master_approval.py
T
Shubhankar45 0d30c58bf0 Server backup 2026-11-07 of uncommitted work in projects/pharma-web-celtic
Snapshot of the working tree on srv1071960 (branch main), taken during
server cleanup. .env files, node_modules, builds, logs and media were excluded.
2026-11-07 05:43:12 +00:00

125 lines
4.9 KiB
Python

"""Approval of the doctors, chemists and stockists an MR adds.
MR adds one --> PENDING --approve(ABM)--> APPROVED (listed, and visitable by that MR)
--reject(ABM)---> REJECTED (the MR sees why; adding it again re-sends it)
Only APPROVED masters are listed or may be visited. The administrator's own additions are
APPROVED at once. The reviewer is the Area Business Manager of the master's headquarters (or the
administrator); the Assistant General Manager may look but not act.
"""
import uuid
from datetime import date
from typing import Any
from sqlalchemy import select
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.enums import AuditAction, EntityType, MasterApproval, Role, FIELD_ROLES
from app.common.exceptions import ConflictError, ForbiddenError, NotFoundError
from app.users.models import User
def initial_status(actor: User) -> str:
return MasterApproval.PENDING if actor.role in FIELD_ROLES else MasterApproval.APPROVED
async def rejected_twin(db: AsyncSession, model: Any, match: dict[str, Any]) -> Any | None:
"""A rejected record with the same identity: adding it again re-sends that one for approval."""
stmt = select(model).where(*(getattr(model, k) == v for k, v in match.items()))
found = (await db.execute(stmt)).scalars().first()
return found if found is not None and found.approval_status == MasterApproval.REJECTED else None
async def resubmit(
db: AsyncSession,
record: Any,
values: dict[str, Any],
actor: User,
assignment_model: Any | None = None,
fk: str | None = None,
) -> None:
"""Re-send a rejected record with the MR's new details, assigned to that MR (stockists have no
per-MR assignment: they belong to the headquarters)."""
for field, value in values.items():
setattr(record, field, value)
record.approval_status = MasterApproval.PENDING
record.requested_by_user_id = actor.id
record.rejection_reason = None
if assignment_model is None or fk is None:
return
today = date.today()
current = (
await db.execute(
select(assignment_model).where(
getattr(assignment_model, fk) == record.id, assignment_model.effective_to.is_(None)
)
)
).scalars().all()
if not any(a.mr_user_id == actor.id for a in current):
for row in current:
row.effective_to = today
await db.flush()
db.add(assignment_model(**{fk: record.id, "mr_user_id": actor.id, "effective_from": today}))
async def requests_for(db: AsyncSession, model: Any, actor: User) -> list[Any]:
"""An MR: what they asked for that is still waiting or was rejected.
An Area Business Manager: what waits for them. Administrator and AGM: everything waiting."""
stmt = select(model).order_by(model.created_at.desc())
if actor.role in FIELD_ROLES:
return list(
(
await db.execute(
stmt.where(
model.requested_by_user_id == actor.id,
model.approval_status.in_([MasterApproval.PENDING, MasterApproval.REJECTED]),
)
)
).scalars()
)
stmt = stmt.where(model.approval_status == MasterApproval.PENDING)
allowed = await visible_hq_ids(db, actor)
if allowed is not None:
stmt = stmt.where(model.headquarters_id.in_(allowed or [None]))
return list((await db.execute(stmt)).scalars())
async def review(
db: AsyncSession,
model: Any,
entity_type: EntityType,
record_id: uuid.UUID,
approve: bool,
reason: str | None,
actor: User,
ip: str | None,
) -> Any:
record = await db.get(model, record_id)
if record is None:
raise NotFoundError(f"{entity_type.value.capitalize()} not found")
if actor.role not in (Role.ABM, Role.ADMIN):
raise ForbiddenError("Only the Area Business Manager approves a new doctor, chemist or stockist")
await assert_can_view_hq(db, actor, record.headquarters_id)
target = MasterApproval.APPROVED if approve else MasterApproval.REJECTED
if record.approval_status == target:
return record # a double click
if record.approval_status != MasterApproval.PENDING:
raise ConflictError("This request has already been decided", {"status": record.approval_status})
record.approval_status = target
record.rejection_reason = None if approve else reason
await AuditService(db).log(
actor_user_id=actor.id,
entity_type=entity_type,
entity_id=record.id,
action=AuditAction.APPROVE if approve else AuditAction.RETURN,
before={"approval_status": MasterApproval.PENDING.value},
after={"approval_status": target.value, **({"reason": reason} if reason else {})},
ip_address=ip,
)
await db.commit()
await db.refresh(record)
return record