init

app/routers/activities.py

@@ -0,0 +1,77 @@
+import uuid
+
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlmodel import Session, select
+
+from app.database import get_session
+from app.models.user import User
+from app.models.activity import Activity
+from app.models.zone import Zone
+from app.schemas.activity import ActivityCreate, ActivityRead, ActivityDetail
+from app.auth.dependencies import get_current_user
+from app.services.geo_pipeline import process_activity
+
+router = APIRouter(prefix="/activities", tags=["activities"])
+
+
+@router.post("", response_model=ActivityDetail, status_code=status.HTTP_201_CREATED)
+def create_activity(
+    body: ActivityCreate,
+    current_user: User = Depends(get_current_user),
+    session: Session = Depends(get_session),
+):
+    """Upload a GPS track and trigger the zone computation pipeline."""
+    result = process_activity(
+        user_id=current_user.id,
+        activity_type=body.type,
+        started_at=body.started_at,
+        ended_at=body.ended_at,
+        gps_track=body.gps_track,
+        session=session,
+    )
+    return result
+
+
+@router.get("", response_model=list[ActivityRead])
+def list_activities(
+    current_user: User = Depends(get_current_user),
+    session: Session = Depends(get_session),
+    limit: int = 50,
+    offset: int = 0,
+):
+    """List current user's activities."""
+    activities = session.exec(
+        select(Activity)
+        .where(Activity.user_id == current_user.id)
+        .order_by(Activity.created_at.desc())  # type: ignore[union-attr]
+        .offset(offset)
+        .limit(limit)
+    ).all()
+    return activities
+
+
+@router.get("/{activity_id}", response_model=ActivityDetail)
+def get_activity(
+    activity_id: uuid.UUID,
+    current_user: User = Depends(get_current_user),
+    session: Session = Depends(get_session),
+):
+    activity = session.get(Activity, activity_id)
+    if not activity or activity.user_id != current_user.id:
+        raise HTTPException(status_code=404, detail="Activity not found")
+
+    # Find associated zone
+    zone = session.exec(select(Zone).where(Zone.activity_id == activity_id)).first()
+
+    return ActivityDetail(
+        id=activity.id,
+        user_id=activity.user_id,
+        type=activity.type,
+        started_at=activity.started_at,
+        ended_at=activity.ended_at,
+        distance_m=activity.distance_m,
+        status=activity.status,
+        created_at=activity.created_at,
+        zone_id=zone.id if zone else None,
+        area_m2=zone.area_m2 if zone else None,
+    )

app/routers/auth.py

@@ -0,0 +1,76 @@
+import uuid
+
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlmodel import Session, select
+
+from app.database import get_session
+from app.models.user import User
+from app.schemas.user import (
+    UserCreate,
+    UserRead,
+    LoginRequest,
+    TokenResponse,
+    RefreshRequest,
+)
+from app.auth.jwt import (
+    hash_password,
+    verify_password,
+    create_access_token,
+    create_refresh_token,
+    decode_token,
+)
+
+router = APIRouter(prefix="/auth", tags=["auth"])
+
+
+@router.post("/register", response_model=UserRead, status_code=status.HTTP_201_CREATED)
+def register(body: UserCreate, session: Session = Depends(get_session)):
+    # Check username uniqueness
+    existing = session.exec(select(User).where(User.username == body.username)).first()
+    if existing:
+        raise HTTPException(status_code=400, detail="Username already taken")
+
+    # Check email uniqueness
+    existing = session.exec(select(User).where(User.email == body.email)).first()
+    if existing:
+        raise HTTPException(status_code=400, detail="Email already registered")
+
+    user = User(
+        username=body.username,
+        email=body.email,
+        password_hash=hash_password(body.password),
+    )
+    session.add(user)
+    session.commit()
+    session.refresh(user)
+    return user
+
+
+@router.post("/login", response_model=TokenResponse)
+def login(body: LoginRequest, session: Session = Depends(get_session)):
+    user = session.exec(select(User).where(User.username == body.username)).first()
+    if not user or not verify_password(body.password, user.password_hash):
+        raise HTTPException(status_code=401, detail="Invalid credentials")
+
+    access_token = create_access_token({"sub": str(user.id)})
+    refresh_token = create_refresh_token({"sub": str(user.id)})
+    return TokenResponse(access_token=access_token, refresh_token=refresh_token)
+
+
+@router.post("/refresh", response_model=TokenResponse)
+def refresh(body: RefreshRequest, session: Session = Depends(get_session)):
+    try:
+        payload = decode_token(body.refresh_token)
+        if payload.get("type") != "refresh":
+            raise HTTPException(status_code=401, detail="Invalid token type")
+        user_id = uuid.UUID(payload["sub"])
+    except Exception:
+        raise HTTPException(status_code=401, detail="Invalid refresh token")
+
+    user = session.get(User, user_id)
+    if not user:
+        raise HTTPException(status_code=401, detail="User not found")
+
+    access_token = create_access_token({"sub": str(user.id)})
+    refresh_token = create_refresh_token({"sub": str(user.id)})
+    return TokenResponse(access_token=access_token, refresh_token=refresh_token)

app/routers/friends.py

@@ -0,0 +1,91 @@
+import uuid
+
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlmodel import Session, select
+
+from app.database import get_session
+from app.models.user import User
+from app.models.friendship import Friendship
+from app.schemas.user import UserRead
+from app.auth.dependencies import get_current_user
+
+router = APIRouter(prefix="/friends", tags=["friends"])
+
+
+@router.post("", status_code=status.HTTP_201_CREATED)
+def add_friend(
+    username: str,
+    current_user: User = Depends(get_current_user),
+    session: Session = Depends(get_session),
+):
+    """Add a friend by username. Creates bidirectional friendship."""
+    friend = session.exec(select(User).where(User.username == username)).first()
+    if not friend:
+        raise HTTPException(status_code=404, detail="User not found")
+    if friend.id == current_user.id:
+        raise HTTPException(status_code=400, detail="Cannot add yourself")
+
+    # Check if already friends
+    existing = session.exec(
+        select(Friendship).where(
+            Friendship.user_id == current_user.id,
+            Friendship.friend_id == friend.id,
+        )
+    ).first()
+    if existing:
+        raise HTTPException(status_code=400, detail="Already friends")
+
+    # Bidirectional
+    session.add(Friendship(user_id=current_user.id, friend_id=friend.id))
+    session.add(Friendship(user_id=friend.id, friend_id=current_user.id))
+    session.commit()
+
+    return {"detail": f"Now friends with {friend.username}"}
+
+
+@router.get("", response_model=list[UserRead])
+def list_friends(
+    current_user: User = Depends(get_current_user),
+    session: Session = Depends(get_session),
+):
+    """List all friends of the current user."""
+    friend_ids = session.exec(
+        select(Friendship.friend_id).where(Friendship.user_id == current_user.id)
+    ).all()
+
+    if not friend_ids:
+        return []
+
+    friends = session.exec(
+        select(User).where(User.id.in_(friend_ids))  # type: ignore[union-attr]
+    ).all()
+    return friends
+
+
+@router.delete("/{friend_id}", status_code=status.HTTP_204_NO_CONTENT)
+def remove_friend(
+    friend_id: uuid.UUID,
+    current_user: User = Depends(get_current_user),
+    session: Session = Depends(get_session),
+):
+    """Remove a friend (bidirectional)."""
+    f1 = session.exec(
+        select(Friendship).where(
+            Friendship.user_id == current_user.id,
+            Friendship.friend_id == friend_id,
+        )
+    ).first()
+    f2 = session.exec(
+        select(Friendship).where(
+            Friendship.user_id == friend_id,
+            Friendship.friend_id == current_user.id,
+        )
+    ).first()
+
+    if not f1:
+        raise HTTPException(status_code=404, detail="Friendship not found")
+
+    session.delete(f1)
+    if f2:
+        session.delete(f2)
+    session.commit()

app/routers/leaderboard.py

@@ -0,0 +1,73 @@
+from fastapi import APIRouter, Depends
+from sqlmodel import Session, select, func
+
+from app.database import get_session
+from app.models.user import User
+from app.models.zone import Zone
+from app.models.score import Score
+from app.models.friendship import Friendship
+from app.schemas.score import LeaderboardEntry
+from app.auth.dependencies import get_current_user
+
+router = APIRouter(prefix="/leaderboard", tags=["leaderboard"])
+
+
+@router.get("", response_model=list[LeaderboardEntry])
+def get_leaderboard(
+    current_user: User = Depends(get_current_user),
+    session: Session = Depends(get_session),
+):
+    """Friend leaderboard sorted by total points.
+
+    Includes the current user and all their friends.
+    """
+    # Get friend IDs + self
+    friend_ids = list(
+        session.exec(
+            select(Friendship.friend_id).where(Friendship.user_id == current_user.id)
+        ).all()
+    )
+    user_ids = friend_ids + [current_user.id]
+
+    entries: list[LeaderboardEntry] = []
+    for uid in user_ids:
+        user = session.get(User, uid)
+        if not user:
+            continue
+
+        # Latest score
+        latest_score = session.exec(
+            select(Score).where(Score.user_id == uid).order_by(Score.date.desc())  # type: ignore[union-attr]
+        ).first()
+        total_pts = latest_score.total_pts if latest_score else 0
+
+        # Total area
+        total_area = session.exec(
+            select(func.coalesce(func.sum(Zone.area_m2), 0.0)).where(
+                Zone.owner_id == uid
+            )
+        ).one()
+
+        # Zone count
+        zone_count = session.exec(
+            select(func.count()).select_from(Zone).where(Zone.owner_id == uid)
+        ).one()
+
+        entries.append(
+            LeaderboardEntry(
+                user_id=uid,
+                username=user.username,
+                avatar_url=user.avatar_url,
+                total_pts=total_pts,
+                total_area_m2=float(total_area),
+                zone_count=zone_count,
+                rank=0,  # calculated below
+            )
+        )
+
+    # Sort by total_pts descending, assign rank
+    entries.sort(key=lambda e: e.total_pts, reverse=True)
+    for i, entry in enumerate(entries):
+        entry.rank = i + 1
+
+    return entries

app/routers/users.py

@@ -0,0 +1,91 @@
+import uuid
+
+from fastapi import APIRouter, Depends, HTTPException
+from sqlmodel import Session, select, func
+
+from app.database import get_session
+from app.models.user import User
+from app.models.zone import Zone
+from app.models.activity import Activity
+from app.models.score import Score
+from app.schemas.user import UserRead, UserUpdate, UserStats
+from app.auth.dependencies import get_current_user
+
+router = APIRouter(prefix="/users", tags=["users"])
+
+
+@router.get("/me", response_model=UserRead)
+def get_me(current_user: User = Depends(get_current_user)):
+    return current_user
+
+
+@router.patch("/me", response_model=UserRead)
+def update_me(
+    body: UserUpdate,
+    current_user: User = Depends(get_current_user),
+    session: Session = Depends(get_session),
+):
+    if body.username is not None:
+        existing = session.exec(
+            select(User).where(
+                User.username == body.username, User.id != current_user.id
+            )
+        ).first()
+        if existing:
+            raise HTTPException(status_code=400, detail="Username already taken")
+        current_user.username = body.username
+    if body.avatar_url is not None:
+        current_user.avatar_url = body.avatar_url
+    if body.fcm_token is not None:
+        current_user.fcm_token = body.fcm_token
+
+    session.add(current_user)
+    session.commit()
+    session.refresh(current_user)
+    return current_user
+
+
+@router.get("/{user_id}/stats", response_model=UserStats)
+def get_user_stats(
+    user_id: uuid.UUID,
+    current_user: User = Depends(get_current_user),
+    session: Session = Depends(get_session),
+):
+    user = session.get(User, user_id)
+    if not user:
+        raise HTTPException(status_code=404, detail="User not found")
+
+    # Total area
+    total_area = session.exec(
+        select(func.coalesce(func.sum(Zone.area_m2), 0.0)).where(
+            Zone.owner_id == user_id
+        )
+    ).one()
+
+    # Zone count
+    zone_count = session.exec(
+        select(func.count()).select_from(Zone).where(Zone.owner_id == user_id)
+    ).one()
+
+    # Activity count
+    activity_count = session.exec(
+        select(func.count())
+        .select_from(Activity)
+        .where(Activity.user_id == user_id, Activity.status == "completed")
+    ).one()
+
+    # Total points (latest score)
+    latest_score = session.exec(
+        select(Score).where(Score.user_id == user_id).order_by(Score.date.desc())  # type: ignore[union-attr]
+    ).first()
+    total_pts = latest_score.total_pts if latest_score else 0
+
+    return UserStats(
+        id=user.id,
+        username=user.username,
+        avatar_url=user.avatar_url,
+        total_area_m2=float(total_area),
+        total_points=total_pts,
+        zone_count=zone_count,
+        activity_count=activity_count,
+    )

app/routers/zones.py

@@ -0,0 +1,86 @@
+import uuid
+import json
+
+from fastapi import APIRouter, Depends, HTTPException
+from sqlmodel import Session, select
+
+from app.database import get_session
+from app.models.user import User
+from app.models.zone import Zone
+from app.models.friendship import Friendship
+from app.schemas.zone import ZoneRead, ZoneBrief
+from app.auth.dependencies import get_current_user
+from app.services.geo_pipeline import wkt_to_geojson
+
+router = APIRouter(prefix="/zones", tags=["zones"])
+
+
+@router.get("", response_model=list[ZoneBrief])
+def list_my_zones(
+    current_user: User = Depends(get_current_user),
+    session: Session = Depends(get_session),
+):
+    """Return all zones owned by the current user."""
+    zones = session.exec(select(Zone).where(Zone.owner_id == current_user.id)).all()
+    return [
+        ZoneBrief(
+            id=z.id,
+            owner_id=z.owner_id,
+            polygon_geojson=wkt_to_geojson(z.polygon_wkt),
+            area_m2=z.area_m2,
+            defense_level=z.defense_level,
+        )
+        for z in zones
+    ]
+
+
+@router.get("/friends", response_model=list[ZoneBrief])
+def list_friend_zones(
+    current_user: User = Depends(get_current_user),
+    session: Session = Depends(get_session),
+):
+    """Return all zones owned by friends of the current user."""
+    friend_ids = session.exec(
+        select(Friendship.friend_id).where(Friendship.user_id == current_user.id)
+    ).all()
+
+    if not friend_ids:
+        return []
+
+    zones = session.exec(
+        select(Zone).where(Zone.owner_id.in_(friend_ids))  # type: ignore[union-attr]
+    ).all()
+
+    return [
+        ZoneBrief(
+            id=z.id,
+            owner_id=z.owner_id,
+            polygon_geojson=wkt_to_geojson(z.polygon_wkt),
+            area_m2=z.area_m2,
+            defense_level=z.defense_level,
+        )
+        for z in zones
+    ]
+
+
+@router.get("/{zone_id}", response_model=ZoneRead)
+def get_zone(
+    zone_id: uuid.UUID,
+    current_user: User = Depends(get_current_user),
+    session: Session = Depends(get_session),
+):
+    zone = session.get(Zone, zone_id)
+    if not zone:
+        raise HTTPException(status_code=404, detail="Zone not found")
+
+    return ZoneRead(
+        id=zone.id,
+        owner_id=zone.owner_id,
+        activity_id=zone.activity_id,
+        polygon_geojson=wkt_to_geojson(zone.polygon_wkt),
+        area_m2=zone.area_m2,
+        defense_level=zone.defense_level,
+        defense_runs=zone.defense_runs,
+        created_at=zone.created_at,
+        last_reinforced_at=zone.last_reinforced_at,
+    )