Merge pull request 'fix list' (#33) from feature/tags-search into master

Reviewed-on: #33

app/models/events.py

@@ -6,13 +6,13 @@ class Event(BaseModel):
     id: ObjectIdField = None
     name: str
     place: str
-    zip_code: str
+    description: str
-    city: str
+    imgUrl: str | None = None
-    country: str
     status: int = 0
     latitude: float = 0.0
     longitude: float = 0.0
     organizers: list[str] = []
+    tags: list[str] = []
     start_date: datetime | None = None
     end_date: datetime | None = None
     created_at: datetime = datetime.today()
@@ -24,21 +24,21 @@ class EventOut(BaseModel):
     id: ObjectIdField = None
     name: str
     place: str
-    zip_code: str
+    description: str
-    city: str
+    imgUrl: str | None = None
-    country: str
     status: int = 0
     start_date: datetime | None = None
     end_date: datetime | None = None
+    tags: list[str] = []
 
 class EventIn(BaseModel):
     name: str
     place: str
-    zip_code: str
+    description: str
-    city: str
+    imgUrl: str | None = None
-    country: str
     status: int = 0
     organizers: list[str] = []
+    tags: list[str] = []
     start_date: datetime | None = None
     end_date: datetime | None = None
     latitude: float = 0.0

app/routers/events.py

@@ -4,40 +4,219 @@ from datetime import datetime
 from ..dependencies import users_token, permissions_checker, database
 from ..models import events, users
 from pydantic import EmailStr
-from typing import Annotated
+from typing import Annotated, Union
 from bson import ObjectId
+from datetime import datetime
 router = APIRouter()
 
+def build_location_filter(min_lat, max_lat, min_lon, max_lon):
+    """Build location-based query filters."""
+    if min_lat is not None and max_lat is not None and min_lon is not None and max_lon is not None:
+        return [
+            {"latitude": {"$gte": min_lat}},
+            {"latitude": {"$lte": max_lat}},
+            {"longitude": {"$gte": min_lon}},
+            {"longitude": {"$lte": max_lon}},
+        ]
+    return []
+
+def build_datetime_filter(current_datetime):
+    """Build filters for current datetime."""
+    if current_datetime:
+        return {
+            "$or": [
+                {"start_date": {"$gte": current_datetime}},  # Upcoming events
+                {
+                    "$and": [
+                        {"start_date": {"$lte": current_datetime}},  # Already started
+                        {"$or": [
+                            {"end_date": {"$gte": current_datetime}},  # Ongoing
+                            {"end_date": None},  # No end date
+                        ]},
+                    ],
+                },
+            ],
+        }
+    return None
+
+def build_date_filter(start_date, end_date):
+    """Build date range filters."""
+    if start_date and end_date:
+        return [
+            {"start_date": {"$gte": datetime.combine(start_date, datetime.min.time())}},
+            {"start_date": {"$lte": datetime.combine(end_date, datetime.max.time())}},
+        ]
+    return []
+
+def build_text_filter(item):
+    """Build text-based search filters."""
+    if item:
+        return {
+            "$or": [
+                {"name": {"$regex": item, "$options": "i"}},
+                {"tags": {"$regex": item, "$options": "i"}},
+                {"organizers": {"$regex": item, "$options": "i"}},
+            ]
+        }
+    return None
+
+
 
 
 @router.get("/events", tags=["events"], response_model=list[events.EventOut])
-async def read_events(authorize: Annotated[bool, Depends(permissions_checker.PermissionChecker(roles=["Admin", "User"]))], skip: int = 0, limit: int = 20, id_event: str | None = None, name: str | None = None, status: int | None = None):
+async def read_events(
+    authorize: Annotated[bool, Depends(permissions_checker.PermissionChecker(roles=["Admin", "User"]))],
+    skip: int = 0,
+    limit: int = 20,
+    id_event: str | None = None,
+    name: str | None = None,
+    status: int = 1,
+    tags: str | None = None,
+    organizers: str | None = None,
+    current_datetime: datetime | None = None,
+    date_event: datetime | None = None,
+    start_date: datetime | None = None,
+    end_date: datetime | None = None,
+):
+    # Validate `skip` and `limit`
     if limit < 1 or skip < 0 or limit < skip:
         raise HTTPException(
             status_code=status.HTTP_400_BAD_REQUEST,
-            detail="skip should be greater than 0 and limit should be greater than 1. Limit should be greater than skip"
+            detail="`skip` should be >= 0 and `limit` should be > 0 and greater than `skip`.",
         )
     limit = limit + skip
-    listEvents = []
+
+    # Initialize filters
+    filters = []
+
+    # Add status filter
+    filters.append({"status": {"$eq": status}})
+
+    # Add date filters
+    if date_event:
+        start_of_day = datetime.combine(date_event, datetime.min.time())
+        end_of_day = datetime.combine(date_event, datetime.max.time())
+        filters.extend(build_date_filter(start_of_day, end_of_day))
+    elif start_date and end_date:
+        filters.extend(build_date_filter(start_date, end_date))
+
+    # Add current datetime filter
+    datetime_filter = build_datetime_filter(current_datetime)
+    if datetime_filter:
+        filters.append(datetime_filter)
+
+    # Add text-based filters
+    if name:
+        filters.append(build_text_filter(name))
+    if tags:
+        filters.append({"tags": {"$eq": tags}})
+    if organizers:
+        filters.append({"organizers": {"$eq": organizers}})
+
+    # Add ID filter
+    if id_event:
+        try:
+            event_id = ObjectId(id_event)
+            filters.append({"_id": {"$eq": event_id}})
+        except Exception:
+            raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Invalid event ID format.")
+
+    # Combine all filters
+    object_search = {"$and": filters} if filters else {}
+
+    # Fetch and return results
     event_repository = events.EventRepository(database=database.database)
-    object_search = {}
+    list_events = []
-    if status is not None:
-        object_search = {"status":{"$eq": status}}
-    if id_event is not None:
-        eventid = ObjectId(id_event)
-        object_search = {"id": {"$regex": userid}}
-        if status is not None:
-           object_search = {"$and":[{"id":{"$regex": eventid}}, {"status":{"$eq":status}}]}
-    if name is not None:
-        object_search = {"name": {"$regex": name}}
-        if status is not None:
-           object_search = {"$and":[{"name":{"$regex": name}}, {"status":{"$eq":status}}]}
-
-
     for event_index in event_repository.find_by(object_search, limit=limit, skip=skip):
-        event = events.EventOut(id=event_index.id, name=event_index.name, place=event_index.place, zip_code=event_index.zip_code, city=event_index.city, country=event_index.country,  status=event_index.status, start_date=event_index.start_date, end_date=event_index.end_date)
+        event = events.EventOut(
-        listEvents.append(event)
+            id=event_index.id,
-    return listEvents
+            tags=event_index.tags,
+            imgUrl=event_index.imgUrl,
+            name=event_index.name,
+            description=event_index.description,
+            place=event_index.place,
+            status=event_index.status,
+            start_date=event_index.start_date,
+            end_date=event_index.end_date,
+        )
+        list_events.append(event)
+
+    return list_events
+
+
+@router.get("/events/search", tags=["events"], response_model=list[events.EventOut])
+async def search_events(
+    authorize: Annotated[bool, Depends(permissions_checker.PermissionChecker(roles=["Admin", "User"]))],
+    skip: int = 0,
+    limit: int = 20,
+    item: Union[str, None] = None,
+    status: int = 1,
+    min_lat: Union[float, None] = None,
+    max_lat: Union[float, None] = None,
+    min_lon: Union[float, None] = None,
+    max_lon: Union[float, None] = None,
+    current_datetime: Union[datetime, None] = None,
+    date_event: Union[datetime, None] = None,
+    start_date: Union[datetime, None] = None,
+    end_date: Union[datetime, None] = None,
+    tags: Union[List[str], None] = None,
+):
+    if limit < 1 or skip < 0 or limit < skip:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="`skip` should be >= 0 and `limit` should be > 0 and greater than `skip`.",
+        )
+    limit = limit + skip
+
+    # Initialize filters
+    filters = [{"status": {"$eq": status}}]
+
+    # Date filters
+    if date_event:
+        start_of_day = datetime.combine(date_event, datetime.min.time())
+        end_of_day = datetime.combine(date_event, datetime.max.time())
+        filters.extend(build_date_filter(start_of_day, end_of_day))
+    else:
+        filters.extend(build_date_filter(start_date, end_date))
+
+    # Add location filter
+    filters.extend(build_location_filter(min_lat, max_lat, min_lon, max_lon))
+
+    # Add datetime filter
+    datetime_filter = build_datetime_filter(current_datetime)
+    if datetime_filter:
+        filters.append(datetime_filter)
+
+    # Add text filter
+    text_filter = build_text_filter(item)
+    if text_filter:
+        filters.append(text_filter)
+
+    if tags is not None:
+        filters.append({"tags": {"$in": tags}})
+
+    # Combine filters
+    object_search = {"$and": filters} if filters else {}
+
+    # Fetch and return results
+    event_repository = events.EventRepository(database=database.database)
+    list_events = []
+    for event_index in event_repository.find_by(object_search, limit=limit, skip=skip):
+        event = events.EventOut(
+            id=event_index.id,
+            tags=event_index.tags,
+            imgUrl=event_index.imgUrl,
+            name=event_index.name,
+            description=event_index.description,
+            place=event_index.place,
+            status=event_index.status,
+            start_date=event_index.start_date,
+            end_date=event_index.end_date,
+        )
+        list_events.append(event)
+
+    return list_events
+
 
 
 @router.get("/events/me",tags=["events"])
@@ -46,7 +225,7 @@ async def read_users_me(current_user: Annotated[users.User, Depends(users_token.
     listOrganizers = []
 
     for event_index in event_repository.find_by({"organizers":{"$eq": current_user.username}}, limit=limit, skip=skip):
-        event = events.EventOut(id=event_index.id, name=event_index.name, place=event_index.place, zip_code=event_index.zip_code, city=event_index.city, country=event_index.country, status=event_index.status, start_date=event_index.start_date, end_date=event_index.end_date)
+        event = events.EventOut(id=event_index.id, name=event_index.name, tags=event_index.tags, imgUrl=event_index.imgUrl, description=event_index.description, place=event_index.place, status=event_index.status, start_date=event_index.start_date, end_date=event_index.end_date)
         listOrganizers.append(event)
 
     content = {"organizers":listOrganizers}
@@ -129,15 +308,15 @@ async def update_events_me(item_id: str, current_user: Annotated[users.User, Dep
     event_repository = event.EventRepository(database=database.database)
     event = event_repository.find_one_by_id(ObjectId(item_id))
     event.name = eventSingle.name
+    event.description = eventSingle.description
     event.place = eventSingle.place
-    event.zip_code = eventSingle.zip_code
-    event.city = eventSingle.city
-    event.country = eventSingle.country
     event.start_date = eventSingle.start_date
+    event.tags = eventSingle.tags
     event.end_date = eventSingle.end_date
     event.latitude = eventSingle.latitude
     event.longitude = eventSingle.longitude
     event.updated_at = datetime.today()
+    event.imgUrl = eventSingle.imgUrl
     event_repository.save(event)
     content = {"message": "event is updated"}
     response = JSONResponse(content=content)  
@@ -160,16 +339,15 @@ async def update_events(authorize: Annotated[bool, Depends(permissions_checker.P
         )
         
 
-    event = events.Event(name=eventSingle.name,  place=eventSingle.place)
+    event = events.Event(name=eventSingle.name, description=eventSingle.description, place=eventSingle.place)
     event.start_date = eventSingle.start_date
     event.end_date = eventSingle.end_date
-    event.place = eventSingle.place
-    event.zip_code = eventSingle.zip_code
-    event.city = eventSingle.city
-    event.country = eventSingle.country
     event.organizers = eventSingle.organizers
     event.latitude = eventSingle.latitude
     event.longitude = eventSingle.longitude
+    event.imgUrl = eventSingle.imgUrl
+    event.tags = eventSingle.tags
+    event.status = 1
     event.created_at = datetime.today()
     event_repository.save(event)
     content = {"message": "event is created"}
@@ -195,15 +373,15 @@ async def update_events_id(item_id: str, authorize: Annotated[bool, Depends(perm
         
     event.name = eventSingle.name
     event.place = eventSingle.place
-    event.zip_code = eventSingle.zip_code
+    event.description = eventSingle.description
-    event.city = eventSingle.city
-    event.country = eventSingle.country
     event.start_date = eventSingle.start_date
     event.end_date = eventSingle.end_date
     event.organizers = eventSingle.organizers
+    event.tags = eventSingle.tags
     event.latitude = eventSingle.latitude
     event.longitude = eventSingle.longitude
     event.updated_at = datetime.today()
+    event.imgUrl = eventSingle.imgUrl
     event_repository.save(event)
     content = {"message": "event is updated"}
     response = JSONResponse(content=content)