Merge branch 'main' into vasu/party-csv-export

Author: notvasub

backend/src/main.py

@@ -1,9 +1,10 @@
 from fastapi import FastAPI, HTTPException, Request
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import JSONResponse
+from src.modules.account.account_router import account_router
 from src.modules.location.location_router import location_router
-from src.modules.student.student_router import student_router
 from src.modules.party.party_router import party_router
+from src.modules.student.student_router import student_router
 
 app = FastAPI()
 
@@ -37,6 +38,7 @@ def read_root():
     return {"message": "Successful Test"}
 
 
+app.include_router(account_router)
 app.include_router(party_router)
 app.include_router(student_router)
 app.include_router(location_router)

backend/src/modules/account/account_router.py

@@ -0,0 +1,66 @@
+from fastapi import APIRouter, Depends, Query
+from src.core.authentication import authenticate_admin
+from src.modules.account.account_model import Account, AccountData, AccountRole
+from src.modules.account.account_service import AccountService
+from src.modules.police.police_model import PoliceAccount, PoliceAccountUpdate
+from src.modules.police.police_service import PoliceService
+
+account_router = APIRouter(prefix="/api/accounts", tags=["accounts"])
+
+
+@account_router.get("/police")
+async def get_police_credentials(
+    police_service: PoliceService = Depends(),
+    _=Depends(authenticate_admin),
+) -> PoliceAccount:
+    police_entity = await police_service.get_police()
+    return PoliceAccount(email=police_entity.email)
+
+
+@account_router.put("/police")
+async def update_police_credentials(
+    data: PoliceAccountUpdate,
+    police_service: PoliceService = Depends(),
+    _=Depends(authenticate_admin),
+) -> PoliceAccount:
+    police_entity = await police_service.update_police(data.email, data.password)
+    return PoliceAccount(email=police_entity.email)
+
+
+@account_router.get("")
+async def list_accounts(
+    role: list[AccountRole] | None = Query(
+        None, description="Filter by role(s): admin, staff, student"
+    ),
+    account_service: AccountService = Depends(),
+    _=Depends(authenticate_admin),
+) -> list[Account]:
+    return await account_service.get_accounts_by_roles(role)
+
+
+@account_router.post("")
+async def create_account(
+    data: AccountData,
+    account_service: AccountService = Depends(),
+    _=Depends(authenticate_admin),
+) -> Account:
+    return await account_service.create_account(data)
+
+
+@account_router.put("/{account_id}")
+async def update_account(
+    account_id: int,
+    data: AccountData,
+    account_service: AccountService = Depends(),
+    _=Depends(authenticate_admin),
+) -> Account:
+    return await account_service.update_account(account_id, data)
+
+
+@account_router.delete("/{account_id}")
+async def delete_account(
+    account_id: int,
+    account_service: AccountService = Depends(),
+    _=Depends(authenticate_admin),
+) -> Account:
+    return await account_service.delete_account(account_id)

backend/src/modules/account/account_service.py

@@ -50,6 +50,18 @@ async def get_accounts(self) -> list[Account]:
         accounts = result.scalars().all()
         return [Account.from_entity(account) for account in accounts]
 
+    async def get_accounts_by_roles(
+        self, roles: list[AccountRole] | None = None
+    ) -> list[Account]:
+        if not roles:
+            return await self.get_accounts()
+
+        result = await self.session.execute(
+            select(AccountEntity).where(AccountEntity.role.in_(roles))
+        )
+        accounts = result.scalars().all()
+        return [Account.from_entity(account) for account in accounts]
+
     async def get_account_by_id(self, account_id: int) -> Account:
         account_entity = await self._get_account_entity_by_id(account_id)
         return Account.from_entity(account_entity)

backend/src/modules/location/location_model.py

@@ -5,6 +5,17 @@
 from src.core.models import PaginatedResponse
 
 
+class AutocompleteInput(BaseModel):
+    # Input for address autocomplete
+    address: str
+
+
+class AutocompleteResult(BaseModel):
+    # Result from Google Maps autocomplete
+    formatted_address: str
+    place_id: str
+
+
 class AddressData(BaseModel):
     # Location data without OCSL-specific fields
     google_place_id: str
@@ -65,9 +76,3 @@ class LocationCreate(BaseModel):
     warning_count: int = 0
     citation_count: int = 0
     hold_expiration: datetime | None = None
-
-
-class AutocompleteResult(BaseModel):
-    # Result from Google Maps autocomplete
-    formatted_address: str
-    place_id: str

backend/src/modules/location/location_router.py

@@ -1,5 +1,10 @@
-from fastapi import APIRouter, Depends
-from src.core.authentication import authenticate_admin, authenticate_staff_or_admin
+from fastapi import APIRouter, Depends, HTTPException, status
+from src.core.authentication import (
+    authenticate_admin,
+    authenticate_staff_or_admin,
+    authenticate_user,
+)
+from src.modules.account.account_model import Account
 from src.modules.location.location_model import (
     Location,
     LocationCreate,
@@ -8,9 +13,43 @@
 )
 from src.modules.location.location_service import LocationService
 
+from .location_model import AutocompleteInput, AutocompleteResult
+
 location_router = APIRouter(prefix="/api/locations", tags=["locations"])
 
 
+@location_router.post(
+    "/autocomplete",
+    response_model=list[AutocompleteResult],
+    status_code=status.HTTP_200_OK,
+    summary="Autocomplete address search",
+    description="Returns address suggestions based on user input using Google Maps Places API.",
+)
+async def autocomplete_address(
+    input_data: AutocompleteInput,
+    location_service: LocationService = Depends(),
+    user: Account = Depends(authenticate_user),
+) -> list[AutocompleteResult]:
+    """
+    Autocomplete address search endpoint.
+    """
+    try:
+        results = await location_service.autocomplete_address(input_data.address)
+        return results
+    except ValueError as e:
+        # Handle validation errors from service
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=str(e),
+        )
+    except Exception:
+        # Log error in production
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to fetch address suggestions. Please try again later.",
+        )
+
+
 @location_router.get("/", response_model=PaginatedLocationResponse)
 async def get_locations(
     location_service: LocationService = Depends(),