479 lines
19 KiB
Python
479 lines
19 KiB
Python
from fastapi import APIRouter, Depends, HTTPException, status, Response
|
||
from fastapi.responses import JSONResponse
|
||
from datetime import datetime
|
||
from ..dependencies import users_token, permissions_checker, database
|
||
from ..models import events, users, tags
|
||
from pydantic import EmailStr
|
||
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.EventOutWithInterested])
|
||
async def read_events(
|
||
authorize: Annotated[bool, Depends(permissions_checker.PermissionChecker(roles=["Admin", "User"]))],
|
||
user: users.User = Depends(users_token.get_current_user), # 👈 récupère l’utilisateur courant
|
||
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 >= 0 and `limit` should be > 0 and greater than `skip`.",
|
||
)
|
||
skip = limit * skip
|
||
# 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)
|
||
list_events = []
|
||
for event_index in event_repository.find_by(object_search, limit=limit, skip=skip, sort=[("start_date", 1)]):
|
||
interested_users = event_index.interested_users
|
||
is_interested = ObjectId(user.id) in interested_users
|
||
event = events.EventOutWithInterested(
|
||
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,
|
||
ticket=event_index.ticket,
|
||
link=event_index.link,
|
||
interested=is_interested,
|
||
interested_count=len(interested_users)
|
||
)
|
||
list_events.append(event)
|
||
|
||
return list_events
|
||
|
||
|
||
@router.get("/events/search", tags=["events"], response_model=list[events.EventOutWithInterested])
|
||
async def search_events(
|
||
authorize: Annotated[bool, Depends(permissions_checker.PermissionChecker(roles=["Admin", "User"]))],
|
||
user: users.User = Depends(users_token.get_current_user), # 👈 récupère l’utilisateur courant
|
||
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[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`.",
|
||
)
|
||
skip = 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": {"$eq": 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, sort=[("start_date", 1)]):
|
||
interested_users = event_index.interested_users
|
||
is_interested = ObjectId(user.id) in interested_users
|
||
event = events.EventOutWithInterested(
|
||
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,
|
||
link=event_index.link,
|
||
ticket=event_index.ticket,
|
||
interested=is_interested,
|
||
interested_count=len(interested_users)
|
||
)
|
||
list_events.append(event)
|
||
|
||
return list_events
|
||
|
||
|
||
|
||
@router.get("/events/me",tags=["events"])
|
||
async def read_users_me(current_user: Annotated[users.User, Depends(users_token.get_current_active_user)], authorize: Annotated[bool, Depends(permissions_checker.PermissionChecker(roles=["Admin", "User"]))]):
|
||
event_repository = events.EventRepository(database=database.database)
|
||
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, ticket=event_index.ticket, link=event_index.link, 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}
|
||
response = JSONResponse(content=content)
|
||
return response
|
||
|
||
@router.get("/events/count", tags=["events"])
|
||
async def read_events_count(authorize: Annotated[bool, Depends(permissions_checker.PermissionChecker(roles=["Admin", "User"]))]):
|
||
count = database.database.get_collection("events").estimated_document_count()
|
||
content = {"count":count}
|
||
response = JSONResponse(content=content)
|
||
return response
|
||
|
||
|
||
@router.get("/events/{item_id}", tags=["events"], response_model=events.Event)
|
||
async def read_events_id(item_id : str, authorize: Annotated[bool, Depends(permissions_checker.PermissionChecker(roles=["Admin"]))]):
|
||
event_repository = events.EventRepository(database=database.database)
|
||
event = event_repository.find_one_by_id(ObjectId(item_id))
|
||
return event
|
||
|
||
|
||
@router.delete("/events/me/{item_id}", tags=["events"])
|
||
async def delete_event_me(item_id: str, current_user: Annotated[users.User, Depends(users_token.get_current_active_user)], authorize: Annotated[bool, Depends(permissions_checker.PermissionChecker(roles=["Admin", "User"]))], remove: bool = False):
|
||
event_repository = events.EventRepository(database=database.database)
|
||
event = event_repository.find_one_by_id(ObjectId(item_id))
|
||
if remove is True:
|
||
event.deleted_at = datetime.today()
|
||
event.status = -1
|
||
content = {"message": "event is deleted"}
|
||
else:
|
||
event.status = 0
|
||
event.deleted_at = datetime.today()
|
||
content = {"message": "event is disabled"}
|
||
event_repository.save(event)
|
||
response = JSONResponse(content=content)
|
||
return response
|
||
|
||
@router.delete("/events/groups",tags=["events"])
|
||
async def delete_events_groups(authorize: Annotated[bool, Depends(permissions_checker.PermissionChecker(roles=["Admin"]))], remove: bool = False, eventids: events.EventIDS | None = None):
|
||
if len(eventids.ids) == 0:
|
||
raise HTTPException(
|
||
status_code=status.HTTP_400_BAD_REQUEST,
|
||
detail="eventids should be greater than 0"
|
||
)
|
||
|
||
event_repository = event.EventRepository(database=database.database)
|
||
for i in eventids.ids:
|
||
event = event_repository.find_one_by_id(ObjectId(i))
|
||
if remove is True:
|
||
event.status = -1
|
||
event.deleted_at = datetime.today()
|
||
content = {"message": "events are deleted "}
|
||
else:
|
||
event.status = 0
|
||
event.disabled_at = datetime.today()
|
||
content = {"message": "events are disabled"}
|
||
event_repository.save(event)
|
||
|
||
response = JSONResponse(content=content)
|
||
return response
|
||
|
||
@router.delete("/events/{item_id}", tags=["events"])
|
||
async def delete_events_id(item_id : str, authorize: Annotated[bool, Depends(permissions_checker.PermissionChecker(roles=["Admin"]))], remove : bool = False):
|
||
event_repository = events.EventRepository(database=database.database)
|
||
event = event_repository.find_one_by_id(ObjectId(item_id))
|
||
if remove is True:
|
||
event.status = -1
|
||
event.deleted_at = datetime.today()
|
||
content = {"message": "events are deleted"}
|
||
else:
|
||
event.status = 0
|
||
event.disabled_at = datetime.today()
|
||
content = {"message": "events are disabled"}
|
||
event_repository.save(event)
|
||
response = JSONResponse(content=content)
|
||
return response
|
||
|
||
@router.put("/events/me/{item_id}",tags=["events"])
|
||
async def update_events_me(item_id: str, current_user: Annotated[users.User, Depends(users_token.get_current_active_user)], authorize: Annotated[bool, Depends(permissions_checker.PermissionChecker(roles=["Admin", "User"]))], eventSingle: events.EventIn | None = None):
|
||
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.start_date = eventSingle.start_date
|
||
event.tags = eventSingle.tags
|
||
event.end_date = eventSingle.end_date
|
||
event.latitude = eventSingle.latitude
|
||
event.longitude = eventSingle.longitude
|
||
event.link = eventSingle.link
|
||
event.ticket = eventSingle.ticket
|
||
event.updated_at = datetime.today()
|
||
event.imgUrl = eventSingle.imgUrl
|
||
event_repository.save(event)
|
||
content = {"message": "event is updated"}
|
||
response = JSONResponse(content=content)
|
||
return response
|
||
|
||
@router.put("/events", tags=["events"], status_code=status.HTTP_201_CREATED)
|
||
async def update_events(authorize: Annotated[bool, Depends(permissions_checker.PermissionChecker(roles=["Admin"]))], eventSingle: events.EventIn | None = None):
|
||
if eventSingle is None:
|
||
raise HTTPException(
|
||
status_code=status.HTTP_400_BAD_REQUEST,
|
||
detail="Body request is empty"
|
||
)
|
||
event_repository = events.EventRepository(database=database.database)
|
||
tags_repository = tags.TagsRepository(database=database.database)
|
||
|
||
event = event_repository.find_one_by( {"$and": [
|
||
{"start_date": {"$eq": eventSingle.start_date}}, # Already started
|
||
{"name": {"$eq": eventSingle.name}},
|
||
]})
|
||
if event is not None:
|
||
raise HTTPException(
|
||
status_code=status.HTTP_204_NO_CONTENT,
|
||
detail="name"
|
||
)
|
||
|
||
|
||
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.organizers = eventSingle.organizers
|
||
event.latitude = eventSingle.latitude
|
||
event.longitude = eventSingle.longitude
|
||
event.imgUrl = eventSingle.imgUrl
|
||
event.link = eventSingle.link
|
||
event.ticket = eventSingle.ticket
|
||
event.tags = eventSingle.tags
|
||
for tag_name in eventSingle.tags:
|
||
tag = tags_repository.find_one_by({"name": {'$eq': tag_name}})
|
||
if tag is None:
|
||
tag = tags.Tags(name=tag_name)
|
||
tags_repository.save(tag)
|
||
event.status = 1
|
||
event.created_at = datetime.today()
|
||
event_repository.save(event)
|
||
content = {"message": "event created"}
|
||
response = JSONResponse(content=content, status_code=status.HTTP_201_CREATED)
|
||
return response
|
||
|
||
|
||
@router.put("/events/{item_id}", tags=["events"], status_code=status.HTTP_200_OK)
|
||
async def update_events_id(item_id: str, authorize: Annotated[bool, Depends(permissions_checker.PermissionChecker(roles=["Admin"]))], eventSingle: events.EventIn | None = None, response: Response = Response):
|
||
if eventSingle is None:
|
||
raise HTTPException(
|
||
status_code=status.HTTP_400_BAD_REQUEST,
|
||
detail="Body request is empty"
|
||
)
|
||
event_repository = events.EventRepository(database=database.database)
|
||
tags_repository = tags.TagsRepository(database=database)
|
||
event = event_repository.find_one_by({"id": {'$eq': ObjectId(item_id)}})
|
||
if event is None:
|
||
raise HTTPException(
|
||
status_code=status.HTTP_404_NOT_FOUND,
|
||
detail="Event not found"
|
||
)
|
||
|
||
event.name = eventSingle.name
|
||
event.place = eventSingle.place
|
||
event.description = eventSingle.description
|
||
event.start_date = eventSingle.start_date
|
||
event.end_date = eventSingle.end_date
|
||
event.organizers = eventSingle.organizers
|
||
event.link = eventSingle.link
|
||
event.ticket = eventSingle.ticket
|
||
event.tags = eventSingle.tags
|
||
for tag_name in eventSingle:
|
||
tag = tags_repository.find_one_by({"name": {'$eq': tag_name}})
|
||
if tag is None:
|
||
tag = Tags(name=tag_name)
|
||
tags_repository.save(tag)
|
||
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)
|
||
return response
|
||
|
||
|
||
@router.patch("/events/groups",tags=["events"])
|
||
async def patch_events_groups(authorize: Annotated[bool, Depends(permissions_checker.PermissionChecker(roles=["Admin"]))], eventids: events.EventIDS | None = None):
|
||
if len(eventids.ids) == 0:
|
||
raise HTTPException(
|
||
status_code=status.HTTP_400_BAD_REQUEST,
|
||
detail="eventids should be greater than 0"
|
||
)
|
||
|
||
event_repository = events.EventRepository(database=database.database)
|
||
content = {"message": "events are enabled"}
|
||
for i in eventids.ids:
|
||
event = event_repository.find_one_by_id(ObjectId(i))
|
||
event.status = 1
|
||
event.disabled_at = None
|
||
event.deleted_at = None
|
||
event_repository.save(event)
|
||
|
||
|
||
response = JSONResponse(content=content)
|
||
return response
|
||
|
||
@router.patch("/events/{item_id}", tags=["events"])
|
||
async def patch_events_id(item_id : str, authorize: Annotated[bool, Depends(permissions_checker.PermissionChecker(roles=["Admin"]))]):
|
||
event_repository = events.EventRepository(database=database.database)
|
||
event = event_repository.find_one_by_id(ObjectId(item_id))
|
||
event.status = 1
|
||
event.disabled_at = None
|
||
event.deleted_at = None
|
||
event_repository.save(event)
|
||
content = {"message": "event is enabled"}
|
||
response = JSONResponse(content=content)
|
||
return response
|
||
|
||
@router.post("/events/{event_id}/interest", tags=["events"])
|
||
async def toggle_interest(event_id: str, user: users.User = Depends(users_token.get_current_user)):
|
||
event_repository = events.EventRepository(database=database.database)
|
||
event = event_repository.find_one_by_id(ObjectId(event_id))
|
||
|
||
if not event:
|
||
raise HTTPException(status_code=404, detail="Event not found")
|
||
|
||
interested_users = event.interested_users
|
||
user_obj_id = ObjectId(user.id)
|
||
|
||
if user_obj_id in interested_users:
|
||
# Retirer l’utilisateur
|
||
interested_users.remove(user_obj_id)
|
||
else:
|
||
# Ajouter l’utilisateur
|
||
interested_users.append(user_obj_id)
|
||
event.interested_users = interested_users
|
||
|
||
event_repository.save(event)
|
||
|
||
return {"event_id": event_id, "interested": user_obj_id in interested_users, "interested_count": len(interested_users)}
|