Upload 162 files

src/apis/controllers/admin_controller.py

@@ -0,0 +1,234 @@
+from fastapi import APIRouter, Depends, HTTPException, Query
+from typing import Annotated, List
+from fastapi.responses import JSONResponse
+import pandas as pd
+import math
+from src.apis.models.user_models import User
+from src.apis.models.destination_models import Destination
+from src.apis.middlewares.auth_middleware import get_current_user
+from src.utils.logger import logger
+from src.apis.controllers.destination_controller import (
+    destination_recommendation_func,
+)
+from fastapi.responses import JSONResponse
+from src.utils.mongo import DestinationCRUD
+from datetime import datetime
+from bson import ObjectId
+
+router = APIRouter(prefix="/deadminst", tags=["Destination"])
+
+user_dependency = Annotated[User, Depends(get_current_user)]
+EXCEL_FILE_PATH = "./src/data/destination_1_new_tag.xlsx"
+
+
+@router.get("/get_tourist")
+def get_tourist(page: int = Query(default=1, ge=1)):
+    try:
+        PAGE_SIZE = 10
+        df = pd.read_excel(EXCEL_FILE_PATH)
+        required_columns = ["name", "description", "image"]
+        if not all(col in df.columns for col in required_columns):
+            raise HTTPException(
+                status_code=400, detail="Missing required columns in Excel file"
+            )
+        total_items = len(df)
+        total_pages = math.ceil(total_items / PAGE_SIZE)
+        start_idx = (page - 1) * PAGE_SIZE
+        end_idx = start_idx + PAGE_SIZE
+        paginated_df = df[required_columns].iloc[start_idx:end_idx]
+        tourist_data = paginated_df.to_dict(orient="records")
+        return JSONResponse(
+            content={
+                "data": tourist_data,
+                "page": page,
+                "total_pages": total_pages,
+                "total_items": total_items,
+                "page_size": PAGE_SIZE,
+            }
+        )
+    except Exception as e:
+        logger.error(f"Error reading the Excel file: {str(e)}")
+        raise HTTPException(
+            status_code=500, detail=f"Error reading the Excel file: {str(e)}"
+        )
+
+
+@router.get("/destination_detail")
+async def get_destinations(destination_id: str = Query(min_length=1, max_length=50)):
+    try:
+        destination_data = await DestinationCRUD.find_by_id(destination_id)
+        if not destination_data:
+            return JSONResponse(
+                content={"message": "Destination not found"}, status_code=404
+            )
+        destination_data.pop("created_at")
+        destination_data.pop("updated_at")
+        destination_data.pop("expire_at")
+        destination_data["id"] = str(destination_data["_id"])
+        destination_data.pop("_id")
+        print("destination_data", destination_data)
+        return JSONResponse(content=destination_data, status_code=200)
+
+    except Exception as e:
+        logger.error(f"Error fetching destination: {str(e)}")
+
+
+@router.get("/paginate")
+async def get_paginated_destinations(
+    page: int = Query(default=1, ge=1), page_size: int = Query(default=10, ge=1, le=100)
+):
+    """
+    Get paginated destinations from database
+
+    Args:
+        page: Page number (starts from 1)
+        page_size: Number of items per page
+
+    Returns:
+        Paginated list of destinations with pagination metadata
+    """
+    try:
+        # Calculate skip value for pagination
+        skip = (page - 1) * page_size
+
+        # Query destinations with pagination
+        destination_data = await DestinationCRUD.find_many(
+            filter={},  # Empty filter means get all
+            skip=skip,
+            limit=page_size,
+            sort=[("created_at", -1)],  # Sort by created_at descending
+        )
+
+        # Get total count for pagination metadata
+        total_items = await DestinationCRUD.count({})
+        total_pages = math.ceil(total_items / page_size)
+
+        # Process results
+        serialized_data = []
+        for dest in destination_data:
+            dest.pop("created_at")
+            dest.pop("updated_at")
+            dest.pop("expire_at")
+
+            dest_dict = {
+                "id": dest["_id"],
+                **{k: v for k, v in dest.items() if k != "_id"},
+            }
+            serialized_data.append(dest_dict)
+
+        return JSONResponse(
+            content={
+                "data": serialized_data,
+                "page": page,
+                "total_pages": total_pages,
+                "total_items": total_items,
+                "page_size": page_size,
+            },
+            status_code=200,
+        )
+    except Exception as e:
+        logger.error(f"Error fetching paginated destinations: {str(e)}")
+        raise HTTPException(
+            status_code=500, detail=f"Error fetching paginated destinations: {str(e)}"
+        )
+
+@router.post("/")
+async def create_destination(
+    destination_data: Destination, current_user: user_dependency
+):
+    if current_user["role"] != "admin":
+        raise HTTPException(status_code=403, detail="Unauthorized")
+    try:
+        destination_id = await DestinationCRUD.create(destination_data.model_dump())
+
+        if not destination_id:
+            raise HTTPException(status_code=400, detail="Failed to create destination")
+
+        return JSONResponse(
+            content={
+                "message": "Destination created successfully",
+                "id": destination_id,
+            },
+            status_code=201,
+        )
+    except Exception as e:
+        logger.error(f"Error creating destination: {str(e)}")
+        raise HTTPException(
+            status_code=500, detail=f"Error creating destination: {str(e)}"
+        )
+
+
+@router.put("/{destination_id}")
+async def update_destination(
+    destination_id: str, destination_data: dict, current_user: user_dependency
+):
+    if current_user["role"] != "admin":
+        raise HTTPException(status_code=403, detail="Unauthorized")
+    try:
+        # Add updated_at timestamp
+        destination_data["updated_at"] = datetime.utcnow()
+
+        # Update destination
+        result = await DestinationCRUD.update(
+            {"_id": ObjectId(destination_id)}, destination_data
+        )
+
+        if not result:
+            raise HTTPException(status_code=404, detail="Destination not found")
+
+        return JSONResponse(
+            content={"message": "Destination updated successfully"}, status_code=200
+        )
+    except Exception as e:
+        logger.error(f"Error updating destination: {str(e)}")
+        raise HTTPException(
+            status_code=500, detail=f"Error updating destination: {str(e)}"
+        )
+
+
+@router.delete("/{destination_id}")
+async def delete_destination(destination_id: str, current_user: user_dependency):
+    if current_user["role"] != "admin":
+        raise HTTPException(status_code=403, detail="Unauthorized")
+    try:
+        # Delete destination
+        result = await DestinationCRUD.delete_one({"_id": ObjectId(destination_id)})
+
+        if not result:
+            raise HTTPException(status_code=404, detail="Destination not found")
+
+        return JSONResponse(
+            content={"message": "Destination deleted successfully"}, status_code=200
+        )
+    except Exception as e:
+        logger.error(f"Error deleting destination: {str(e)}")
+        raise HTTPException(
+            status_code=500, detail=f"Error deleting destination: {str(e)}"
+        )
+
+
+@router.get("/")
+async def get_all_destinations(current_user: user_dependency):
+    print("current_user", current_user)
+    if current_user["role"] != "admin":
+        raise HTTPException(status_code=403, detail="Unauthorized")
+    try:
+        # Get all destinations
+        destinations = await DestinationCRUD.find_all()
+
+        # Process results
+        serialized_data = []
+        for dest in destinations:
+            dest.pop("created_at")
+            dest.pop("updated_at")
+            dest.pop("expire_at")
+            dest["id"] = str(dest["_id"])
+            dest.pop("_id")
+            serialized_data.append(dest)
+
+        return JSONResponse(content={"data": serialized_data}, status_code=200)
+    except Exception as e:
+        logger.error(f"Error fetching destinations: {str(e)}")
+        raise HTTPException(
+            status_code=500, detail=f"Error fetching destinations: {str(e)}"
+        )

src/apis/controllers/auth_controller.py

@@ -35,6 +35,7 @@ async def login_control(token):
     token = jwt_provider.encrypt({"id": str(user_id)})
     user_data = user.__dict__
     user_data["id"] = user_id
+    user_data["role"] = existing_user["role"]
     user_data.pop("created_at", None)
     user_data.pop("updated_at", None)
     user_data.pop("expire_at", None)

src/apis/controllers/post_controller.py

@@ -12,28 +12,29 @@ import math
 async def create_a_post_controller(
     content: str, user_id: str, destination_id: str, images: list
 ) -> Dict:
-    # try:
-    image_url = await call_external_api(
-        method="POST",
-        url="http://localhost:8000/upload_image",
-        # url="https://abao77-image-retrieval.hf.space/upload_image",
-        # url="https://abao77-image-retrieval-full.hf.space/upload_image",
-        json={"base64_image": images},
-    )
-    print(f"IMAGE URL: {image_url}")
-    post = {
-        "content": content,
-        "user_id": user_id,
-        "destination_id": destination_id,
-        "comment_count": 0,
-        "reaction_count": 0,
-        "picture": image_url["public_url"] if image_url.get("public_url") else None,
-        "like": [],
-    }
-    await PostCRUD.create(post)
-    return {"status": "success", "message": "Post created successfully"}
-    # except Exception as e:
-    #     return {"status": "error", "message": str(e)}
+    try:
+        image_url = await call_external_api(
+            method="POST",
+            # url="http://localhost:8000/upload_image",
+            # url="https://abao77-image-retrieval.hf.space/upload_image",
+            url="https://abao77-image-retrieval-full.hf.space/upload_image",
+            json={"base64_image": images},
+        )
+        print(f"IMAGE URL: {image_url}")
+        post = {
+            "content": content,
+            "user_id": user_id,
+            "destination_id": destination_id,
+            "comment_count": 0,
+            "reaction_count": 0,
+            "picture": image_url["public_url"] if image_url.get("public_url") else None,
+            "like": [],
+        }
+        await PostCRUD.create(post)
+        return {"status": "success", "message": "Post created successfully"}
+    except Exception as e:
+        logger.error(f"Error creating post: {str(e)}")
+        return {"status": "error", "message": str(e)}
 
 
 async def get_a_post_controller(post_id: str) -> Dict:

src/apis/controllers/scheduling_controller.py

@@ -12,36 +12,38 @@ async def create_a_activity_controller(
     start_time: datetime,
     end_time: datetime,
     user_id: str,
+    overlap_allow: bool = True,
 ) -> Dict[str, str]:
     try:
-        existing_activity = await ScheduleCRUD.read_one(
-            {
-                "user_id": user_id,
-                "$or": [
-                    {
-                        "start_time": {"$lte": start_time},
-                        "end_time": {"$gt": start_time},
-                    },
-                    {
-                        "start_time": {"$lt": end_time},
-                        "end_time": {"$gte": end_time},
-                    },
-                    {
-                        "start_time": {"$gte": start_time},
-                        "end_time": {"$lte": end_time},
-                    },
-                ],
-            }
-        )
-        if existing_activity:
-            activity_category = existing_activity.get("activity_category", "N/A")
-            description = existing_activity.get("description", "N/A")
-            start_time = existing_activity.get("start_time", "N/A")
-            end_time = existing_activity.get("end_time", "N/A")
-            return {
-                "status": "error",
-                "message": f"""Overlapping activities found:\nDescription: {description}, \nCategory: {activity_category}, \nStart time: {start_time}, \nEnd time: {end_time}. Please update or delete the existing activity to create a new one.""",
-            }
+        if not overlap_allow:
+            existing_activity = await ScheduleCRUD.read_one(
+                {
+                    "user_id": user_id,
+                    "$or": [
+                        {
+                            "start_time": {"$lte": start_time},
+                            "end_time": {"$gt": start_time},
+                        },
+                        {
+                            "start_time": {"$lt": end_time},
+                            "end_time": {"$gte": end_time},
+                        },
+                        {
+                            "start_time": {"$gte": start_time},
+                            "end_time": {"$lte": end_time},
+                        },
+                    ],
+                }
+            )
+            if existing_activity:
+                activity_category = existing_activity.get("activity_category", "N/A")
+                description = existing_activity.get("description", "N/A")
+                start_time = existing_activity.get("start_time", "N/A")
+                end_time = existing_activity.get("end_time", "N/A")
+                return {
+                    "status": "error",
+                    "message": f"""Overlapping activities found:\nDescription: {description}, \nCategory: {activity_category}, \nStart time: {start_time}, \nEnd time: {end_time}. Please update or delete the existing activity to create a new one.""",
+                }
         document = {
             "user_id": user_id,
             "activity_category": activity_category,

src/apis/create_app.py

@@ -1,41 +1,42 @@
-from fastapi import FastAPI, APIRouter
-from fastapi.middleware.cors import CORSMiddleware
-from src.apis.routes.chat_route import router as router_chat
-from src.apis.routes.auth_route import router as router_auth
-from src.apis.routes.location_route import router as router_location
-from src.apis.routes.hotel_route import router as router_hotel
-from src.apis.routes.travel_dest_route import router as router_travel_dest
-from src.apis.routes.scheduling_router import router as router_scheduling
-from src.apis.routes.planner_route import router as router_planner
-from src.apis.routes.post_router import router as router_post
-from src.apis.routes.comment_route import router as router_comment
-from src.apis.routes.reaction_route import router as router_reaction
-
-api_router = APIRouter()
-api_router.include_router(router_chat)
-api_router.include_router(router_auth)
-api_router.include_router(router_location)
-api_router.include_router(router_hotel)
-api_router.include_router(router_travel_dest)
-api_router.include_router(router_scheduling)
-api_router.include_router(router_planner)
-api_router.include_router(router_post)
-api_router.include_router(router_comment)
-api_router.include_router(router_reaction)
-
-
-def create_app():
-    app = FastAPI(
-        docs_url="/",
-        title="eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6IjY3ZTU1ZTczYTA0MzI1YmUzNjAzYjU2MCJ9.Vdz3DdbvNUdUERDXEOyvi14EuYATRw29eOVWNGTQIYo",
-    )
-
-    app.add_middleware(
-        CORSMiddleware,
-        allow_origins=["*"],
-        allow_credentials=True,
-        allow_methods=["*"],
-        allow_headers=["*"],
-    )
-
-    return app
+from fastapi import FastAPI, APIRouter
+from fastapi.middleware.cors import CORSMiddleware
+from src.apis.routes.chat_route import router as router_chat
+from src.apis.routes.auth_route import router as router_auth
+from src.apis.routes.location_route import router as router_location
+from src.apis.routes.hotel_route import router as router_hotel
+from src.apis.routes.travel_dest_route import router as router_travel_dest
+from src.apis.routes.scheduling_router import router as router_scheduling
+from src.apis.routes.planner_route import router as router_planner
+from src.apis.routes.post_router import router as router_post
+from src.apis.routes.comment_route import router as router_comment
+from src.apis.routes.reaction_route import router as router_reaction
+from src.apis.routes.admin_route import router as router_admin
+
+api_router = APIRouter()
+api_router.include_router(router_chat)
+api_router.include_router(router_auth)
+api_router.include_router(router_location)
+api_router.include_router(router_hotel)
+api_router.include_router(router_travel_dest)
+api_router.include_router(router_scheduling)
+api_router.include_router(router_planner)
+api_router.include_router(router_post)
+api_router.include_router(router_comment)
+api_router.include_router(router_reaction)
+api_router.include_router(router_admin)
+
+def create_app():
+    app = FastAPI(
+        docs_url="/",
+        title="eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6IjY3ZTU1ZTczYTA0MzI1YmUzNjAzYjU2MCJ9.Vdz3DdbvNUdUERDXEOyvi14EuYATRw29eOVWNGTQIYo"
+    )
+
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    return app

src/apis/models/destination_models.py

@@ -8,13 +8,16 @@ class Destination(BaseDocument):
     name: str = Field("", description="Destination's name")
     description: str = Field("", description="Destination's description")
     image: str = Field("", description="Destination's picture")
-
+    created_user_id: str = Field("", description="Destination's created user")
+    updated_user_id: str = Field("", description="Destination's updated user")
     model_config = {
         "json_schema_extra": {
             "example": {
                 "name": "Hanoi",
                 "description": "Hanoi is the capital of Vietnam",
                 "image": "https://www.google.com.vn",
+                "created_user_id": "1234567890",
+                "updated_user_id": "1234567890",
             }
         }
     }

src/apis/models/user_models.py

@@ -10,6 +10,7 @@ def get_user(user) -> dict:
         "email": user["email"],
         "picture": user["picture"],
         "contact_number": user["contact_number"],
+        "role": user["role"],
     }
 
 
@@ -23,6 +24,7 @@ class User(BaseDocument):
     email: EmailStr = Field("", description="User's email")
     picture: str = Field("", title="User Picture")
     contact_number: str = Field("", description="User's contact number")
+    role: str = Field("", description="User's role")
 
     class Config:
         json_schema_extra = {
@@ -31,5 +33,6 @@ class User(BaseDocument):
                 "email": "johnUS192@gmail.com",
                 "picture": "https://example.com/picture.jpg",
                 "contact_number": "1234567890",
+                "role": "user",
             }
         }

src/apis/routes/admin_route.py

@@ -0,0 +1,199 @@
+from fastapi import APIRouter, Depends, HTTPException, Query
+from typing import Annotated, List
+from fastapi.responses import JSONResponse
+import pandas as pd
+import math
+from src.apis.models.user_models import User
+from src.apis.models.destination_models import Destination
+from src.apis.middlewares.auth_middleware import get_current_user
+from src.utils.logger import logger
+from fastapi import status
+from src.utils.mongo import DestinationCRUD, PostCRUD, UserCRUD
+from datetime import datetime
+from bson import ObjectId
+
+router = APIRouter(prefix="/admin", tags=["Admin"])
+
+user_dependency = Annotated[User, Depends(get_current_user)]
+
+@router.get("/destination/paginate")
+async def get_paginated_destinations(
+    user: user_dependency,
+    page: int = Query(default=1, ge=1),
+    page_size: int = Query(default=10, ge=1, le=100)
+):
+    """
+    Get paginated destinations from database
+
+    Args:
+        page: Page number (starts from 1)
+        page_size: Number of items per page
+
+    Returns:
+        Paginated list of destinations with pagination metadata
+    """
+    if user["role"] != "admin":
+        raise HTTPException(status_code=403, detail="Unauthorized")
+    try:
+        # Calculate skip value for pagination
+        skip = (page - 1) * page_size
+
+        # Query destinations with pagination
+        destination_data = await DestinationCRUD.find_many(
+            filter={},  # Empty filter means get all
+            skip=skip,
+            limit=page_size,
+            sort=[("created_at", -1)],  # Sort by created_at descending
+        )
+
+        # Get total count for pagination metadata
+        total_items = await DestinationCRUD.count({})
+        total_pages = math.ceil(total_items / page_size)
+
+        # Collect unique user IDs
+        user_ids = set()
+        for dest in destination_data:
+            if dest.get("created_user_id"):
+                user_ids.add(dest["created_user_id"])
+            if dest.get("updated_user_id"):
+                user_ids.add(dest["updated_user_id"])
+
+        # Fetch all users in a single query
+        users = {}
+        if user_ids:
+            user_data = await UserCRUD.find_many(
+                filter={"_id": {"$in": [ObjectId(uid) for uid in user_ids]}}
+            )
+            users = {str(user["_id"]): user for user in user_data}
+
+        # Process results
+        serialized_data = []
+        for dest in destination_data:
+            # Convert timestamps to ISO format
+            if "created_at" in dest:
+                dest["created_at"] = dest["created_at"].isoformat() if dest["created_at"] else None
+            if "updated_at" in dest:
+                dest["updated_at"] = dest["updated_at"].isoformat() if dest["updated_at"] else None
+            dest.pop("expire_at", None)
+
+            dest_dict = {
+                "id": dest["_id"],
+                "created_user": {
+                    "id": dest.get("created_user_id"),
+                    "name": users.get(dest.get("created_user_id", ""), {}).get("name"),
+                    "email": users.get(dest.get("created_user_id", ""), {}).get("email")
+                } if dest.get("created_user_id") else None,
+                "updated_user": {
+                    "id": dest.get("updated_user_id"),
+                    "name": users.get(dest.get("updated_user_id", ""), {}).get("name"),
+                    "email": users.get(dest.get("updated_user_id", ""), {}).get("email")
+                } if dest.get("updated_user_id") else None,
+                **{k: v for k, v in dest.items() if k not in ["_id", "created_user_id", "updated_user_id"]},
+            }
+            serialized_data.append(dest_dict)
+
+        return JSONResponse(
+            content={
+                "data": serialized_data,
+                "page": page,
+                "total_pages": total_pages,
+                "total_items": total_items,
+                "page_size": page_size,
+            },
+            status_code=200,
+        )
+    except Exception as e:
+        logger.error(f"Error fetching paginated destinations: {str(e)}")
+        raise HTTPException(
+            status_code=500, detail=f"Error fetching paginated destinations: {str(e)}"
+        )
+
+
+
+@router.post("/destination")
+async def create_destination(
+    destination_data: Destination, current_user: user_dependency
+):
+    if current_user["role"] != "admin":
+        raise HTTPException(status_code=403, detail="Unauthorized")
+    try:
+        destination_data.created_user_id = current_user["id"]
+        destination_data.updated_user_id = current_user["id"]
+        destination_id = await DestinationCRUD.create(destination_data.model_dump())
+
+        if not destination_id:
+            raise HTTPException(status_code=400, detail="Failed to create destination")
+
+        return JSONResponse(
+            content={
+                "message": "Destination created successfully",
+                "id": destination_id,
+            },
+            status_code=201,
+        )
+    except Exception as e:
+        logger.error(f"Error creating destination: {str(e)}")
+        raise HTTPException(
+            status_code=500, detail=f"Error creating destination: {str(e)}"
+        )
+
+
+@router.put("/destination/{destination_id}")
+async def update_destination(
+    destination_id: str, destination_data: dict, current_user: user_dependency
+):
+    if current_user["role"] != "admin":
+        raise HTTPException(status_code=403, detail="Unauthorized")
+    try:
+        # Add updated_at timestamp
+        destination_data["updated_at"] = datetime.utcnow()
+        destination_data["updated_user_id"] = current_user["id"]
+        # Update destination
+        result = await DestinationCRUD.update(
+            {"_id": ObjectId(destination_id)}, destination_data
+        )
+
+        if not result:
+            raise HTTPException(status_code=404, detail="Destination not found")
+
+        return JSONResponse(
+            content={"message": "Destination updated successfully"}, status_code=200
+        )
+    except Exception as e:
+        logger.error(f"Error updating destination: {str(e)}")
+        raise HTTPException(
+            status_code=500, detail=f"Error updating destination: {str(e)}"
+        )
+
+
+@router.delete("/destination/{destination_id}")
+async def delete_destination(destination_id: str, current_user: user_dependency):
+    print("destination_id", destination_id)
+    if current_user["role"] != "admin":
+        raise HTTPException(status_code=403, detail="Unauthorized")
+    try:
+        # Delete destination
+        result = await DestinationCRUD.delete_one({"_id": ObjectId(destination_id)})
+
+        if not result:
+            raise HTTPException(status_code=404, detail="Destination not found")
+
+        return JSONResponse(
+            content={"message": "Destination deleted successfully"}, status_code=200
+        )
+    except Exception as e:
+        logger.error(f"Error deleting destination: {str(e)}")
+        raise HTTPException(
+            status_code=500, detail=f"Error deleting destination: {str(e)}"
+        )
+
+
+
+@router.delete("/post/delete/{post_id}", status_code=status.HTTP_200_OK)
+async def delete_post(post_id: str, user: user_dependency):
+    if user["role"] != "admin":
+        raise HTTPException(status_code=403, detail="Unauthorized")
+    result = await PostCRUD.delete_one({"_id": ObjectId(post_id)})
+    if not result:
+        raise HTTPException(status_code=404, detail="Post not found")
+    return JSONResponse(content={"message": "Post deleted successfully"}, status_code=200)

src/apis/routes/travel_dest_route.py

@@ -1,9 +1,10 @@
 from fastapi import APIRouter, Depends, HTTPException, Query
-from typing import Annotated
+from typing import Annotated, List
 from fastapi.responses import JSONResponse
 import pandas as pd
 import math
 from src.apis.models.user_models import User
+from src.apis.models.destination_models import Destination
 from src.apis.middlewares.auth_middleware import get_current_user
 from src.utils.logger import logger
 from src.apis.controllers.destination_controller import (
@@ -11,6 +12,8 @@ from src.apis.controllers.destination_controller import (
 )
 from fastapi.responses import JSONResponse
 from src.utils.mongo import DestinationCRUD
+from datetime import datetime
+from bson import ObjectId
 
 router = APIRouter(prefix="/dest", tags=["Destination"])
 
@@ -153,3 +156,105 @@ async def get_tourist_names():
 @router.get("/suggest")
 async def destination_suggestion(question: str, top_k: int = Query(default=5, ge=1)):
     return JSONResponse(await destination_recommendation_func(question))
+
+
+@router.post("/")
+async def create_destination(
+    destination_data: Destination, current_user: user_dependency
+):
+    if current_user["role"] != "admin":
+        raise HTTPException(status_code=403, detail="Unauthorized")
+    try:
+        destination_id = await DestinationCRUD.create(destination_data.model_dump())
+
+        if not destination_id:
+            raise HTTPException(status_code=400, detail="Failed to create destination")
+
+        return JSONResponse(
+            content={
+                "message": "Destination created successfully",
+                "id": destination_id,
+            },
+            status_code=201,
+        )
+    except Exception as e:
+        logger.error(f"Error creating destination: {str(e)}")
+        raise HTTPException(
+            status_code=500, detail=f"Error creating destination: {str(e)}"
+        )
+
+
+@router.put("/{destination_id}")
+async def update_destination(
+    destination_id: str, destination_data: dict, current_user: user_dependency
+):
+    if current_user["role"] != "admin":
+        raise HTTPException(status_code=403, detail="Unauthorized")
+    try:
+        # Add updated_at timestamp
+        destination_data["updated_at"] = datetime.utcnow()
+
+        # Update destination
+        result = await DestinationCRUD.update(
+            {"_id": ObjectId(destination_id)}, destination_data
+        )
+
+        if not result:
+            raise HTTPException(status_code=404, detail="Destination not found")
+
+        return JSONResponse(
+            content={"message": "Destination updated successfully"}, status_code=200
+        )
+    except Exception as e:
+        logger.error(f"Error updating destination: {str(e)}")
+        raise HTTPException(
+            status_code=500, detail=f"Error updating destination: {str(e)}"
+        )
+
+
+@router.delete("/{destination_id}")
+async def delete_destination(destination_id: str, current_user: user_dependency):
+    if current_user["role"] != "admin":
+        raise HTTPException(status_code=403, detail="Unauthorized")
+    try:
+        # Delete destination
+        result = await DestinationCRUD.delete_one({"_id": ObjectId(destination_id)})
+
+        if not result:
+            raise HTTPException(status_code=404, detail="Destination not found")
+
+        return JSONResponse(
+            content={"message": "Destination deleted successfully"}, status_code=200
+        )
+    except Exception as e:
+        logger.error(f"Error deleting destination: {str(e)}")
+        raise HTTPException(
+            status_code=500, detail=f"Error deleting destination: {str(e)}"
+        )
+
+
+@router.get("/")
+async def get_all_destinations(current_user: user_dependency):
+    print("current_user", current_user)
+    if current_user["role"] != "admin":
+        raise HTTPException(status_code=403, detail="Unauthorized")
+    try:
+        # Get all destinations
+        destinations = await DestinationCRUD.find_all()
+
+        # Process results
+        serialized_data = []
+        for dest in destinations:
+            dest.pop("created_at")
+            dest.pop("updated_at")
+            dest.pop("expire_at")
+            dest["id"] = str(dest["_id"])
+            dest.pop("_id")
+            serialized_data.append(dest)
+
+        return JSONResponse(content={"data": serialized_data}, status_code=200)
+    except Exception as e:
+        logger.error(f"Error fetching destinations: {str(e)}")
+        raise HTTPException(
+            status_code=500, detail=f"Error fetching destinations: {str(e)}"
+        )

src/langgraph/tools/scheduling_tools.py

@@ -31,7 +31,13 @@ async def create_a_activity(
         configuration = config.get("configurable", {})
         user_id = configuration.get("user_id", None)
         response = await create_a_activity_controller(
-            None, activity_category, description, start_time, end_time, user_id
+            None,
+            activity_category,
+            description,
+            start_time,
+            end_time,
+            user_id,
+            overlap_allow=False,
         )
         return response["message"]
     except Exception as e: