Spaces:
Sleeping
Sleeping
Download routes/double_auth.py from alisaleem97/NexLab_System: direct link, hf CLI and curl.
- Browser
- Download file 11.5 kB
-
https://huggingface.co/spaces/alisaleem97/NexLab_System/resolve/main/routes/double_auth.py
- Command line
-
hf download hf://spaces/alisaleem97/NexLab_System/routes/double_auth.py
-
curl -L -o double_auth.py https://huggingface.co/spaces/alisaleem97/NexLab_System/resolve/main/routes/double_auth.py
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 | |
| 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 | |
| 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 | |
| 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) | |
| 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) | |
| 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) |