| from typing import Any, Optional |
| from datetime import date, time |
|
|
|
|
| class AppException(Exception): |
| status_code: int = 500 |
| error_code: str = "internal_error" |
| |
| def __init__( |
| self, |
| message: str, |
| details: Optional[dict[str, Any]] = None, |
| error_code: Optional[str] = None, |
| ): |
| self.message = message |
| self.details = details or {} |
| if error_code: |
| self.error_code = error_code |
| super().__init__(message) |
| |
| def to_dict(self) -> dict[str, Any]: |
| response = { |
| "error": self.error_code, |
| "message": self.message, |
| } |
| if self.details: |
| response["details"] = self.details |
| return response |
|
|
|
|
| class ValidationError(AppException): |
| status_code = 400 |
| error_code = "validation_error" |
| |
| def __init__( |
| self, |
| message: str, |
| field: Optional[str] = None, |
| invalid_values: Optional[list] = None, |
| **kwargs, |
| ): |
| details = {} |
| if field: |
| details["field"] = field |
| if invalid_values: |
| details["invalid_values"] = invalid_values |
| super().__init__(message, details=details, **kwargs) |
|
|
|
|
| class EntityNotFoundError(ValidationError): |
| error_code = "entity_not_found" |
| |
| def __init__( |
| self, |
| entity_type: str, |
| entity_id: Optional[int] = None, |
| entity_ids: Optional[list[int]] = None, |
| ): |
| if entity_ids: |
| message = f"{entity_type}(s) not found: {sorted(entity_ids)}" |
| details = {"entity_type": entity_type, "missing_ids": sorted(entity_ids)} |
| else: |
| message = f"{entity_type} with ID {entity_id} not found" |
| details = {"entity_type": entity_type, "id": entity_id} |
| |
| super().__init__(message, details=details) |
|
|
|
|
| class NotFoundError(AppException): |
| status_code = 404 |
| error_code = "not_found" |
| |
| def __init__( |
| self, |
| resource_type: str, |
| resource_id: int, |
| ): |
| message = f"{resource_type} with ID {resource_id} not found" |
| details = {"resource_type": resource_type, "id": resource_id} |
| super().__init__(message, details=details) |
|
|
|
|
| class ConflictError(AppException): |
| status_code = 409 |
| error_code = "conflict" |
| |
| def __init__( |
| self, |
| message: str = "Cannot save class due to scheduling conflicts", |
| conflicts: Optional[list[dict]] = None, |
| ): |
| details = {"conflicts": conflicts or []} |
| super().__init__(message, details=details) |
| |
| def to_dict(self) -> dict[str, Any]: |
| return { |
| "error": self.error_code, |
| "message": self.message, |
| "conflicts": self.details.get("conflicts", []), |
| } |
|
|
|
|
| class ServerError(AppException): |
| status_code = 500 |
| error_code = "internal_server_error" |
| |
| def __init__( |
| self, |
| message: str = "An unexpected error occurred", |
| error_id: Optional[str] = None, |
| original_error: Optional[Exception] = None, |
| ): |
| details = {} |
| if error_id: |
| details["error_id"] = error_id |
| self.original_error = original_error |
| super().__init__(message, details=details) |
|
|
|
|
| class RoomConflictError(ConflictError): |
| |
| def __init__( |
| self, |
| room_name: str, |
| existing_course: str, |
| existing_time: str, |
| suggested_rooms: Optional[list[dict]] = None, |
| ): |
| conflicts = [{ |
| "type": "room", |
| "message": f"Room {room_name} is already booked for {existing_course}", |
| "suggestion": self._build_suggestion(suggested_rooms), |
| }] |
| super().__init__(conflicts=conflicts) |
| |
| @staticmethod |
| def _build_suggestion(suggested_rooms: Optional[list[dict]]) -> str: |
| if not suggested_rooms: |
| return "Try selecting a different room or time slot" |
| room_names = [r["name"] for r in suggested_rooms[:3]] |
| return f"Available rooms: {', '.join(room_names)}" |
|
|
|
|
| class InstructorConflictError(ConflictError): |
| |
| def __init__( |
| self, |
| instructor_name: str, |
| existing_course: str, |
| existing_time: str, |
| ): |
| conflicts = [{ |
| "type": "instructor", |
| "message": f"Instructor {instructor_name} is already teaching {existing_course}", |
| "suggestion": "Try selecting a different instructor or time slot", |
| }] |
| super().__init__(conflicts=conflicts) |
|
|
|
|
| class StudentConflictError(ConflictError): |
| pass |
|
|
|
|
| class CapacityConflictError(ConflictError): |
| |
| def __init__( |
| self, |
| room_name: str, |
| capacity: int, |
| student_count: int, |
| suggested_rooms: Optional[list[dict]] = None, |
| ): |
| conflicts = [{ |
| "type": "capacity", |
| "message": f"Room {room_name} has capacity {capacity}, but {student_count} students enrolled", |
| "suggestion": self._build_suggestion(suggested_rooms, student_count), |
| }] |
| super().__init__(conflicts=conflicts) |
| |
| @staticmethod |
| def _build_suggestion(suggested_rooms: Optional[list[dict]], student_count: int) -> str: |
| if not suggested_rooms: |
| return f"Select a room with capacity >= {student_count} or reduce enrollment" |
| suitable = [r for r in suggested_rooms if r.get("capacity", 0) >= student_count] |
| if suitable: |
| room_names = [f"{r['name']} (cap: {r['capacity']})" for r in suitable[:3]] |
| return f"Rooms with sufficient capacity: {', '.join(room_names)}" |
| return f"No available rooms with capacity >= {student_count}. Reduce enrollment." |
|
|
