294 lines
8.9 KiB
Python
294 lines
8.9 KiB
Python
from fastapi import APIRouter, Depends, HTTPException, Query
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
from sqlalchemy import select, desc, func
|
|
from pydantic import BaseModel
|
|
from typing import Optional, List
|
|
from datetime import datetime, timedelta, timezone
|
|
|
|
from app.core.database import get_db
|
|
from app.core.security import get_current_user
|
|
from app.models.user import User, NamedRoute, Activity
|
|
|
|
router = APIRouter()
|
|
|
|
|
|
class RouteCreate(BaseModel):
|
|
name: str
|
|
description: Optional[str] = None
|
|
sport_type: Optional[str] = None
|
|
activity_id: int
|
|
|
|
|
|
class RouteUpdate(BaseModel):
|
|
name: Optional[str] = None
|
|
sport_type: Optional[str] = None
|
|
|
|
|
|
class RouteOut(BaseModel):
|
|
id: int
|
|
name: str
|
|
description: Optional[str]
|
|
sport_type: Optional[str]
|
|
reference_polyline: Optional[str]
|
|
bounding_box: Optional[dict]
|
|
distance_m: Optional[float]
|
|
auto_detected: Optional[bool]
|
|
created_at: datetime
|
|
activity_count: int = 0
|
|
last_activity_at: Optional[datetime] = None
|
|
|
|
class Config:
|
|
from_attributes = True
|
|
|
|
|
|
@router.get("/", response_model=List[RouteOut])
|
|
async def list_routes(
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
):
|
|
# Fetch routes with activity counts and last-completed time in one query
|
|
agg_subq = (
|
|
select(
|
|
Activity.named_route_id,
|
|
func.count(Activity.id).label("cnt"),
|
|
func.max(Activity.start_time).label("last_at"),
|
|
)
|
|
.where(Activity.user_id == current_user.id, Activity.named_route_id.isnot(None))
|
|
.group_by(Activity.named_route_id)
|
|
.subquery()
|
|
)
|
|
result = await db.execute(
|
|
select(
|
|
NamedRoute,
|
|
func.coalesce(agg_subq.c.cnt, 0).label("activity_count"),
|
|
agg_subq.c.last_at.label("last_activity_at"),
|
|
)
|
|
.outerjoin(agg_subq, NamedRoute.id == agg_subq.c.named_route_id)
|
|
.where(NamedRoute.user_id == current_user.id)
|
|
.order_by(desc(NamedRoute.created_at))
|
|
)
|
|
rows = result.all()
|
|
out = []
|
|
for route, cnt, last_at in rows:
|
|
d = {c.name: getattr(route, c.name) for c in route.__table__.columns}
|
|
d["activity_count"] = cnt
|
|
d["last_activity_at"] = last_at
|
|
out.append(RouteOut(**d))
|
|
return out
|
|
|
|
|
|
@router.get("/recent-activities")
|
|
async def recent_activities_for_route(
|
|
days: int = Query(14, ge=1, le=90),
|
|
sport_type: Optional[str] = None,
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
):
|
|
"""Return recent activities for the route creation dropdown."""
|
|
cutoff = datetime.now(timezone.utc) - timedelta(days=days)
|
|
q = select(Activity).where(
|
|
Activity.user_id == current_user.id,
|
|
Activity.start_time >= cutoff,
|
|
Activity.sport_type != "swimming",
|
|
)
|
|
if sport_type:
|
|
q = q.where(Activity.sport_type == sport_type)
|
|
q = q.order_by(desc(Activity.start_time)).limit(50)
|
|
result = await db.execute(q)
|
|
activities = result.scalars().all()
|
|
return [
|
|
{
|
|
"id": a.id,
|
|
"name": a.name,
|
|
"sport_type": a.sport_type,
|
|
"start_time": a.start_time,
|
|
"distance_m": a.distance_m,
|
|
"duration_s": a.duration_s,
|
|
}
|
|
for a in activities
|
|
]
|
|
|
|
|
|
@router.post("/", response_model=RouteOut)
|
|
async def create_route(
|
|
body: RouteCreate,
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
):
|
|
act_result = await db.execute(
|
|
select(Activity).where(
|
|
Activity.id == body.activity_id,
|
|
Activity.user_id == current_user.id,
|
|
)
|
|
)
|
|
activity = act_result.scalar_one_or_none()
|
|
if not activity:
|
|
raise HTTPException(status_code=404, detail="Activity not found")
|
|
|
|
route = NamedRoute(
|
|
user_id=current_user.id,
|
|
name=body.name,
|
|
description=body.description,
|
|
sport_type=body.sport_type or activity.sport_type,
|
|
reference_polyline=activity.polyline,
|
|
bounding_box=activity.bounding_box,
|
|
distance_m=activity.distance_m,
|
|
auto_detected=False,
|
|
)
|
|
db.add(route)
|
|
await db.flush()
|
|
activity.named_route_id = route.id
|
|
await db.commit()
|
|
await db.refresh(route)
|
|
return route
|
|
|
|
|
|
@router.get("/{route_id}", response_model=RouteOut)
|
|
async def get_route(
|
|
route_id: int,
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
):
|
|
result = await db.execute(
|
|
select(NamedRoute).where(
|
|
NamedRoute.id == route_id,
|
|
NamedRoute.user_id == current_user.id,
|
|
)
|
|
)
|
|
route = result.scalar_one_or_none()
|
|
if not route:
|
|
raise HTTPException(status_code=404, detail="Route not found")
|
|
return route
|
|
|
|
|
|
@router.patch("/{route_id}", response_model=RouteOut)
|
|
async def update_route(
|
|
route_id: int,
|
|
body: RouteUpdate,
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
):
|
|
result = await db.execute(
|
|
select(NamedRoute).where(
|
|
NamedRoute.id == route_id,
|
|
NamedRoute.user_id == current_user.id,
|
|
)
|
|
)
|
|
route = result.scalar_one_or_none()
|
|
if not route:
|
|
raise HTTPException(status_code=404, detail="Route not found")
|
|
if body.name is not None and body.name.strip():
|
|
route.name = body.name.strip()
|
|
# A user-given name makes this a custom route (moves it out of the
|
|
# auto-detected group on the routes page).
|
|
route.auto_detected = False
|
|
if body.sport_type is not None:
|
|
route.sport_type = body.sport_type
|
|
await db.commit()
|
|
await db.refresh(route)
|
|
return route
|
|
|
|
|
|
@router.get("/{route_id}/activities")
|
|
async def route_activities(
|
|
route_id: int,
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
):
|
|
result = await db.execute(
|
|
select(Activity).where(
|
|
Activity.named_route_id == route_id,
|
|
Activity.user_id == current_user.id,
|
|
).order_by(Activity.duration_s)
|
|
)
|
|
activities = result.scalars().all()
|
|
return [
|
|
{
|
|
"id": a.id,
|
|
"name": a.name,
|
|
"start_time": a.start_time,
|
|
"duration_s": a.duration_s,
|
|
"distance_m": a.distance_m,
|
|
"avg_heart_rate": a.avg_heart_rate,
|
|
"avg_speed_ms": a.avg_speed_ms,
|
|
}
|
|
for a in activities
|
|
]
|
|
|
|
|
|
@router.post("/{route_id}/merge/{source_id}", response_model=RouteOut)
|
|
async def merge_routes(
|
|
route_id: int,
|
|
source_id: int,
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
):
|
|
"""Move all activities from source route into route_id, then delete source route."""
|
|
from sqlalchemy import update
|
|
|
|
target = (await db.execute(
|
|
select(NamedRoute).where(NamedRoute.id == route_id, NamedRoute.user_id == current_user.id)
|
|
)).scalar_one_or_none()
|
|
source = (await db.execute(
|
|
select(NamedRoute).where(NamedRoute.id == source_id, NamedRoute.user_id == current_user.id)
|
|
)).scalar_one_or_none()
|
|
if not target or not source:
|
|
raise HTTPException(status_code=404, detail="Route not found")
|
|
if route_id == source_id:
|
|
raise HTTPException(status_code=400, detail="Cannot merge a route with itself")
|
|
|
|
await db.execute(
|
|
update(Activity)
|
|
.where(Activity.named_route_id == source_id, Activity.user_id == current_user.id)
|
|
.values(named_route_id=route_id)
|
|
)
|
|
await db.delete(source)
|
|
await db.commit()
|
|
await db.refresh(target)
|
|
return target
|
|
|
|
|
|
@router.delete("/{route_id}")
|
|
async def delete_route(
|
|
route_id: int,
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
):
|
|
from sqlalchemy import update as sa_update
|
|
route = (await db.execute(
|
|
select(NamedRoute).where(NamedRoute.id == route_id, NamedRoute.user_id == current_user.id)
|
|
)).scalar_one_or_none()
|
|
if not route:
|
|
raise HTTPException(status_code=404, detail="Route not found")
|
|
# Unlink activities before deleting
|
|
await db.execute(
|
|
sa_update(Activity)
|
|
.where(Activity.named_route_id == route_id, Activity.user_id == current_user.id)
|
|
.values(named_route_id=None)
|
|
)
|
|
await db.delete(route)
|
|
await db.commit()
|
|
return {"status": "ok"}
|
|
|
|
|
|
@router.post("/{route_id}/assign-activity")
|
|
async def assign_activity_to_route(
|
|
route_id: int,
|
|
body: dict,
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
):
|
|
activity_id = body.get("activity_id")
|
|
act_result = await db.execute(
|
|
select(Activity).where(
|
|
Activity.id == activity_id,
|
|
Activity.user_id == current_user.id,
|
|
)
|
|
)
|
|
activity = act_result.scalar_one_or_none()
|
|
if not activity:
|
|
raise HTTPException(status_code=404, detail="Activity not found")
|
|
activity.named_route_id = route_id
|
|
await db.commit()
|
|
return {"status": "ok"}
|