342 lines
13 KiB
Python
342 lines
13 KiB
Python
"""
|
|
Parking Management Routes
|
|
Parking assignments, spot management, and pool initialization
|
|
|
|
Manager-centric model:
|
|
- Managers own parking spots (defined by manager_parking_quota)
|
|
- Spots are named with manager's letter prefix (A1, A2, B1, B2...)
|
|
- Assignments reference manager_id directly
|
|
"""
|
|
from typing import List
|
|
from datetime import datetime
|
|
from fastapi import APIRouter, Depends, HTTPException
|
|
from pydantic import BaseModel
|
|
from sqlalchemy.orm import Session
|
|
|
|
from database.connection import get_db
|
|
from database.models import DailyParkingAssignment, User
|
|
from utils.auth_middleware import get_current_user, require_manager_or_admin
|
|
from services.parking import initialize_parking_pool, get_spot_display_name
|
|
from services.notifications import notify_parking_assigned, notify_parking_released, notify_parking_reassigned
|
|
from app import config
|
|
|
|
router = APIRouter(prefix="/api/parking", tags=["parking"])
|
|
|
|
|
|
# Request/Response Models
|
|
class InitPoolRequest(BaseModel):
|
|
date: str # YYYY-MM-DD
|
|
|
|
|
|
class ManualAssignRequest(BaseModel):
|
|
manager_id: str
|
|
user_id: str
|
|
spot_id: str
|
|
date: str
|
|
|
|
|
|
class ReassignSpotRequest(BaseModel):
|
|
assignment_id: str
|
|
new_user_id: str | None # None = release spot
|
|
|
|
|
|
class AssignmentResponse(BaseModel):
|
|
id: str
|
|
date: str
|
|
spot_id: str
|
|
spot_display_name: str | None = None
|
|
user_id: str | None
|
|
manager_id: str
|
|
user_name: str | None = None
|
|
user_email: str | None = None
|
|
|
|
|
|
# Routes
|
|
@router.post("/init-manager-pool")
|
|
def init_manager_pool(request: InitPoolRequest, db: Session = Depends(get_db), current_user=Depends(require_manager_or_admin)):
|
|
"""Initialize parking pool for a manager on a given date"""
|
|
try:
|
|
datetime.strptime(request.date, "%Y-%m-%d")
|
|
except ValueError:
|
|
raise HTTPException(status_code=400, detail="Invalid date format")
|
|
|
|
quota = current_user.manager_parking_quota or 0
|
|
if quota == 0:
|
|
return {"success": True, "message": "No parking quota configured", "spots": 0}
|
|
|
|
spots = initialize_parking_pool(current_user.id, quota, request.date, db)
|
|
return {"success": True, "spots": spots}
|
|
|
|
|
|
@router.get("/assignments/{date}", response_model=List[AssignmentResponse])
|
|
def get_assignments(date: str, manager_id: str = None, db: Session = Depends(get_db), current_user=Depends(get_current_user)):
|
|
"""Get parking assignments for a date, optionally filtered by manager"""
|
|
try:
|
|
datetime.strptime(date, "%Y-%m-%d")
|
|
except ValueError:
|
|
raise HTTPException(status_code=400, detail="Invalid date format")
|
|
|
|
query = db.query(DailyParkingAssignment).filter(DailyParkingAssignment.date == date)
|
|
if manager_id:
|
|
query = query.filter(DailyParkingAssignment.manager_id == manager_id)
|
|
|
|
assignments = query.all()
|
|
results = []
|
|
|
|
for assignment in assignments:
|
|
# Get display name using manager's spot prefix
|
|
spot_display_name = get_spot_display_name(assignment.spot_id, assignment.manager_id, db)
|
|
|
|
result = AssignmentResponse(
|
|
id=assignment.id,
|
|
date=assignment.date,
|
|
spot_id=assignment.spot_id,
|
|
spot_display_name=spot_display_name,
|
|
user_id=assignment.user_id,
|
|
manager_id=assignment.manager_id
|
|
)
|
|
|
|
if assignment.user_id:
|
|
user = db.query(User).filter(User.id == assignment.user_id).first()
|
|
if user:
|
|
result.user_name = user.name
|
|
result.user_email = user.email
|
|
|
|
results.append(result)
|
|
|
|
return results
|
|
|
|
|
|
@router.get("/my-assignments", response_model=List[AssignmentResponse])
|
|
def get_my_assignments(start_date: str = None, end_date: str = None, db: Session = Depends(get_db), current_user=Depends(get_current_user)):
|
|
"""Get current user's parking assignments"""
|
|
query = db.query(DailyParkingAssignment).filter(
|
|
DailyParkingAssignment.user_id == current_user.id
|
|
)
|
|
|
|
if start_date:
|
|
query = query.filter(DailyParkingAssignment.date >= start_date)
|
|
if end_date:
|
|
query = query.filter(DailyParkingAssignment.date <= end_date)
|
|
|
|
assignments = query.order_by(DailyParkingAssignment.date.desc()).all()
|
|
results = []
|
|
|
|
for assignment in assignments:
|
|
spot_display_name = get_spot_display_name(assignment.spot_id, assignment.manager_id, db)
|
|
|
|
results.append(AssignmentResponse(
|
|
id=assignment.id,
|
|
date=assignment.date,
|
|
spot_id=assignment.spot_id,
|
|
spot_display_name=spot_display_name,
|
|
user_id=assignment.user_id,
|
|
manager_id=assignment.manager_id,
|
|
user_name=current_user.name,
|
|
user_email=current_user.email
|
|
))
|
|
|
|
return results
|
|
|
|
|
|
@router.post("/manual-assign")
|
|
def manual_assign(data: ManualAssignRequest, db: Session = Depends(get_db), current_user=Depends(require_manager_or_admin)):
|
|
"""Manually assign a spot to a user"""
|
|
# Verify user exists
|
|
user = db.query(User).filter(User.id == data.user_id).first()
|
|
if not user:
|
|
raise HTTPException(status_code=404, detail="User not found")
|
|
|
|
# Verify manager exists and check permission
|
|
manager = db.query(User).filter(User.id == data.manager_id, User.role == "manager").first()
|
|
if not manager:
|
|
raise HTTPException(status_code=404, detail="Manager not found")
|
|
|
|
# Only admin or the manager themselves can assign spots
|
|
if current_user.role != "admin" and current_user.id != data.manager_id:
|
|
raise HTTPException(status_code=403, detail="Not authorized to assign spots for this manager")
|
|
|
|
# Check if spot exists and is free
|
|
spot = db.query(DailyParkingAssignment).filter(
|
|
DailyParkingAssignment.manager_id == data.manager_id,
|
|
DailyParkingAssignment.date == data.date,
|
|
DailyParkingAssignment.spot_id == data.spot_id
|
|
).first()
|
|
|
|
if not spot:
|
|
raise HTTPException(status_code=404, detail="Spot not found")
|
|
if spot.user_id:
|
|
raise HTTPException(status_code=400, detail="Spot already assigned")
|
|
|
|
# Check if user already has a spot for this date (from any manager)
|
|
existing = db.query(DailyParkingAssignment).filter(
|
|
DailyParkingAssignment.date == data.date,
|
|
DailyParkingAssignment.user_id == data.user_id
|
|
).first()
|
|
|
|
if existing:
|
|
raise HTTPException(status_code=400, detail="User already has a spot for this date")
|
|
|
|
spot.user_id = data.user_id
|
|
db.commit()
|
|
|
|
spot_display_name = get_spot_display_name(data.spot_id, data.manager_id, db)
|
|
return {"message": "Spot assigned", "spot_id": data.spot_id, "spot_display_name": spot_display_name}
|
|
|
|
|
|
@router.post("/release-my-spot/{assignment_id}")
|
|
def release_my_spot(assignment_id: str, db: Session = Depends(get_db), current_user=Depends(get_current_user)):
|
|
"""Release a parking spot assigned to the current user"""
|
|
assignment = db.query(DailyParkingAssignment).filter(
|
|
DailyParkingAssignment.id == assignment_id
|
|
).first()
|
|
|
|
if not assignment:
|
|
raise HTTPException(status_code=404, detail="Assignment not found")
|
|
|
|
if assignment.user_id != current_user.id:
|
|
raise HTTPException(status_code=403, detail="You can only release your own parking spot")
|
|
|
|
# Get spot display name for notification
|
|
spot_display_name = get_spot_display_name(assignment.spot_id, assignment.manager_id, db)
|
|
|
|
assignment.user_id = None
|
|
db.commit()
|
|
|
|
# Send notification (self-release, so just confirmation)
|
|
notify_parking_released(current_user, assignment.date, spot_display_name)
|
|
|
|
config.logger.info(f"User {current_user.email} released parking spot {spot_display_name} on {assignment.date}")
|
|
return {"message": "Parking spot released"}
|
|
|
|
|
|
@router.post("/reassign-spot")
|
|
def reassign_spot(data: ReassignSpotRequest, db: Session = Depends(get_db), current_user=Depends(get_current_user)):
|
|
"""Reassign a spot to another user or release it.
|
|
Allowed by: spot owner, their manager, or admin.
|
|
"""
|
|
assignment = db.query(DailyParkingAssignment).filter(
|
|
DailyParkingAssignment.id == data.assignment_id
|
|
).first()
|
|
|
|
if not assignment:
|
|
raise HTTPException(status_code=404, detail="Assignment not found")
|
|
|
|
# Check permission: admin, manager who owns the spot, or current spot holder
|
|
is_admin = current_user.role == 'admin'
|
|
is_spot_owner = assignment.user_id == current_user.id
|
|
is_manager = current_user.id == assignment.manager_id
|
|
|
|
if not (is_admin or is_manager or is_spot_owner):
|
|
raise HTTPException(status_code=403, detail="Not authorized to reassign this spot")
|
|
|
|
# Store old user for notification
|
|
old_user_id = assignment.user_id
|
|
old_user = db.query(User).filter(User.id == old_user_id).first() if old_user_id else None
|
|
|
|
# Get spot display name for notifications
|
|
spot_display_name = get_spot_display_name(assignment.spot_id, assignment.manager_id, db)
|
|
|
|
if data.new_user_id:
|
|
# Check new user exists
|
|
new_user = db.query(User).filter(User.id == data.new_user_id).first()
|
|
if not new_user:
|
|
raise HTTPException(status_code=404, detail="User not found")
|
|
|
|
# Check user doesn't already have a spot for this date
|
|
existing = db.query(DailyParkingAssignment).filter(
|
|
DailyParkingAssignment.user_id == data.new_user_id,
|
|
DailyParkingAssignment.date == assignment.date,
|
|
DailyParkingAssignment.id != assignment.id
|
|
).first()
|
|
|
|
if existing:
|
|
raise HTTPException(status_code=400, detail="User already has a spot for this date")
|
|
|
|
assignment.user_id = data.new_user_id
|
|
|
|
# Send notifications
|
|
# Notify old user that spot was reassigned
|
|
if old_user and old_user.id != new_user.id:
|
|
notify_parking_reassigned(old_user, assignment.date, spot_display_name, new_user.name)
|
|
# Notify new user that spot was assigned
|
|
notify_parking_assigned(new_user, assignment.date, spot_display_name)
|
|
|
|
config.logger.info(f"Parking spot {spot_display_name} on {assignment.date} reassigned from {old_user.email if old_user else 'unassigned'} to {new_user.email}")
|
|
else:
|
|
assignment.user_id = None
|
|
# Notify old user that spot was released
|
|
if old_user:
|
|
notify_parking_released(old_user, assignment.date, spot_display_name)
|
|
|
|
config.logger.info(f"Parking spot {spot_display_name} on {assignment.date} released by {old_user.email if old_user else 'unknown'}")
|
|
|
|
db.commit()
|
|
db.refresh(assignment)
|
|
|
|
# Build response
|
|
spot_display_name = get_spot_display_name(assignment.spot_id, assignment.manager_id, db)
|
|
|
|
result = AssignmentResponse(
|
|
id=assignment.id,
|
|
date=assignment.date,
|
|
spot_id=assignment.spot_id,
|
|
spot_display_name=spot_display_name,
|
|
user_id=assignment.user_id,
|
|
manager_id=assignment.manager_id
|
|
)
|
|
|
|
if assignment.user_id:
|
|
user = db.query(User).filter(User.id == assignment.user_id).first()
|
|
if user:
|
|
result.user_name = user.name
|
|
result.user_email = user.email
|
|
|
|
return result
|
|
|
|
|
|
@router.get("/eligible-users/{assignment_id}")
|
|
def get_eligible_users(assignment_id: str, db: Session = Depends(get_db), current_user=Depends(get_current_user)):
|
|
"""Get users eligible for reassignment of a parking spot.
|
|
Returns users managed by the same manager.
|
|
"""
|
|
assignment = db.query(DailyParkingAssignment).filter(
|
|
DailyParkingAssignment.id == assignment_id
|
|
).first()
|
|
|
|
if not assignment:
|
|
raise HTTPException(status_code=404, detail="Assignment not found")
|
|
|
|
# Check permission: admin, manager who owns the spot, or current spot holder
|
|
is_admin = current_user.role == 'admin'
|
|
is_spot_owner = assignment.user_id == current_user.id
|
|
is_manager = current_user.id == assignment.manager_id
|
|
|
|
if not (is_admin or is_manager or is_spot_owner):
|
|
raise HTTPException(status_code=403, detail="Not authorized")
|
|
|
|
# Get users in this manager's team (including the manager themselves)
|
|
users = db.query(User).filter(
|
|
(User.manager_id == assignment.manager_id) | (User.id == assignment.manager_id),
|
|
User.id != assignment.user_id # Exclude current holder
|
|
).all()
|
|
|
|
# Filter out users who already have a spot for this date
|
|
existing_assignments = db.query(DailyParkingAssignment.user_id).filter(
|
|
DailyParkingAssignment.date == assignment.date,
|
|
DailyParkingAssignment.user_id.isnot(None),
|
|
DailyParkingAssignment.id != assignment.id
|
|
).all()
|
|
users_with_spots = {a[0] for a in existing_assignments}
|
|
|
|
result = []
|
|
for user in users:
|
|
if user.id not in users_with_spots:
|
|
result.append({
|
|
"id": user.id,
|
|
"name": user.name,
|
|
"email": user.email
|
|
})
|
|
|
|
return result
|