Spaces:
Sleeping
Sleeping
Download routes/tests.py from alisaleem97/NexLab_System: direct link, hf CLI and curl.
- Browser
- Download file 39.3 kB
-
https://huggingface.co/spaces/alisaleem97/NexLab_System/resolve/main/routes/tests.py
- Command line
-
hf download hf://spaces/alisaleem97/NexLab_System/routes/tests.py
-
curl -L -o tests.py https://huggingface.co/spaces/alisaleem97/NexLab_System/resolve/main/routes/tests.py
39.3 kB
| # routes/tests.py | |
| # CRUD routes for: Test Definitions, Formulas, Test Ranges, Test Result Types, Packages. | |
| # Includes N+1 fixes with selectinload. | |
| from fastapi import APIRouter, Depends, Request, Form, status | |
| from fastapi.responses import HTMLResponse, RedirectResponse | |
| from sqlmodel import Session, select | |
| from sqlalchemy.orm import selectinload | |
| from datetime import datetime | |
| from typing import Optional | |
| from database import get_session | |
| from models import ( | |
| TestDefinition, TestDevice, TestParameter, Department, SampleType, ReportNote, | |
| Device, Parameter, Formula, FormulaItem, TestRange, TestResultType, | |
| Package, PackageTest, | |
| ) | |
| from routes.helpers import templates, get_current_user, create_audit_log, model_to_dict, require_permission | |
| router = APIRouter() | |
| # =========================== | |
| # TEST DEFINITION ROUTES (N+1 FIX: selectinload) | |
| # =========================== | |
| def tests_page(request: Request, session: Session = Depends(get_session)): | |
| if not require_permission(request, session, "tests"): | |
| return RedirectResponse(url="/dashboard?error=Permission Denied", status_code=status.HTTP_303_SEE_OTHER) | |
| # ✅ N+1 FIX: eager-load test_devices and test_parameters in one query | |
| tests = session.exec( | |
| select(TestDefinition) | |
| .options(selectinload(TestDefinition.test_devices), selectinload(TestDefinition.test_parameters)) | |
| .order_by(TestDefinition.id.asc()) | |
| ).all() | |
| tests_json = [] | |
| for test in tests: | |
| test_dict = model_to_dict(test) | |
| device_ids = [int(td.device_id) for td in test.test_devices] | |
| parameter_ids = [int(tp.parameter_id) for tp in test.test_parameters] | |
| test_dict['device_ids'] = device_ids | |
| test_dict['parameter_ids'] = parameter_ids | |
| tests_json.append(test_dict) | |
| departments = session.exec(select(Department).where(Department.is_active == True)).all() | |
| sample_types = session.exec(select(SampleType).where(SampleType.is_active == True)).all() | |
| report_notes = session.exec(select(ReportNote).where(ReportNote.is_active == True)).all() | |
| devices = session.exec(select(Device).where(Device.is_active == True)).all() | |
| parameters = session.exec(select(Parameter)).all() | |
| success = request.query_params.get("success") | |
| error = request.query_params.get("error") | |
| return templates.TemplateResponse("tests.html", { | |
| "request": request, "tests": tests, "tests_json": tests_json, | |
| "departments": departments, "sample_types": sample_types, "report_notes": report_notes, | |
| "devices": devices, "parameters": parameters, | |
| "message_success": success, "message_error": error | |
| }) | |
| def create_test(test_name: str = Form(...), test_short_name: str = Form(...), | |
| department_id: int = Form(...), sample_type_id: int = Form(...), | |
| report_note_id: Optional[int] = Form(None), price: float = Form(...), | |
| test_note: Optional[str] = Form(None), test_condition: Optional[str] = Form(None), | |
| is_available: str = Form(None), print_separately: str = Form(None), | |
| device_ids: Optional[str] = Form(""), | |
| parameter_ids: Optional[str] = Form(""), request: Request = None, | |
| session: Session = Depends(get_session)): | |
| if not require_permission(request, session, "tests", "create"): | |
| return RedirectResponse(url="/tests?error=Permission Denied", status_code=status.HTTP_303_SEE_OTHER) | |
| try: | |
| current_user = get_current_user(request, session) | |
| is_available_bool = True if is_available == "on" else False | |
| new_test = TestDefinition( | |
| test_name=test_name, test_short_name=test_short_name.upper(), | |
| department_id=department_id, sample_type_id=sample_type_id, | |
| report_note_id=report_note_id if report_note_id and report_note_id != "" else None, | |
| price=price, test_note=test_note, test_condition=test_condition, | |
| is_available=is_available_bool, print_separately=(print_separately == "on"), | |
| created_by=current_user.id if current_user else None | |
| ) | |
| session.add(new_test) | |
| session.commit() | |
| session.refresh(new_test) | |
| if device_ids and device_ids.strip(): | |
| device_id_list = [int(d.strip()) for d in device_ids.split(',') if d.strip().isdigit()] | |
| for device_id in device_id_list: | |
| link = TestDevice(test_id=new_test.id, device_id=device_id) | |
| session.add(link) | |
| if parameter_ids and parameter_ids.strip(): | |
| parameter_id_list = [int(p.strip()) for p in parameter_ids.split(',') if p.strip().isdigit()] | |
| for parameter_id in parameter_id_list: | |
| link = TestParameter(test_id=new_test.id, parameter_id=parameter_id) | |
| session.add(link) | |
| session.commit() | |
| create_audit_log(session, "testdefinition", new_test.id, "create", current_user, new_values=model_to_dict(new_test)) | |
| return RedirectResponse(url="/tests?success=Test saved successfully!", status_code=status.HTTP_303_SEE_OTHER) | |
| except Exception as e: | |
| session.rollback() | |
| return RedirectResponse(url=f"/tests?error={str(e).replace(' ', '%20')}", status_code=status.HTTP_303_SEE_OTHER) | |
| def update_test(test_id: int, test_name: str = Form(...), test_short_name: str = Form(...), | |
| department_id: int = Form(...), sample_type_id: int = Form(...), | |
| report_note_id: Optional[int] = Form(None), price: float = Form(...), | |
| test_note: Optional[str] = Form(None), test_condition: Optional[str] = Form(None), | |
| is_available: str = Form(None), print_separately: str = Form(None), | |
| device_ids: Optional[str] = Form(""), | |
| parameter_ids: Optional[str] = Form(""), request: Request = None, | |
| session: Session = Depends(get_session)): | |
| if not require_permission(request, session, "tests", "edit"): | |
| return RedirectResponse(url="/tests?error=Permission Denied", status_code=status.HTTP_303_SEE_OTHER) | |
| try: | |
| current_user = get_current_user(request, session) | |
| test = session.get(TestDefinition, test_id) | |
| if test: | |
| old_values = model_to_dict(test) | |
| test.test_name = test_name | |
| test.test_short_name = test_short_name.upper() | |
| test.department_id = department_id | |
| test.sample_type_id = sample_type_id | |
| test.report_note_id = report_note_id if report_note_id and report_note_id != "" else None | |
| test.price = price | |
| test.test_note = test_note | |
| test.test_condition = test_condition | |
| test.is_available = True if is_available == "on" else False | |
| test.print_separately = True if print_separately == "on" else False | |
| test.edited_by = current_user.id if current_user else None | |
| test.edited_at = datetime.now() | |
| existing_device_links = session.exec(select(TestDevice).where(TestDevice.test_id == test_id)).all() | |
| for link in existing_device_links: | |
| session.delete(link) | |
| if device_ids and device_ids.strip(): | |
| device_id_list = [int(d.strip()) for d in device_ids.split(',') if d.strip().isdigit()] | |
| for device_id in device_id_list: | |
| link = TestDevice(test_id=test.id, device_id=device_id) | |
| session.add(link) | |
| existing_parameter_links = session.exec(select(TestParameter).where(TestParameter.test_id == test_id)).all() | |
| for link in existing_parameter_links: | |
| session.delete(link) | |
| if parameter_ids and parameter_ids.strip(): | |
| parameter_id_list = [int(p.strip()) for p in parameter_ids.split(',') if p.strip().isdigit()] | |
| for parameter_id in parameter_id_list: | |
| link = TestParameter(test_id=test.id, parameter_id=parameter_id) | |
| session.add(link) | |
| session.add(test) | |
| session.commit() | |
| session.refresh(test) | |
| create_audit_log(session, "testdefinition", test.id, "update", current_user, old_values=old_values, new_values=model_to_dict(test)) | |
| return RedirectResponse(url="/tests?success=Test updated successfully!", status_code=status.HTTP_303_SEE_OTHER) | |
| return RedirectResponse(url="/tests?error=Test not found", status_code=status.HTTP_303_SEE_OTHER) | |
| except Exception as e: | |
| session.rollback() | |
| return RedirectResponse(url=f"/tests?error={str(e).replace(' ', '%20')}", status_code=status.HTTP_303_SEE_OTHER) | |
| def delete_test(test_id: int, request: Request, session: Session = Depends(get_session)): | |
| if not require_permission(request, session, "tests", "delete"): | |
| return RedirectResponse(url="/tests?error=Permission Denied", status_code=status.HTTP_303_SEE_OTHER) | |
| try: | |
| current_user = get_current_user(request, session) | |
| test = session.get(TestDefinition, test_id) | |
| if test: | |
| old_values = model_to_dict(test) | |
| # Check for existing orders referencing this test | |
| from models import Order | |
| order_count = session.exec( | |
| select(Order).where(Order.test_id == test_id) | |
| ).first() | |
| if order_count: | |
| # Soft-delete: mark as unavailable to preserve order references | |
| test.is_available = False | |
| test.deleted_at = datetime.now() | |
| test.deleted_by = current_user.id if current_user else None | |
| session.add(test) | |
| session.commit() | |
| create_audit_log(session, "testdefinition", test.id, "soft_delete", current_user, old_values=old_values, new_values={"action": "Test deactivated (has existing orders)"}) | |
| return RedirectResponse(url="/tests?success=Test deactivated (has existing patient orders, cannot hard-delete).", status_code=status.HTTP_303_SEE_OTHER) | |
| else: | |
| # Safe to hard-delete: no orders reference this test | |
| existing_device_links = session.exec(select(TestDevice).where(TestDevice.test_id == test_id)).all() | |
| for link in existing_device_links: | |
| session.delete(link) | |
| existing_parameter_links = session.exec(select(TestParameter).where(TestParameter.test_id == test_id)).all() | |
| for link in existing_parameter_links: | |
| session.delete(link) | |
| session.delete(test) | |
| session.commit() | |
| create_audit_log(session, "testdefinition", test.id, "delete", current_user, old_values=old_values) | |
| return RedirectResponse(url="/tests?success=Test deleted successfully!", status_code=status.HTTP_303_SEE_OTHER) | |
| return RedirectResponse(url="/tests?error=Test not found", status_code=status.HTTP_303_SEE_OTHER) | |
| except Exception as e: | |
| session.rollback() | |
| return RedirectResponse(url=f"/tests?error={str(e).replace(' ', '%20')}", status_code=status.HTTP_303_SEE_OTHER) | |
| # =========================== | |
| # FORMULA ROUTES | |
| # =========================== | |
| def formulas_page(request: Request, session: Session = Depends(get_session)): | |
| if not require_permission(request, session, "formulas"): | |
| return RedirectResponse(url="/dashboard?error=Permission Denied", status_code=status.HTTP_303_SEE_OTHER) | |
| formulas = session.exec(select(Formula).order_by(Formula.id.asc())).all() | |
| formulas_json = [model_to_dict(f) for f in formulas] | |
| tests = session.exec(select(TestDefinition).where(TestDefinition.is_available == True)).all() | |
| parameters = session.exec(select(Parameter)).all() | |
| success = request.query_params.get("success") | |
| error = request.query_params.get("error") | |
| return templates.TemplateResponse("formulas.html", { | |
| "request": request, "formulas": formulas, "formulas_json": formulas_json, | |
| "tests": tests, "parameters": parameters, | |
| "message_success": success, "message_error": error | |
| }) | |
| def create_formula(formula_name: str = Form(...), main_test_id: int = Form(...), | |
| main_parameter_id: Optional[int] = Form(None), gender_type: str = Form(...), | |
| formula_expression: str = Form(""), formula_description: Optional[str] = Form(None), | |
| request: Request = None, session: Session = Depends(get_session)): | |
| if not require_permission(request, session, "formulas", "create"): | |
| return RedirectResponse(url="/formulas?error=Permission Denied", status_code=status.HTTP_303_SEE_OTHER) | |
| try: | |
| current_user = get_current_user(request, session) | |
| new_formula = Formula( | |
| formula_name=formula_name, main_test_id=main_test_id, | |
| main_parameter_id=main_parameter_id if main_parameter_id else None, | |
| gender_type=gender_type, formula_expression=formula_expression, | |
| formula_description=formula_description, is_active=True, | |
| created_by=current_user.id if current_user else None | |
| ) | |
| session.add(new_formula) | |
| session.commit() | |
| session.refresh(new_formula) | |
| create_audit_log(session, "formula", new_formula.id, "create", current_user, new_values=model_to_dict(new_formula)) | |
| return RedirectResponse(url="/formulas?success=Formula saved successfully!", status_code=status.HTTP_303_SEE_OTHER) | |
| except Exception as e: | |
| session.rollback() | |
| return RedirectResponse(url=f"/formulas?error={str(e).replace(' ', '%20')}", status_code=status.HTTP_303_SEE_OTHER) | |
| def update_formula(formula_id: int, formula_name: str = Form(...), main_test_id: int = Form(...), | |
| main_parameter_id: Optional[int] = Form(None), gender_type: str = Form(...), | |
| formula_expression: str = Form(""), formula_description: Optional[str] = Form(None), | |
| request: Request = None, session: Session = Depends(get_session)): | |
| if not require_permission(request, session, "formulas", "edit"): | |
| return RedirectResponse(url="/formulas?error=Permission Denied", status_code=status.HTTP_303_SEE_OTHER) | |
| try: | |
| current_user = get_current_user(request, session) | |
| formula = session.get(Formula, formula_id) | |
| if formula: | |
| old_values = model_to_dict(formula) | |
| formula.formula_name = formula_name | |
| formula.main_test_id = main_test_id | |
| formula.main_parameter_id = main_parameter_id if main_parameter_id else None | |
| formula.gender_type = gender_type | |
| formula.formula_expression = formula_expression | |
| formula.formula_description = formula_description | |
| formula.edited_by = current_user.id if current_user else None | |
| formula.edited_at = datetime.now() | |
| session.add(formula) | |
| session.commit() | |
| session.refresh(formula) | |
| create_audit_log(session, "formula", formula.id, "update", current_user, old_values=old_values, new_values=model_to_dict(formula)) | |
| return RedirectResponse(url="/formulas?success=Formula updated successfully!", status_code=status.HTTP_303_SEE_OTHER) | |
| return RedirectResponse(url="/formulas?error=Formula not found", status_code=status.HTTP_303_SEE_OTHER) | |
| except Exception as e: | |
| session.rollback() | |
| return RedirectResponse(url=f"/formulas?error={str(e).replace(' ', '%20')}", status_code=status.HTTP_303_SEE_OTHER) | |
| def delete_formula(formula_id: int, request: Request, session: Session = Depends(get_session)): | |
| if not require_permission(request, session, "formulas", "delete"): | |
| return RedirectResponse(url="/formulas?error=Permission Denied", status_code=status.HTTP_303_SEE_OTHER) | |
| try: | |
| current_user = get_current_user(request, session) | |
| formula = session.get(Formula, formula_id) | |
| if formula: | |
| old_values = model_to_dict(formula) | |
| session.delete(formula) | |
| session.commit() | |
| create_audit_log(session, "formula", formula.id, "delete", current_user, old_values=old_values) | |
| return RedirectResponse(url="/formulas?success=Formula deleted successfully!", status_code=status.HTTP_303_SEE_OTHER) | |
| return RedirectResponse(url="/formulas?error=Formula not found", status_code=status.HTTP_303_SEE_OTHER) | |
| except Exception as e: | |
| session.rollback() | |
| return RedirectResponse(url=f"/formulas?error={str(e).replace(' ', '%20')}", status_code=status.HTTP_303_SEE_OTHER) | |
| # =========================== | |
| # TEST RANGE ROUTES | |
| # =========================== | |
| def test_ranges_page(request: Request, session: Session = Depends(get_session)): | |
| if not require_permission(request, session, "test_ranges"): | |
| return RedirectResponse(url="/dashboard?error=Permission Denied", status_code=status.HTTP_303_SEE_OTHER) | |
| ranges = session.exec(select(TestRange).order_by(TestRange.id.asc())).all() | |
| ranges_json = [model_to_dict(r) for r in ranges] | |
| tests = session.exec(select(TestDefinition).where(TestDefinition.is_available == True)).all() | |
| parameters = session.exec(select(Parameter)).all() | |
| devices = session.exec(select(Device).where(Device.is_active == True)).all() | |
| departments = session.exec(select(Department).where(Department.is_active == True)).all() | |
| success = request.query_params.get("success") | |
| error = request.query_params.get("error") | |
| return templates.TemplateResponse("test_ranges.html", { | |
| "request": request, "ranges": ranges, "ranges_json": ranges_json, | |
| "tests": tests, "parameters": parameters, "devices": devices, "departments": departments, | |
| "message_success": success, "message_error": error | |
| }) | |
| def create_test_range(test_id: int = Form(...), parameter_id: Optional[int] = Form(None), | |
| device_id: Optional[int] = Form(None), unit: str = Form(...), | |
| gender_type: str = Form(...), age_from: int = Form(...), | |
| age_to: int = Form(...), age_from_unit: str = Form("year"), age_to_unit: str = Form("year"), | |
| fasting_required: str = Form("false"), range_type: str = Form(...), | |
| normal_from: Optional[float] = Form(None), normal_to: Optional[float] = Form(None), | |
| vlow_from: Optional[float] = Form(None), vlow_to: Optional[float] = Form(None), | |
| low_from: Optional[float] = Form(None), low_to: Optional[float] = Form(None), | |
| midlow_from: Optional[float] = Form(None), midlow_to: Optional[float] = Form(None), | |
| midhigh_from: Optional[float] = Form(None), midhigh_to: Optional[float] = Form(None), | |
| high_from: Optional[float] = Form(None), high_to: Optional[float] = Form(None), | |
| vhigh_from: Optional[float] = Form(None), vhigh_to: Optional[float] = Form(None), | |
| panic_less_than: Optional[float] = Form(None), panic_more_than: Optional[float] = Form(None), | |
| text_range: Optional[str] = Form(None), request: Request = None, | |
| session: Session = Depends(get_session)): | |
| if not require_permission(request, session, "test_ranges", "create"): | |
| return RedirectResponse(url="/test-ranges?error=Permission Denied", status_code=status.HTTP_303_SEE_OTHER) | |
| try: | |
| current_user = get_current_user(request, session) | |
| fasting_bool = fasting_required.lower() == "true" | |
| new_range = TestRange( | |
| test_id=test_id, parameter_id=parameter_id if parameter_id else None, | |
| device_id=device_id if device_id else None, unit=unit, gender_type=gender_type, | |
| age_from=age_from, age_to=age_to, age_from_unit=age_from_unit, age_to_unit=age_to_unit, age_unit=age_from_unit, fasting_required=fasting_bool, | |
| range_type=range_type, normal_from=normal_from, normal_to=normal_to, | |
| vlow_from=vlow_from, vlow_to=vlow_to, low_from=low_from, low_to=low_to, | |
| midlow_from=midlow_from, midlow_to=midlow_to, midhigh_from=midhigh_from, | |
| midhigh_to=midhigh_to, high_from=high_from, high_to=high_to, | |
| vhigh_from=vhigh_from, vhigh_to=vhigh_to, panic_less_than=panic_less_than, | |
| panic_more_than=panic_more_than, text_range=text_range if range_type == "text" else None, | |
| is_active=True, created_by=current_user.id if current_user else None | |
| ) | |
| session.add(new_range) | |
| session.commit() | |
| session.refresh(new_range) | |
| create_audit_log(session, "testrange", new_range.id, "create", current_user, new_values=model_to_dict(new_range)) | |
| return RedirectResponse(url="/test-ranges?success=Test range saved successfully!", status_code=status.HTTP_303_SEE_OTHER) | |
| except Exception as e: | |
| session.rollback() | |
| return RedirectResponse(url=f"/test-ranges?error={str(e).replace(' ', '%20')}", status_code=status.HTTP_303_SEE_OTHER) | |
| def update_test_range(range_id: int, test_id: int = Form(...), parameter_id: Optional[int] = Form(None), | |
| device_id: Optional[int] = Form(None), unit: str = Form(...), | |
| gender_type: str = Form(...), age_from: int = Form(...), | |
| age_to: int = Form(...), age_from_unit: str = Form("year"), age_to_unit: str = Form("year"), | |
| fasting_required: str = Form("false"), range_type: str = Form(...), | |
| normal_from: Optional[float] = Form(None), normal_to: Optional[float] = Form(None), | |
| vlow_from: Optional[float] = Form(None), vlow_to: Optional[float] = Form(None), | |
| low_from: Optional[float] = Form(None), low_to: Optional[float] = Form(None), | |
| midlow_from: Optional[float] = Form(None), midlow_to: Optional[float] = Form(None), | |
| midhigh_from: Optional[float] = Form(None), midhigh_to: Optional[float] = Form(None), | |
| high_from: Optional[float] = Form(None), high_to: Optional[float] = Form(None), | |
| vhigh_from: Optional[float] = Form(None), vhigh_to: Optional[float] = Form(None), | |
| panic_less_than: Optional[float] = Form(None), panic_more_than: Optional[float] = Form(None), | |
| text_range: Optional[str] = Form(None), request: Request = None, | |
| session: Session = Depends(get_session)): | |
| if not require_permission(request, session, "test_ranges", "edit"): | |
| return RedirectResponse(url="/test-ranges?error=Permission Denied", status_code=status.HTTP_303_SEE_OTHER) | |
| try: | |
| current_user = get_current_user(request, session) | |
| range_item = session.get(TestRange, range_id) | |
| if range_item: | |
| old_values = model_to_dict(range_item) | |
| fasting_bool = fasting_required.lower() == "true" | |
| range_item.test_id = test_id | |
| range_item.parameter_id = parameter_id if parameter_id else None | |
| range_item.device_id = device_id if device_id else None | |
| range_item.unit = unit | |
| range_item.gender_type = gender_type | |
| range_item.age_from = age_from | |
| range_item.age_to = age_to | |
| range_item.age_from_unit = age_from_unit | |
| range_item.age_to_unit = age_to_unit | |
| range_item.age_unit = age_from_unit | |
| range_item.fasting_required = fasting_bool | |
| range_item.range_type = range_type | |
| range_item.normal_from = normal_from | |
| range_item.normal_to = normal_to | |
| range_item.vlow_from = vlow_from | |
| range_item.vlow_to = vlow_to | |
| range_item.low_from = low_from | |
| range_item.low_to = low_to | |
| range_item.midlow_from = midlow_from | |
| range_item.midlow_to = midlow_to | |
| range_item.midhigh_from = midhigh_from | |
| range_item.midhigh_to = midhigh_to | |
| range_item.high_from = high_from | |
| range_item.high_to = high_to | |
| range_item.vhigh_from = vhigh_from | |
| range_item.vhigh_to = vhigh_to | |
| range_item.panic_less_than = panic_less_than | |
| range_item.panic_more_than = panic_more_than | |
| range_item.text_range = text_range if range_type == "text" else None | |
| range_item.edited_by = current_user.id if current_user else None | |
| range_item.edited_at = datetime.now() | |
| session.add(range_item) | |
| session.commit() | |
| session.refresh(range_item) | |
| create_audit_log(session, "testrange", range_item.id, "update", current_user, old_values=old_values, new_values=model_to_dict(range_item)) | |
| return RedirectResponse(url="/test-ranges?success=Test range updated successfully!", status_code=status.HTTP_303_SEE_OTHER) | |
| return RedirectResponse(url="/test-ranges?error=Test range not found", status_code=status.HTTP_303_SEE_OTHER) | |
| except Exception as e: | |
| session.rollback() | |
| return RedirectResponse(url=f"/test-ranges?error={str(e).replace(' ', '%20')}", status_code=status.HTTP_303_SEE_OTHER) | |
| def delete_test_range(range_id: int, request: Request, session: Session = Depends(get_session)): | |
| if not require_permission(request, session, "test_ranges", "delete"): | |
| return RedirectResponse(url="/test-ranges?error=Permission Denied", status_code=status.HTTP_303_SEE_OTHER) | |
| try: | |
| current_user = get_current_user(request, session) | |
| range_item = session.get(TestRange, range_id) | |
| if range_item: | |
| old_values = model_to_dict(range_item) | |
| session.delete(range_item) | |
| session.commit() | |
| create_audit_log(session, "testrange", range_item.id, "delete", current_user, old_values=old_values) | |
| return RedirectResponse(url="/test-ranges?success=Test range deleted successfully!", status_code=status.HTTP_303_SEE_OTHER) | |
| return RedirectResponse(url="/test-ranges?error=Test range not found", status_code=status.HTTP_303_SEE_OTHER) | |
| except Exception as e: | |
| session.rollback() | |
| return RedirectResponse(url=f"/test-ranges?error={str(e).replace(' ', '%20')}", status_code=status.HTTP_303_SEE_OTHER) | |
| # =========================== | |
| # TEST RESULT TYPE ROUTES | |
| # =========================== | |
| def test_result_types_page(request: Request, session: Session = Depends(get_session)): | |
| if not require_permission(request, session, "test_result_types"): | |
| return RedirectResponse(url="/dashboard?error=Permission Denied", status_code=status.HTTP_303_SEE_OTHER) | |
| result_types = session.exec(select(TestResultType).order_by(TestResultType.id.asc())).all() | |
| result_types_json = [model_to_dict(rt) for rt in result_types] | |
| # Eager-load test_parameters for building test→parameter mapping | |
| tests = session.exec( | |
| select(TestDefinition) | |
| .where(TestDefinition.is_available == True) | |
| .options(selectinload(TestDefinition.test_parameters)) | |
| ).all() | |
| # Build test→parameter_ids mapping for dynamic parameter filtering | |
| import json | |
| test_param_map = {} | |
| for test in tests: | |
| test_param_map[str(test.id)] = [tp.parameter_id for tp in test.test_parameters] | |
| parameters = session.exec(select(Parameter)).all() | |
| success = request.query_params.get("success") | |
| error = request.query_params.get("error") | |
| return templates.TemplateResponse("test_result_types.html", { | |
| "request": request, "result_types": result_types, "result_types_json": result_types_json, | |
| "tests": tests, "parameters": parameters, | |
| "test_param_map_json": json.dumps(test_param_map), | |
| "message_success": success, "message_error": error | |
| }) | |
| def create_test_result_type(test_id: int = Form(...), parameter_id: Optional[int] = Form(None), | |
| result_type: str = Form(...), selection_options: Optional[str] = Form(None), | |
| request: Request = None, session: Session = Depends(get_session)): | |
| if not require_permission(request, session, "test_result_types", "create"): | |
| return RedirectResponse(url="/test-result-types?error=Permission Denied", status_code=status.HTTP_303_SEE_OTHER) | |
| try: | |
| current_user = get_current_user(request, session) | |
| new_result_type = TestResultType( | |
| test_id=test_id, parameter_id=parameter_id if parameter_id else None, | |
| result_type=result_type, selection_options=selection_options if result_type == "selection" else None, | |
| is_active=True, created_by=current_user.id if current_user else None | |
| ) | |
| session.add(new_result_type) | |
| session.commit() | |
| session.refresh(new_result_type) | |
| create_audit_log(session, "testresulttype", new_result_type.id, "create", current_user, new_values=model_to_dict(new_result_type)) | |
| return RedirectResponse(url="/test-result-types?success=Result type saved successfully!", status_code=status.HTTP_303_SEE_OTHER) | |
| except Exception as e: | |
| session.rollback() | |
| return RedirectResponse(url=f"/test-result-types?error={str(e).replace(' ', '%20')}", status_code=status.HTTP_303_SEE_OTHER) | |
| def update_test_result_type(result_type_id: int, test_id: int = Form(...), | |
| parameter_id: Optional[int] = Form(None), result_type: str = Form(...), | |
| selection_options: Optional[str] = Form(None), request: Request = None, | |
| session: Session = Depends(get_session)): | |
| if not require_permission(request, session, "test_result_types", "edit"): | |
| return RedirectResponse(url="/test-result-types?error=Permission Denied", status_code=status.HTTP_303_SEE_OTHER) | |
| try: | |
| current_user = get_current_user(request, session) | |
| rt = session.get(TestResultType, result_type_id) | |
| if rt: | |
| old_values = model_to_dict(rt) | |
| rt.test_id = test_id | |
| rt.parameter_id = parameter_id if parameter_id else None | |
| rt.result_type = result_type | |
| rt.selection_options = selection_options if result_type == "selection" else None | |
| rt.edited_by = current_user.id if current_user else None | |
| rt.edited_at = datetime.now() | |
| session.add(rt) | |
| session.commit() | |
| session.refresh(rt) | |
| create_audit_log(session, "testresulttype", rt.id, "update", current_user, old_values=old_values, new_values=model_to_dict(rt)) | |
| return RedirectResponse(url="/test-result-types?success=Result type updated successfully!", status_code=status.HTTP_303_SEE_OTHER) | |
| return RedirectResponse(url="/test-result-types?error=Result type not found", status_code=status.HTTP_303_SEE_OTHER) | |
| except Exception as e: | |
| session.rollback() | |
| return RedirectResponse(url=f"/test-result-types?error={str(e).replace(' ', '%20')}", status_code=status.HTTP_303_SEE_OTHER) | |
| def delete_test_result_type(result_type_id: int, request: Request, session: Session = Depends(get_session)): | |
| if not require_permission(request, session, "test_result_types", "delete"): | |
| return RedirectResponse(url="/test-result-types?error=Permission Denied", status_code=status.HTTP_303_SEE_OTHER) | |
| try: | |
| current_user = get_current_user(request, session) | |
| rt = session.get(TestResultType, result_type_id) | |
| if rt: | |
| old_values = model_to_dict(rt) | |
| session.delete(rt) | |
| session.commit() | |
| create_audit_log(session, "testresulttype", rt.id, "delete", current_user, old_values=old_values) | |
| return RedirectResponse(url="/test-result-types?success=Result type deleted successfully!", status_code=status.HTTP_303_SEE_OTHER) | |
| return RedirectResponse(url="/test-result-types?error=Result type not found", status_code=status.HTTP_303_SEE_OTHER) | |
| except Exception as e: | |
| session.rollback() | |
| return RedirectResponse(url=f"/test-result-types?error={str(e).replace(' ', '%20')}", status_code=status.HTTP_303_SEE_OTHER) | |
| # =========================== | |
| # PACKAGE ROUTES (N+1 FIX: selectinload) | |
| # =========================== | |
| def packages_page(request: Request, session: Session = Depends(get_session)): | |
| if not require_permission(request, session, "packages"): | |
| return RedirectResponse(url="/dashboard?error=Permission Denied", status_code=status.HTTP_303_SEE_OTHER) | |
| # ✅ N+1 FIX: eager-load package_tests in one query | |
| packages = session.exec( | |
| select(Package) | |
| .options(selectinload(Package.package_tests)) | |
| .order_by(Package.id.asc()) | |
| ).all() | |
| packages_json = [] | |
| for pkg in packages: | |
| pkg_dict = model_to_dict(pkg) | |
| test_ids = [pt.test_id for pt in pkg.package_tests] | |
| pkg_dict['test_ids'] = test_ids | |
| packages_json.append(pkg_dict) | |
| tests = session.exec(select(TestDefinition).where(TestDefinition.is_available == True)).all() | |
| success = request.query_params.get("success") | |
| error = request.query_params.get("error") | |
| return templates.TemplateResponse("packages.html", { | |
| "request": request, "packages": packages, "packages_json": packages_json, | |
| "tests": tests, "message_success": success, "message_error": error | |
| }) | |
| def create_package(package_name: str = Form(...), package_short_name: str = Form(...), | |
| price: float = Form(...), package_note: Optional[str] = Form(None), | |
| test_ids: Optional[str] = Form(""), request: Request = None, | |
| session: Session = Depends(get_session)): | |
| if not require_permission(request, session, "packages", "create"): | |
| return RedirectResponse(url="/packages?error=Permission Denied", status_code=status.HTTP_303_SEE_OTHER) | |
| try: | |
| current_user = get_current_user(request, session) | |
| new_package = Package( | |
| package_name=package_name, package_short_name=package_short_name.upper(), | |
| price=price, package_note=package_note, is_active=True, | |
| created_by=current_user.id if current_user else None | |
| ) | |
| session.add(new_package) | |
| session.commit() | |
| session.refresh(new_package) | |
| if test_ids and test_ids.strip(): | |
| test_id_list = [int(t.strip()) for t in test_ids.split(',') if t.strip().isdigit()] | |
| for test_id in test_id_list: | |
| link = PackageTest(package_id=new_package.id, test_id=test_id) | |
| session.add(link) | |
| session.commit() | |
| create_audit_log(session, "package", new_package.id, "create", current_user, new_values=model_to_dict(new_package)) | |
| return RedirectResponse(url="/packages?success=Package saved successfully!", status_code=status.HTTP_303_SEE_OTHER) | |
| except Exception as e: | |
| session.rollback() | |
| return RedirectResponse(url=f"/packages?error={str(e).replace(' ', '%20')}", status_code=status.HTTP_303_SEE_OTHER) | |
| def update_package(package_id: int, package_name: str = Form(...), package_short_name: str = Form(...), | |
| price: float = Form(...), package_note: Optional[str] = Form(None), | |
| test_ids: Optional[str] = Form(""), request: Request = None, | |
| session: Session = Depends(get_session)): | |
| if not require_permission(request, session, "packages", "edit"): | |
| return RedirectResponse(url="/packages?error=Permission Denied", status_code=status.HTTP_303_SEE_OTHER) | |
| try: | |
| current_user = get_current_user(request, session) | |
| pkg = session.get(Package, package_id) | |
| if pkg: | |
| old_values = model_to_dict(pkg) | |
| pkg.package_name = package_name | |
| pkg.package_short_name = package_short_name.upper() | |
| pkg.price = price | |
| pkg.package_note = package_note | |
| pkg.edited_by = current_user.id if current_user else None | |
| pkg.edited_at = datetime.now() | |
| existing_links = session.exec(select(PackageTest).where(PackageTest.package_id == package_id)).all() | |
| for link in existing_links: | |
| session.delete(link) | |
| if test_ids and test_ids.strip(): | |
| test_id_list = [int(t.strip()) for t in test_ids.split(',') if t.strip().isdigit()] | |
| for test_id in test_id_list: | |
| link = PackageTest(package_id=pkg.id, test_id=test_id) | |
| session.add(link) | |
| session.add(pkg) | |
| session.commit() | |
| session.refresh(pkg) | |
| create_audit_log(session, "package", pkg.id, "update", current_user, old_values=old_values, new_values=model_to_dict(pkg)) | |
| return RedirectResponse(url="/packages?success=Package updated successfully!", status_code=status.HTTP_303_SEE_OTHER) | |
| return RedirectResponse(url="/packages?error=Package not found", status_code=status.HTTP_303_SEE_OTHER) | |
| except Exception as e: | |
| session.rollback() | |
| return RedirectResponse(url=f"/packages?error={str(e).replace(' ', '%20')}", status_code=status.HTTP_303_SEE_OTHER) | |
| def delete_package(package_id: int, request: Request, session: Session = Depends(get_session)): | |
| if not require_permission(request, session, "packages", "delete"): | |
| return RedirectResponse(url="/packages?error=Permission Denied", status_code=status.HTTP_303_SEE_OTHER) | |
| try: | |
| current_user = get_current_user(request, session) | |
| pkg = session.get(Package, package_id) | |
| if pkg: | |
| old_values = model_to_dict(pkg) | |
| existing_links = session.exec(select(PackageTest).where(PackageTest.package_id == package_id)).all() | |
| for link in existing_links: | |
| session.delete(link) | |
| session.delete(pkg) | |
| session.commit() | |
| create_audit_log(session, "package", pkg.id, "delete", current_user, old_values=old_values) | |
| return RedirectResponse(url="/packages?success=Package deleted successfully!", status_code=status.HTTP_303_SEE_OTHER) | |
| return RedirectResponse(url="/packages?error=Package not found", status_code=status.HTTP_303_SEE_OTHER) | |
| except Exception as e: | |
| session.rollback() | |
| return RedirectResponse(url=f"/packages?error={str(e).replace(' ', '%20')}", status_code=status.HTTP_303_SEE_OTHER) | |