NexLab_System / routes /double_auth.py
alisaleem97's picture
Upload folder using huggingface_hub
6ea020b verified
Raw History Blame Contribute Delete
11.5 kB
# routes/double_auth.py
from fastapi import APIRouter, Depends, Request
from fastapi.responses import HTMLResponse, JSONResponse, RedirectResponse
from sqlmodel import Session, select
from sqlalchemy.orm import selectinload
from datetime import datetime
from database import get_session
from models import Patient, PatientVisit, Order, TestDefinition, Result, ResultDetail
# ✅ NEW: Added log_audit_action to imports
from routes.helpers import templates, get_current_user, log_audit_action, log_activity_action, require_permission, build_patient_visit_data
router = APIRouter()
# 1. Double Auth Patients List
@router.get("/double-auth", response_class=HTMLResponse)
def double_auth_patients_page(request: Request, session: Session = Depends(get_session)):
if not require_permission(request, session, "double_auth"):
return RedirectResponse(url="/dashboard?error=Permission Denied", status_code=303)
patient_data, filters, page, total_pages, total_count = build_patient_visit_data(session, request)
return templates.TemplateResponse("double_auth_patients.html", {
"request": request,
"patient_data": patient_data,
"filters": filters,
"page": page,
"total_pages": total_pages,
"total_count": total_count,
})
# 2. Double Auth Page
@router.get("/double-auth/{patient_id}", response_class=HTMLResponse)
def double_auth_page(patient_id: str, request: Request, session: Session = Depends(get_session)):
if not require_permission(request, session, "double_auth"):
return RedirectResponse(url="/double-auth?error=Permission Denied", status_code=303)
current_user = get_current_user(request, session)
patient = session.exec(select(Patient).where(Patient.patient_id == patient_id)).first()
if not patient:
return RedirectResponse(url="/double-auth?error=Patient not found", status_code=303)
# Support visit_id query param to select a specific visit
visit_id_param = request.query_params.get("visit_id")
if visit_id_param:
visit = session.exec(
select(PatientVisit)
.where(PatientVisit.visit_id == visit_id_param, PatientVisit.patient_id == patient.id)
).first()
else:
visit = session.exec(
select(PatientVisit)
.where(PatientVisit.patient_id == patient.id)
.order_by(PatientVisit.id.desc())
).first()
visit_user_name = None
if visit and visit.created_by:
from models import User
user = session.get(User, visit.created_by)
if user:
visit_user_name = user.full_name or user.username
# Fetch all visits for the "Previous Results" bar
all_visits = session.exec(
select(PatientVisit)
.where(PatientVisit.patient_id == patient.id)
.order_by(PatientVisit.visit_date.asc())
).all()
return templates.TemplateResponse("double_auth.html", {
"request": request,
"patient": patient,
"visit": visit,
"visit_user_name": visit_user_name,
"all_visits": all_visits,
})
# 3. Actions API
@router.post("/api/double-auth/authorize/{order_id}")
def double_authorize_order(order_id: int, request: Request, session: Session = Depends(get_session)):
if not require_permission(request, session, "double_auth", "double_authorize"):
return JSONResponse({"success": False, "message": "Permission Denied"}, status_code=403)
current_user = get_current_user(request, session)
if not current_user:
return JSONResponse({"success": False, "message": "Unauthorized"}, status_code=401)
try:
order = session.get(Order, order_id)
if not order:
return JSONResponse({"success": False, "message": "Order not found"}, status_code=404)
result = session.exec(select(Result).where(Result.order_id == order_id)).first()
if not result:
return JSONResponse({"success": False, "message": "Result not found"}, status_code=404)
# Guard: must be authorized first before double-authorizing
if not result.authorized:
return JSONResponse({"success": False, "message": "Test must be authorized before double authorization"}, status_code=400)
# Guard: must be in correct status
if order.status not in ("authorized", "resulted"):
return JSONResponse({"success": False, "message": f"Cannot double-authorize from status '{order.status}'"}, status_code=400)
result.double_authorized = True
result.double_authorized_by = current_user.id
result.double_authorized_at = datetime.now()
result.unauth_reason = None
order.status = "double_authorized"
session.add(result)
session.add(order)
# ---------------------------------------------------------
# ✅ NEW: INJECT AUDIT LOG HERE (Tracking Double Auth)
# ---------------------------------------------------------
log_audit_action(
session=session,
table_name="order",
record_id=order.id,
action="UPDATE",
current_user=current_user,
new_values={
"action": "Test Double Authorized",
"status": "double_authorized"
}
)
# ---------------------------------------------------------
session.commit()
# Activity Log
test_name = order.test.test_name if order.test else "Unknown"
patient = session.get(Patient, order.patient_id) if order.patient_id else None
patient_name = patient.full_name if patient else "Unknown"
log_activity_action(session, "DOUBLE_AUTH", f"Double authorized test '{test_name}' for patient {patient_name}", current_user, "patient", order.patient_id)
session.commit()
return {"success": True, "message": "Test double authorized"}
except Exception as e:
session.rollback()
return JSONResponse({"success": False, "message": str(e)}, status_code=500)
@router.post("/api/double-auth/rerun/{order_id}")
def rerun_order(order_id: int, request: Request, session: Session = Depends(get_session)):
if not require_permission(request, session, "double_auth", "rerun"):
return JSONResponse({"success": False, "message": "Permission Denied"}, status_code=403)
current_user = get_current_user(request, session)
if not current_user:
return JSONResponse({"success": False, "message": "Unauthorized"}, status_code=401)
try:
order = session.get(Order, order_id)
if not order:
return JSONResponse({"success": False, "message": "Order not found"}, status_code=404)
# Guard: rerun only allowed from authorized or double_authorized
if order.status not in ("authorized", "double_authorized"):
return JSONResponse({"success": False, "message": f"Cannot rerun from status '{order.status}'. Only authorized tests can be rerun."}, status_code=400)
result = session.exec(select(Result).where(Result.order_id == order_id)).first()
if result:
# Standalone result value backup
if result.result_value:
result.rerun_result = result.result_value
result.result_value = ""
# Reset authorization
result.authorized = False
result.authorized_by = None
result.authorized_at = None
result.double_authorized = False
result.double_authorized_by = None
result.double_authorized_at = None
# Handle children results (ResultDetail)
details = session.exec(select(ResultDetail).where(ResultDetail.result_id == result.id)).all()
for detail in details:
if detail.result_value:
detail.rerun_result = detail.result_value
detail.result_value = ""
session.add(detail)
session.add(result)
order.status = "ordered" # pending
session.add(order)
# ---------------------------------------------------------
# ✅ NEW: INJECT AUDIT LOG HERE (Tracking ReRun)
# ---------------------------------------------------------
log_audit_action(
session=session,
table_name="order",
record_id=order.id,
action="UPDATE",
current_user=current_user,
new_values={
"action": "Test marked for ReRun",
"status": "ordered"
}
)
# ---------------------------------------------------------
session.commit()
return {"success": True, "message": "Test marked for rerun (pending)"}
except Exception as e:
session.rollback()
return JSONResponse({"success": False, "message": str(e)}, status_code=500)
@router.post("/api/double-auth/unauth/{order_id}")
async def unauth_order(order_id: int, request: Request, session: Session = Depends(get_session)):
if not require_permission(request, session, "double_auth", "unauthorize"):
return JSONResponse({"success": False, "message": "Permission Denied"}, status_code=403)
current_user = get_current_user(request, session)
if not current_user:
return JSONResponse({"success": False, "message": "Unauthorized"}, status_code=401)
try:
data = await request.json()
reason = data.get("reason", "")
order = session.get(Order, order_id)
if not order:
return JSONResponse({"success": False, "message": "Order not found"}, status_code=404)
# Guard: unauth only allowed from double_authorized
if order.status != "double_authorized":
return JSONResponse({"success": False, "message": f"Cannot unauthorize from status '{order.status}'. Only double-authorized tests can be unauthorized."}, status_code=400)
result = session.exec(select(Result).where(Result.order_id == order_id)).first()
if not result:
return JSONResponse({"success": False, "message": "Result not found"}, status_code=404)
result.double_authorized = False
result.double_authorized_by = None
result.double_authorized_at = None
result.unauth_reason = reason
order.status = "authorized" # Return to auth and rerun buttons
session.add(result)
session.add(order)
# ---------------------------------------------------------
# ✅ NEW: INJECT AUDIT LOG HERE (Tracking Unauthorize)
# ---------------------------------------------------------
log_audit_action(
session=session,
table_name="order",
record_id=order.id,
action="UPDATE",
current_user=current_user,
new_values={
"action": "Test Unauthorized",
"status": "authorized",
"reason": reason
}
)
# ---------------------------------------------------------
session.commit()
return {"success": True, "message": "Test Unauthorized with reason"}
except Exception as e:
session.rollback()
return JSONResponse({"success": False, "message": str(e)}, status_code=500)