Implemented Radius Search Route (#70)

* Implemented Radius Search Route

* fixed tests to use mock

* hopefully fixed mocks

* Fised broken tests from merge

* Added tests for get_parties_by_radius_and_date_range(), changed config to 0.25

* Add untracked files before merge

* 🙏

* Fixed tests

* fixes

* Fixed tests

* fix: reverted student tests

---------

Co-authored-by: Vasu <[email protected]>
Co-authored-by: Nick A <[email protected]>

Author: notvasub

backend/src/core/config.py

@@ -21,7 +21,7 @@ class Config(BaseSettings):
     POSTGRES_HOST: str = "db"
     POSTGRES_PORT: int = 5432
     HOST: str = "localhost"
-    PARTY_SEARCH_RADIUS_MILES: float = 3.0
+    PARTY_SEARCH_RADIUS_MILES: float = 0.25
     GOOGLE_MAPS_API_KEY: str
 
 

backend/src/modules/party/party_router.py

@@ -5,11 +5,13 @@
 from src.core.authentication import (
     authenticate_admin,
     authenticate_by_role,
+    authenticate_police_or_admin,
     authenticate_staff_or_admin,
     authenticate_user,
 )
-from src.core.exceptions import ForbiddenException
+from src.core.exceptions import BadRequestException, ForbiddenException
 from src.modules.account.account_model import Account, AccountRole
+from src.modules.location.location_service import LocationService
 
 from .party_model import (
     AdminCreatePartyDTO,
@@ -115,6 +117,59 @@ async def list_parties(
     )
 
 
+@party_router.get("/nearby")
+async def get_parties_nearby(
+    place_id: str = Query(..., description="Google Maps place ID"),
+    start_date: str = Query(..., description="Start date (YYYY-MM-DD format)"),
+    end_date: str = Query(..., description="End date (YYYY-MM-DD format)"),
+    party_service: PartyService = Depends(),
+    location_service: LocationService = Depends(),
+    _=Depends(authenticate_police_or_admin),
+) -> list[Party]:
+    """
+    Returns parties within a radius of a location specified by Google Maps place ID,
+    filtered by date range.
+
+    Query Parameters:
+    - place_id: Google Maps place ID from autocomplete selection
+    - start_date: Start date for the search range (YYYY-MM-DD format)
+    - end_date: End date for the search range (YYYY-MM-DD format)
+
+    Returns:
+    - List of parties within the search radius and date range
+
+    Raises:
+    - 400: If place ID is invalid or dates are in wrong format
+    - 404: If place ID is not found
+    - 403: If user is not a police officer or admin
+    """
+    # Parse date strings to datetime objects
+    try:
+        start_datetime = datetime.strptime(start_date, "%Y-%m-%d")
+        end_datetime = datetime.strptime(end_date, "%Y-%m-%d")
+        # Set end_datetime to end of day (23:59:59)
+        end_datetime = end_datetime.replace(hour=23, minute=59, second=59)
+    except ValueError as e:
+        raise BadRequestException(f"Invalid date format. Expected YYYY-MM-DD: {str(e)}")
+
+    # Validate that start_date is not greater than end_date
+    if start_datetime > end_datetime:
+        raise BadRequestException("Start date must be less than or equal to end date")
+
+    # Get location coordinates from place ID
+    location_data = await location_service.get_place_details(place_id)
+
+    # Perform proximity search with date range
+    parties = await party_service.get_parties_by_radius_and_date_range(
+        latitude=location_data.latitude,
+        longitude=location_data.longitude,
+        start_date=start_datetime,
+        end_date=end_datetime,
+    )
+
+    return parties
+
+
 @party_router.get("/csv")
 async def get_parties_csv(
     start_date: str = Query(..., description="Start date in YYYY-MM-DD format"),
@@ -148,6 +203,13 @@ async def get_parties_csv(
             detail="Invalid date format. Use YYYY-MM-DD format for dates.",
         )
 
+    # Validate that start_date is not greater than end_date
+    if start_datetime > end_datetime:
+        raise HTTPException(
+            status_code=400,
+            detail="Start date must be less than or equal to end date",
+        )
+
     parties = await party_service.get_parties_by_date_range(
         start_datetime, end_datetime
     )

backend/src/modules/party/party_service.py

@@ -450,6 +450,57 @@ async def get_parties_by_radius(
 
         return [party.to_model() for party in parties_within_radius]
 
+    async def get_parties_by_radius_and_date_range(
+        self,
+        latitude: float,
+        longitude: float,
+        start_date: datetime,
+        end_date: datetime,
+    ) -> List[Party]:
+        """
+        Get parties within a radius of a location within a specified date range.
+
+        Args:
+            latitude: Latitude of the search center
+            longitude: Longitude of the search center
+            start_date: Start of the date range (inclusive)
+            end_date: End of the date range (inclusive)
+
+        Returns:
+            List of parties within the radius and date range
+        """
+        result = await self.session.execute(
+            select(PartyEntity)
+            .options(
+                selectinload(PartyEntity.location),
+                selectinload(PartyEntity.contact_one).selectinload(
+                    StudentEntity.account
+                ),
+            )
+            .where(
+                PartyEntity.party_datetime >= start_date,
+                PartyEntity.party_datetime <= end_date,
+            )
+        )
+        parties = result.scalars().all()
+
+        parties_within_radius = []
+        for party in parties:
+            if party.location is None:
+                continue
+
+            distance = self._calculate_haversine_distance(
+                latitude,
+                longitude,
+                float(party.location.latitude),
+                float(party.location.longitude),
+            )
+
+            if distance <= env.PARTY_SEARCH_RADIUS_MILES:
+                parties_within_radius.append(party)
+
+        return [party.to_model() for party in parties_within_radius]
+
     def _calculate_haversine_distance(
         self, lat1: float, lon1: float, lat2: float, lon2: float
     ) -> float:

backend/test/modules/account/account_service_test.py

@@ -1,4 +1,5 @@
 import pytest
+import pytest_asyncio
 from sqlalchemy.ext.asyncio import AsyncSession
 from src.modules.account.account_model import AccountData, AccountRole
 from src.modules.account.account_service import (
@@ -14,7 +15,7 @@ def account_service(test_async_session: AsyncSession) -> AccountService:
     return AccountService(session=test_async_session)
 
 
-@pytest.fixture()
+@pytest_asyncio.fixture()
 async def accounts_by_roles_fixture(account_service: AccountService) -> None:
     await account_service.create_account(
         AccountData(