Upload 141 files

init : set all data

Dockerfile

@@ -0,0 +1,29 @@
+# Use the slim variant of Python 3.11 to reduce the size
+FROM python:3.11-slim
+
+# Add a non-root user for better security
+RUN useradd -m -u 1000 user
+
+# Switch to non-root user
+USER user
+
+# Ensure pip, setuptools, and wheel are up to date
+RUN python -m pip install --upgrade pip setuptools wheel
+
+# Set PATH to include user installs
+ENV PATH="/home/user/.local/bin:$PATH"
+
+# Set the working directory inside the container
+WORKDIR /app
+
+# Copy requirements.txt file and install dependencies
+COPY --chown=user ./requirements.txt /app/requirements.txt
+
+# Install only necessary dependencies from the requirements.txt
+RUN pip install --no-cache-dir -r /app/requirements.txt
+
+# Copy the rest of the application code to the working directory
+COPY --chown=user . /app
+
+# Start the FastAPI application with uvicorn
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -0,0 +1,27 @@
+from dotenv import load_dotenv
+import base64
+import json
+import os
+
+load_dotenv(override=True)
+encoded_env = os.getenv("ENCODED_ENV")
+if encoded_env:
+    # Decode the base64 string
+    decoded_env = base64.b64decode(encoded_env).decode()
+
+    # Load it as a dictionary
+    env_data = json.loads(decoded_env)
+
+    # Set environment variables
+    for key, value in env_data.items():
+        os.environ[key] = value
+from src.apis.create_app import create_app, api_router
+import uvicorn
+
+
+app = create_app()
+
+# eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6IjY3M2IwZDMzNTQ5OTg5Zjc1NmZhMzk3MCJ9.a3A9B1ZpzkzIPvhLqFpasK4sk2ocqmc1M80rtyAkbmM
+app.include_router(api_router)
+if __name__ == "__main__":
+    uvicorn.run("app:app", host="0.0.0.0", port=3002)

requirements.txt

@@ -0,0 +1,21 @@
+langgraph
+langchain
+python-dotenv
+motor
+langchain-community
+langchain-mongodb
+fastapi
+uvicorn
+pytz
+PyJWT==2.8.0
+python_jose==3.3.0
+pydantic[email]
+jose
+langchain-google-genai
+python-dateutil
+pandas
+openpyxl
+langchain-redis
+redis
+bs4
+duckduckgo-search

src/apis/controllers/auth_controller.py

@@ -0,0 +1,38 @@
+from fastapi import HTTPException, status
+from src.apis.models.user_models import User
+from src.utils.mongo import UserCRUD
+from src.apis.providers.jwt_provider import JWTProvider
+from src.utils.logger import logger
+import jwt
+
+jwt_provider = JWTProvider()
+
+
+async def login_control(token):
+    if not token:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Authorization Token is required",
+        )
+    decoded_token = jwt.decode(token, options={"verify_signature": False})
+    decoded_data = {
+        "name": decoded_token["name"],
+        "email": decoded_token["email"],
+        "picture": decoded_token["picture"],
+    }
+    user = User(**decoded_data)
+    logger.info(f"User {user} is logging in.")
+    existing_user = await UserCRUD.read_one({"email": user.email})
+    if not existing_user:
+        user_id = await UserCRUD.create(user.model_dump())
+        logger.info(f"User {user.email} created.")
+    else:
+        user_id = existing_user["_id"]
+
+    logger.info(f"User {user.email} logged in.")
+    token = jwt_provider.encrypt({"id": str(user_id)})
+    user_data = user.__dict__
+    user_data.pop("created_at", None)
+    user_data.pop("updated_at", None)
+    user_data.pop("expire_at", None)
+    return token, user_data

src/apis/controllers/chat_controller.py

@@ -0,0 +1,240 @@
+from langchain_core.messages import HumanMessage, AIMessage
+from src.langgraph.multi_agent.chat.chat_flow import app as workflow
+from src.utils.mongo import chat_messages_history
+from src.utils.logger import logger
+from src.utils.mongo import chat_history_management_crud
+from src.apis.interfaces.api_interface import Chat
+from src.utils.helper import handle_validator_raise
+from src.utils.redis import get_key_redis, set_key_redis
+import json
+from langchain_core.messages.ai import AIMessageChunk
+from fastapi import BackgroundTasks
+from fastapi.responses import JSONResponse
+
+
+@handle_validator_raise
+def post_process_history(history):
+    processed_history = []
+    for entry in history:
+        if entry["type"] == "human":
+            processed_history.append(HumanMessage(content=entry["content"]))
+        elif entry["type"] == "ai":
+            processed_history.append(AIMessage(content=entry["content"]))
+    return processed_history
+
+
+async def save_history(user_id, human_message, ai_message, intent):
+    messages_add_to_history = [HumanMessage(human_message), AIMessage(ai_message)]
+    messages_add_to_history_dict = [
+        {"type": "human", "content": human_message},
+        {"type": "ai", "content": ai_message},
+    ]
+    messages_add_to_history_cache = {
+        "message": messages_add_to_history_dict,
+        "intent": intent,
+    }
+    history = chat_messages_history(user_id)
+    await history.aadd_messages(messages_add_to_history)
+    check_exist_history = await chat_history_management_crud.read_one(
+        {"session_id": user_id}
+    )
+    if check_exist_history is None:
+        await chat_history_management_crud.create(
+            {"user_id": user_id, "session_id": user_id, "intent": intent}
+        )
+        logger.info("History created")
+    else:
+        await chat_history_management_crud.update(
+            {"session_id": user_id}, {"intent": intent}
+        )
+        logger.info("History updated")
+    history_cache = await get_key_redis(f"chat_history_{user_id}")
+    if history_cache is not None:
+        history_cache = eval(history_cache)
+        history_cache["message"] = (
+            history_cache["message"] + messages_add_to_history_dict
+        )
+        history_cache["intent"] = intent
+        await set_key_redis(
+            f"chat_history_{user_id}",
+            str(history_cache),
+        )
+        return {"message": "History updated"}
+    await set_key_redis(f"chat_history_{user_id}", str(messages_add_to_history_cache))
+    return {"message": "History created"}
+
+
+async def chat_streaming_function(user, data: Chat, background_tasks: BackgroundTasks):
+    human_message = data.message
+    history = data.history
+    lat = data.lat
+    long = data.long
+    language = data.language
+    logger.info(f"Language: {language}")
+    process_history = post_process_history(history) if history is not None else None
+    config = {
+        "configurable": {
+            "user_id": user["id"],
+            "user_email": user["email"],
+            "contact_number": user["contact_number"],
+            "session_id": user["id"],
+            "lat": lat,
+            "long": long,
+        }
+    }
+    # try:
+    initial_input = {
+        "messages": [("user", human_message)],
+        "messages_history": process_history,
+        "entry_message": None,
+        "manual_save": False,
+        "intent": data.intent,
+        "language": language,
+        "tool_name": None,
+    }
+    last_output_state = None
+    temp = ""
+    async for event in workflow.astream(
+        input=initial_input,
+        config=config,
+        stream_mode=["messages", "values"],
+    ):
+        event_type, event_message = event
+        if event_type == "messages":
+            message, metadata = event_message
+            if (
+                isinstance(message, AIMessageChunk)
+                and message.tool_calls
+                and message.tool_call_chunks[0]["name"] != "ClassifyUserIntent"
+            ):
+                tool_name = message.tool_call_chunks[0]["name"]
+                message_yield = json.dumps(
+                    {"type": "tool_call", "content": tool_name}, ensure_ascii=False
+                )
+                print(message_yield)
+                yield message_yield + "\n"
+            if metadata["langgraph_node"] in [
+                "primary_assistant",
+                "scheduling_agent",
+                "book_hotel_agent",
+            ]:
+
+                if message.content:
+                    temp += message.content
+                    message_yield = json.dumps(
+                        {"type": "message", "content": temp}, ensure_ascii=False
+                    )
+                    print(message_yield)
+                    yield message_yield + "\n"
+        if event_type == "values":
+            last_output_state = event_message
+
+    final_ai_output = last_output_state["messages"][-1].content
+    final_intent = last_output_state["intent"]
+    tool_name_important = last_output_state["tool_name"]
+
+    final_response = json.dumps(
+        {
+            "type": "final",
+            "content": final_ai_output,
+            "intent": final_intent,
+            "tool_name": tool_name_important,
+        },
+        ensure_ascii=False,
+    )
+    yield final_response
+
+    background_tasks.add_task(
+        save_history, user["id"], human_message, final_ai_output, final_intent
+    )
+
+
+async def chat_function(user, data: Chat, background_tasks: BackgroundTasks):
+    message = data.message
+    history = data.history
+    lat = data.lat
+    long = data.long
+    language = data.language
+    logger.info(f"Language: {language}")
+    process_history = post_process_history(history) if history is not None else None
+    config = {
+        "configurable": {
+            "user_id": user["id"],
+            "user_email": user["email"],
+            "contact_number": user["contact_number"],
+            "session_id": user["id"],
+            "lat": lat,
+            "long": long,
+        }
+    }
+    # try:
+    initial_input = {
+        "messages": [("user", message)],
+        "messages_history": process_history,
+        "entry_message": None,
+        "manual_save": False,
+        "intent": data.intent,
+        "language": language,
+        "tool_name": None,
+    }
+    output = await workflow.ainvoke(initial_input, config)
+
+    final_ai_output = output["messages"][-1].content
+    final_intent = output["intent"]
+    tool_name = output["tool_name"]
+
+    if final_ai_output is None:
+        return JSONResponse(
+            content={"message": "Error in chat_function"}, status_code=500
+        )
+    background_tasks.add_task(
+        save_history, user["id"], data.message, final_ai_output, final_intent
+    )
+
+    response_ouput = {
+        "message": final_ai_output,
+        "intent": final_intent,
+        "tool_name": tool_name,
+    }
+    return JSONResponse(content=response_ouput, status_code=200)
+
+
+async def get_intent_function(session_id):
+    record = await chat_history_management_crud.read_one({"session_id": session_id})
+    if record is None:
+        return None
+
+    return record["intent"]
+
+
+async def get_history_function(session_id):
+    history = chat_messages_history(session_id, 50)
+    try:
+        history_messages = await get_key_redis(f"chat_history_{session_id}")
+        if not history_messages:
+            logger.info("History not found in redis")
+            history_messages = await history.aget_messages()
+            history_messages = [
+                i.model_dump(include=["type", "content"]) for i in history_messages
+            ]
+            intent = await get_intent_function(session_id)
+            return {"message": history_messages, "intent": intent}
+        history_messages = eval(history_messages)
+        return history_messages
+    except Exception as e:
+        logger.error(f"Error in get_history_function: {e}")
+        return {"message": [], "intent": None}
+
+
+async def list_chat_history_function(user_id: str):
+    result = await chat_history_management_crud.read({"user_id": user_id})
+    if result is None:
+        return []
+    result = [i["session_id"] for i in result]
+    return result
+
+
+async def delete_chat_history_function(session_id: str):
+    history = chat_messages_history(session_id, 50)
+    await history.aclear()
+    return {"message": "Chat history has been deleted"}

src/apis/controllers/destination_controller.py

@@ -0,0 +1,37 @@
+from typing import List, Dict, Any
+import aiohttp
+from fastapi import HTTPException
+from src.utils.logger import logger
+async def destination_suggestion_controller(question: str, top_k: int = 5) -> List[Dict[str, Any]]:
+    async with aiohttp.ClientSession() as session:
+        # Get question tags
+        try:
+            async with session.get(
+                f"https://darkbreakerk-triventure-ai.hf.space/model/get_question_tags/{question}"
+            ) as response_tag:
+                if response_tag.status == 200:
+                    tag_data = await response_tag.json()
+                    tags = " ".join(tag_data["question_tags"])
+                    logger.info(f"Tags: {tags} for question: {question}")
+                else:
+                    raise HTTPException(
+                        status_code=response_tag.status,
+                        detail=f"Tag request failed with status {response_tag.status}"
+                    )
+
+            # Get destinations list
+            async with session.get(
+                f"https://darkbreakerk-triventure-ai.hf.space/model/get_destinations_list/{tags}/{top_k}"
+            ) as response:
+                if response.status == 200:
+                    data = await response.json()
+                    logger.info(f"Destination suggestion for question: {data}")
+                    return data["destinations_list"]
+                else:
+                    raise HTTPException(
+                        status_code=response.status,
+                        detail=f"Destinations request failed with status {response.status}"
+                    )
+                    
+        except aiohttp.ClientError as e:
+            raise HTTPException(status_code=500, detail=f"Request failed: {str(e)}")

src/apis/controllers/hotel_controller.py

@@ -0,0 +1,109 @@
+from typing import Optional, Dict, Union
+from datetime import datetime
+from src.utils.mongo import BookHotelCRUD
+from src.utils.logger import logger
+import smtplib
+from datetime import datetime
+from email.mime.multipart import MIMEMultipart
+from email.mime.text import MIMEText
+
+
+def send_booking_confirmation_email(
+    user_email: str,
+    user_contact_number: str,
+    hotel_email: str,
+    start_time: datetime,
+    end_time: datetime,
+):
+    host_email = "htbqn2003@gmail.com"
+    msg = MIMEMultipart()
+    msg["From"] = host_email
+    msg["To"] = hotel_email
+    msg["Subject"] = f"TriVenture AI Application Booking from {user_email}"
+
+    email_content = f"""
+    <html>
+    <body style="font-family: Arial, sans-serif; color: #333;">
+        <h2 style="color: #0073e6;">Booking Confirmation</h2>
+        <p style="font-size: 16px;">Dear <strong>Hotel Manager</strong>,</p>
+        <p style="font-size: 16px;">
+            I would like to book your hotel from <strong>{start_time.strftime('%Y-%m-%d %H:%M:%S')}</strong> to <strong>{end_time.strftime('%Y-%m-%d %H:%M:%S')}</strong>.
+        </p>
+        <p style="font-size: 16px;">My personal information is as follows:</p>
+        <ul style="font-size: 16px;">
+            <li><strong>Email:</strong> {user_email}</li>
+            <li><strong>Contact Number:</strong> {user_contact_number}</li>
+        </ul>
+        <p style="font-size: 16px;">With start time: <strong>{start_time.strftime('%Y-%m-%d %H:%M:%S')}</strong> and end time: <strong>{end_time.strftime('%Y-%m-%d %H:%M:%S')}</strong>.</p>
+        <br>
+        <p style="font-size: 16px;">Best regards,<br><strong>TriVenture AI Application</strong></p>
+    </body>
+    </html>
+    """
+    msg.attach(MIMEText(email_content, "html"))
+    try:
+        server = smtplib.SMTP("smtp.gmail.com", 587)
+        server.starttls()
+        server.login(host_email, "lvvi ouzk vafe vgem")
+        server.sendmail(host_email, hotel_email, msg.as_string())
+        server.quit()
+        logger.info("Booking confirmation email sent successfully.")
+    except Exception as e:
+        logger.error(f"Failed to send email: {str(e)}")
+
+
+async def book_hotel_controller(
+    hotel_email: str,
+    hotel_name: str,
+    address: str,
+    phone_number: Optional[str],
+    website: Optional[str],
+    start_time_str: Optional[datetime],
+    end_time_str: Optional[datetime],
+    user_id,
+) -> Union[Dict[str, str], Dict[str, str]]:
+    try:
+        check_existing = await BookHotelCRUD.read_one(
+            {
+                "user_id": user_id,
+                "$or": [
+                    {
+                        "start_time": {"$lte": start_time_str},
+                        "end_time": {"$gt": start_time_str},
+                    },
+                    {
+                        "start_time": {"$lt": end_time_str},
+                        "end_time": {"$gte": end_time_str},
+                    },
+                    {
+                        "start_time": {"$gte": start_time_str},
+                        "end_time": {"$lte": end_time_str},
+                    },
+                ],
+            }
+        )
+
+        if check_existing:
+            logger.info(f"Existing booking: {check_existing}")
+            return {
+                "status": "error",
+                "message": "In the same time, you have already booked a hotel named: "
+                + check_existing["hotel_name"],
+            }
+
+        result = await BookHotelCRUD.create(
+            {
+                "user_id": user_id,
+                "hotel_name": hotel_name,
+                "address": address,
+                "phone_number": phone_number,
+                "hotel_email": hotel_email,
+                "website": website,
+                "start_time": start_time_str,
+                "end_time": end_time_str,
+            }
+        )
+        logger.info(f"Hotel booking result: {result}")
+        return {"status": "success", "message": "Hotel booked successfully"}
+    except Exception as e:
+        return {"status": "error", "message": str(e)}

src/apis/controllers/location_controller.py

@@ -0,0 +1,77 @@
+from src.utils.logger import logger
+from src.utils.helper import format_geoapify_response, format_weather_data
+from fastapi.responses import JSONResponse
+import requests
+import os
+
+
+def get_location_details(lat, long):
+    api_key = os.getenv("OPENCAGE_API_KEY")
+    url = f"https://api.opencagedata.com/geocode/v1/json?q={lat},{long}&pretty=1&key={api_key}"
+    response = requests.get(url)
+    if response.status_code == 200:
+        logger.info("Location details fetched successfully")
+        return JSONResponse(
+            content={"location": response.json()["results"][0]["formatted"]},
+            status_code=200,
+        )
+    else:
+        return JSONResponse(
+            content={"error": "Error fetching location details"}, status_code=500
+        )
+
+
+def get_nearby_places(lat, long, radius, kinds):
+    api_key = os.getenv("OPENTRIPMAP_API_KEY", None)
+    if api_key is None:
+        logger.error("OpenTripMap API key not found")
+        return JSONResponse(content={"error": "API key not found"}, status=500)
+    url = "https://api.opentripmap.com/0.1/en/places/radius"
+    params = {
+        "radius": radius,
+        "lon": long,
+        "lat": lat,
+        "kinds": kinds,
+        "apikey": api_key,
+    }
+    response = requests.get(url, params=params, headers={"accept": "application/json"})
+    if response.status_code == 200:
+        logger.info("Places fetched successfully")
+        return JSONResponse(
+            content={"places": response.json().get("features", [])}, status_code=200
+        )
+    else:
+        return JSONResponse(content={"error": "Error fetching places"}, status_code=500)
+
+
+def get_places(lat, long, radius, categories, limit=20):
+    api_key = os.getenv("GEOAPIFY_API_KEY", None)
+    if api_key is None:
+        logger.error("Geoapify API key not found")
+        return JSONResponse(content={"error": "API key not found"}, status=500)
+    url = f"https://api.geoapify.com/v2/places?categories={categories}&filter=circle:{long},{lat},{radius}&limit={limit}&apiKey={api_key}"
+    response = requests.get(url)
+    if response.status_code == 200:
+        response = response.json().get("features", [])
+        # logger.info(f"RESPONSE:{response}")
+        if response:
+            response = format_geoapify_response(response, long, lat)
+        return JSONResponse(content=response, status_code=200)
+    else:
+        return JSONResponse(content={"error": "Error fetching places"}, status_code=500)
+
+
+def get_weather(lat, long):
+    api_key = os.getenv("OPENWEATHER_API_KEY", None)
+    if api_key is None:
+        logger.error("OpenWeather API key not found")
+        return JSONResponse(content={"error": "API key not found"}, status=500)
+    url = f"https://api.openweathermap.org/data/3.0/onecall?lat={lat}&lon={long}&exclude=hourly,daily&appid={api_key}"
+    response = requests.get(url)
+    if response.status_code == 200:
+        response = format_weather_data(response.json())
+        return JSONResponse(content=response, status_code=200)
+    else:
+        return JSONResponse(
+            content={"error": "Error fetching weather"}, status_code=500
+        )

src/apis/controllers/planner_controller.py

@@ -0,0 +1,57 @@
+import json
+from fastapi import BackgroundTasks
+from src.langgraph.multi_agent.planner.planner_flow import planner_app
+from src.utils.helper import parse_itinerary
+
+
+async def message_generator(input_graph, config, background: BackgroundTasks):
+
+    last_output_state = None
+    temp = ""
+    async for event in planner_app.astream(
+        input=input_graph,
+        config=config,
+        stream_mode=["messages", "values"],
+    ):
+        event_type, event_message = event
+        if event_type == "messages":
+            message, _ = event_message
+            if message.content:
+                temp += message.content
+                message_yield = json.dumps(
+                    {"type": "message", "content": temp},
+                    ensure_ascii=False,
+                )
+                yield message_yield + "\n"
+        if event_type == "values":
+            last_output_state = event_message
+    parser_ouput = parse_itinerary(last_output_state["final_answer"])
+    final_response = json.dumps(
+        {
+            "type": "final",
+            "content": parser_ouput,
+        },
+        ensure_ascii=False,
+    )
+    yield final_response + "\n"
+
+
+from pydantic import BaseModel, Field
+from datetime import datetime
+
+
+class Activity(BaseModel):
+    """Activity model"""
+
+    description: str = Field(
+        ..., description="Short description of the activity can have location"
+    )
+    start_time: datetime = Field(..., description="Start time of the activity")
+    end_time: datetime = Field(..., description="End time of the activity")
+
+
+class Output(BaseModel):
+    """Output model"""
+
+    activities: list[Activity] = Field(..., description="List of activities")
+    note: str = Field(..., description="Note for the user")

src/apis/controllers/post_controller.py

@@ -0,0 +1,122 @@
+from typing import Optional, Dict, Union
+from datetime import datetime
+from src.utils.mongo import PostCRUD, CommentCRUD, LikeCRUD
+from src.utils.logger import logger
+from datetime import datetime
+from bson import ObjectId
+from typing import Optional, Dict
+from datetime import datetime
+from bson import ObjectId
+
+
+def serialize_datetime(obj):
+    if isinstance(obj, datetime):
+        return obj.isoformat()
+    if isinstance(obj, ObjectId):
+        return str(obj)
+    return obj
+
+
+async def create_a_post_controller(
+    content: str, user_id: str, destination_id: str
+) -> Dict:
+    try:
+        post = {
+            "content": content,
+            "user_id": user_id,
+            "destination_id": destination_id,
+            "comment_ids": [],
+            "like": [],
+        }
+        await PostCRUD.create(post)
+        return {"status": "success", "message": "Post created successfully"}
+    except Exception as e:
+        return {"status": "error", "message": str(e)}
+
+
+async def get_a_post_controller(post_id: str) -> Dict:
+    try:
+        post = await PostCRUD.find_by_id(post_id)
+        if post is None:
+            return {"status": "error", "message": "Post not found"}
+
+        # Convert datetime objects in the post
+        serialized_post = {
+            "id": serialize_datetime(post.get("_id")),
+            "content": post.get("content"),
+            "user_id": post.get("user_id"),
+            "destination_id": post.get("destination_id"),
+            "comment_ids": post.get("comment_ids", []),
+            "like": post.get("like", []),
+            "created_at": serialize_datetime(post.get("created_at")),
+            "updated_at": serialize_datetime(post.get("updated_at")),
+        }
+
+        return {"status": "success", "message": serialized_post}
+    except Exception as e:
+        logger.error(f"Error getting post: {str(e)}")
+        return {"status": "error", "message": str(e)}
+
+
+async def list_all_posts_controller():
+    try:
+        posts = await PostCRUD.find_all()
+        serialized_posts = []
+        for post in posts:
+            serialized_post = {
+                "id": serialize_datetime(post.get("_id")),
+                "content": post.get("content"),
+                "user_id": post.get("user_id"),
+                "destination_id": post.get("destination_id"),
+                "comment_ids": post.get("comment_ids", []),
+                "like": post.get("like", []),
+                "created_at": serialize_datetime(post.get("created_at")),
+                "updated_at": serialize_datetime(post.get("updated_at")),
+            }
+            serialized_posts.append(serialized_post)
+        return {"status": "success", "message": serialized_posts}
+    except Exception as e:
+        logger.error(f"Error listing posts: {str(e)}")
+        return {"status": "error", "message": str(e)}
+
+
+async def update_a_post_controller(
+    user_id: str, post_id: str, content: str, destination_id: str
+) -> Dict:
+    try:
+        exist_data = await PostCRUD.find_by_id(post_id)
+        if exist_data["user_id"] != user_id:
+            return {
+                "status": "error",
+                "message": "You are not allowed to update this post",
+            }
+        if exist_data is None:
+            return {"status": "error", "message": "Post not found"}
+        await PostCRUD.update(
+            {"_id": ObjectId(post_id)},
+            {
+                "content": content,
+                "destination_id": destination_id,
+            },
+        )
+        return {"status": "success", "message": "Post updated successfully"}
+    except Exception as e:
+        logger.error(f"Error updating post: {str(e)}")
+        return {"status": "error", "message": str(e)}
+
+
+async def delete_a_post_controller(user_id: str, post_id: str) -> Dict:
+    try:
+        exist_data = await PostCRUD.find_by_id(post_id)
+        if exist_data["user_id"] != user_id:
+            return {
+                "status": "error",
+                "message": "You are not allowed to delete this post",
+            }
+        if exist_data is None:
+            return {"status": "error", "message": "Post not found"}
+        await PostCRUD.delete({"_id": ObjectId(post_id)})
+        return {"status": "success", "message": "Post deleted successfully"}
+    except Exception as e:
+        logger.error(f"Error deleting post: {str(e)}")
+        return {"status": "error", "message": str(e)}

src/apis/controllers/scheduling_controller.py

@@ -0,0 +1,238 @@
+from typing import Optional, Dict, Union
+from datetime import datetime
+from src.utils.mongo import ScheduleCRUD
+from src.utils.logger import logger
+from datetime import datetime
+from bson import ObjectId
+from typing import Optional, Dict
+from datetime import datetime
+from bson import ObjectId
+
+
+async def create_a_activity_controller(
+    activity_id: Optional[str],
+    activity_category: str,
+    description: str,
+    start_time: datetime,
+    end_time: datetime,
+    user_id: str,
+) -> 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.""",
+            }
+        document = {
+            "user_id": user_id,
+            "activity_category": activity_category,
+            "description": description,
+            "start_time": start_time,
+            "end_time": end_time,
+        }
+        if activity_id:
+            logger.info(f"Create activity with ID: {activity_id}")
+            document["id"] = activity_id
+        await ScheduleCRUD.create(document)
+        return {"status": "success", "message": "Activity created successfully"}
+
+    except Exception as e:
+        logger.error(f"Error creating activity: {e}")
+        return {"status": "error", "message": f"Error creating activity: {str(e)}"}
+
+
+async def search_activities_controller(
+    start_time: datetime,
+    end_time: datetime,
+    user_id: str,
+) -> Dict[str, Union[str, list[dict]]]:
+    try:
+        if not start_time or not end_time:
+            activities = await ScheduleCRUD.read({"user_id": user_id})
+        else:
+            activities = await ScheduleCRUD.read(
+                {
+                    "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},
+                        },
+                    ],
+                }
+            )
+        return {"status": "success", "message": activities}
+    except Exception as e:
+        logger.error(f"Error reading activities: {e}")
+        return {"status": "error", "message": f"Error reading activities {e}"}
+
+
+async def update_a_activity_controller(
+    activity_id: Optional[str],
+    activity_category: str,
+    description: str,
+    start_time: datetime,
+    end_time: datetime,
+    user_id: str,
+) -> Dict[str, str]:
+    try:
+        if activity_id:
+            existing_activity = await ScheduleCRUD.read_one(
+                {"_id": ObjectId(activity_id)}
+            )
+            if not existing_activity:
+                return {
+                    "status": "error",
+                    "message": f"Activity with id {activity_id} not found",
+                }
+        else:
+            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 not existing_activity:
+                return {
+                    "status": "error",
+                    "message": f"Activity with id {activity_id} not found",
+                }
+            activity_id = existing_activity["_id"]
+
+        await ScheduleCRUD.update(
+            {"_id": ObjectId(activity_id)},
+            {
+                "activity_category": activity_category,
+                "description": description,
+                "start_time": start_time,
+                "end_time": end_time,
+            },
+        )
+        return {"status": "success", "message": "Activity updated successfully"}
+    except Exception as e:
+        logger.error(f"Error updating activity: {e}")
+        return {"status": "error", "message": f"Error updating activity {e}"}
+
+
+async def delete_activities_controller(
+    activity_id: Optional[str],
+    start_time: datetime,
+    end_time: datetime,
+    user_id: str,
+) -> Dict[str, str]:
+    try:
+        if activity_id:
+            existing_activity = await ScheduleCRUD.read_one(
+                {"_id": ObjectId(activity_id)}
+            )
+            if not existing_activity:
+                return {
+                    "status": "error",
+                    "message": "Don't have activity at the given time",
+                }
+            # Delete single activity by ID
+            await ScheduleCRUD.delete({"_id": ObjectId(activity_id)})
+            return {"status": "success", "message": "Successfully deleted activity"}
+        else:
+            # Find all activities in the time range
+            existing_activities = await ScheduleCRUD.read(
+                {
+                    "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 not existing_activities:
+                return {
+                    "status": "error",
+                    "message": "Don't have any activities at the given time range",
+                }
+
+            logger.info(f"Found {len(existing_activities)} activities to delete")
+
+            # Delete all activities in the time range
+            await ScheduleCRUD.delete(
+                {
+                    "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},
+                        },
+                    ],
+                }
+            )
+
+            return {
+                "status": "success",
+                "message": f"Successfully deleted {len(existing_activities)} activities",
+            }
+
+    except Exception as e:
+        logger.error(f"Error deleting activities: {e}")
+        return {"status": "error", "message": f"Error deleting activities: {e}"}

src/apis/create_app.py

@@ -0,0 +1,64 @@
+from fastapi import FastAPI, APIRouter
+from contextlib import asynccontextmanager
+import base64
+import json
+import os
+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.utils.logger import logger
+
+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)
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    logger.info("Starting the app")
+    # Load the ML model
+    encoded_env = os.getenv("ENCODED_ENV")
+
+    if encoded_env:
+        # Decode the base64 string
+        decoded_env = base64.b64decode(encoded_env).decode()
+
+        # Load it as a dictionary
+        env_data = json.loads(decoded_env)
+
+        # Set environment variables
+        for key, value in env_data.items():
+            os.environ[key] = value
+
+        # Verify by printing an environment variable (for testing)
+        print(os.getenv("MONGODB_URL"))
+    yield
+
+
+def create_app():
+    app = FastAPI(
+        docs_url="/",
+        title="eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6IjY3M2IwZDMzNTQ5OTg5Zjc1NmZhMzk3MCJ9.a3A9B1ZpzkzIPvhLqFpasK4sk2ocqmc1M80rtyAkbmM",
+    )
+
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    return app

src/apis/interfaces/api_interface.py

@@ -0,0 +1,106 @@
+from pydantic import BaseModel, Field
+from typing import Optional
+from src.apis.models.BaseModel import BaseDocument
+from typing import List
+
+class Chat(BaseModel):
+    message: str = Field(..., title="Message from user")
+    session_id: Optional[str] = Field("6701fe32d76fde9d8df1de8e", title="Session Id")
+    history: Optional[list] = Field(None, title="Chat history")
+    lat: Optional[float] = Field(13.717162954654036, title="Latitude")
+    long: Optional[float] = Field(109.21054173319894, title="Longitude")
+    intent: Optional[str] = Field(None, title="Intent")
+    language: Optional[str] = Field("en", title="Language")
+
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "message": "Đề xuất cho 1 địa điểm",
+                "session_id": "6d16c975e8b74d979d6d680e6ff536eb",
+                "history": [
+                    {"content": "tìm khách sạn xịn ở QUy Nhơn", "type": "human"},
+                    {
+                        "content": "search_hotels_luxury  on frontend for user to select",
+                        "type": "ai",
+                    },
+                ],
+                "lat": 13.717162954654036,
+                "long": 109.21054173319894,
+                "intent": None,
+                "language": "Vietnamese",
+            }
+        }
+
+
+class ChatHistory(BaseModel):
+    session_id: Optional[str] = Field(None, title="Session Id")
+
+    class Config:
+        json_schema_extra = {"example": {"session_id": "6701fe32d76fde9d8df1de8e"}}
+
+
+class ChatHistoryManagement(BaseDocument):
+    session_id: str = Field("6701fe32d76fde9d8df1de8e", title="Session Id")
+    user_id: str = Field("6701fe32d76fde9d8df1de8e", title="User Id")
+    intent: Optional[str] = Field(None, title="Intent")
+
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "session_id": "6701fe32d76fde9d8df1de8e",
+                "user_id": "6701fe32d76fde9d8df1de8e",
+                "intent": "greeting",
+            }
+        }
+
+
+class Location(BaseModel):
+    lat: float = Field(13.717162954654036, title="Latitude")
+    long: float = Field(109.21054173319894, title="Longitude")
+    radius: Optional[int] = Field(5000, title="Radius in meters")
+    location_text: Optional[str] = Field("Hanoi", title="Location text")
+    categories: Optional[str] = Field("interesting_places", title="Type of places")
+
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "lat": 13.717162954654036,
+                "long": 109.21054173319894,
+                "radius": 5000,
+                "location_text": "Hanoi",
+                "categories": "interesting_places",
+            }
+        }
+
+
+class Destination(BaseModel):
+    id: int = Field(..., title="Destination Id", gt=0)
+    name: str = Field(..., title="Destination Name", min_length=1)
+    location: str = Field(..., title="Location", min_length=1)
+    description: str = Field(..., title="Description", min_length=1)
+
+
+class Planning(BaseModel):
+    duration: str = Field("7", title="Duration")
+    start_date: str = Field("June 1-7", title="Start date")
+    location: str = Field("Quy Nhon, Vietnam", title="Location")
+    interests: str = Field("natural, cultural", title="Interests")
+    nation: str = Field("Vietnamese", title="Nation")
+    include_destination: Optional[List[Destination]] = Field([], title="Include destinations")
+    limit_interation: Optional[int] = Field(3, title="Limit interation")
+
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "duration": "7",
+                "start_date": "June 1-7",
+                "location": "Quy Nhon, Vietnam",
+                "interests": "natural, cultural",
+                "nation": "nation",
+                "include_destination": {
+                    "destination": "Ky Co Beach",
+                    "description": "Ky Co Beach is a beautiful beach in Quy Nhon, Vietnam",
+                },
+                "limit_interation": 3,
+            }
+        }

src/apis/interfaces/auth_interface.py

@@ -0,0 +1,18 @@
+from pydantic import BaseModel, Field
+
+
+class Credential(BaseModel):
+    credential: str = Field(..., example="F9P/3?@q2!vq")
+
+
+class _LoginResponseInterface(BaseModel):
+    token: str = Field(..., title="JWT Token")
+
+
+class LoginResponseInterface(BaseModel):
+    msg: str = Field(..., title="Message")
+    data: _LoginResponseInterface = Field(..., title="User Data")
+
+
+class AuthInterface(BaseModel):
+    gtoken: str = Field(..., title="Google Access-Token")

src/apis/middlewares/auth_middleware.py

@@ -0,0 +1,40 @@
+from typing import Annotated
+from fastapi import Depends
+from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
+from fastapi.responses import JSONResponse
+from src.apis.providers.jwt_provider import jwt_provider as jwt
+from src.apis.models.user_models import get_user
+from src.utils.mongo import UserCRUD
+from bson import ObjectId
+from jose import JWTError
+from src.utils.logger import logger
+
+security = HTTPBearer()
+
+
+async def get_current_user(
+    credentials: Annotated[HTTPAuthorizationCredentials, Depends(security)]
+):
+
+    try:
+        token = credentials.credentials
+        if not token:
+            return JSONResponse(
+                content={"msg": "Authentication failed"}, status_code=401
+            )
+        payload = jwt.decrypt(token)
+        user_id: str = payload["id"]
+        if not user_id:
+            return JSONResponse(
+                content={"msg": "Authentication failed"}, status_code=401
+            )
+        user = await UserCRUD.read_one({"_id": ObjectId(user_id)})
+        user_email = user.get("email", None)
+        logger.info(f"Request of user: {user_email}")
+        if not user:
+            return JSONResponse(
+                content={"msg": "Authentication failed"}, status_code=401
+            )
+        return get_user(user)
+    except JWTError:
+        return JSONResponse(content={"msg": "Authentication failed"}, status_code=401)

src/apis/models/BaseModel.py

@@ -0,0 +1,17 @@
+from pydantic import BaseModel, Field
+from typing import Optional
+
+from datetime import datetime, timezone
+
+
+class BaseDocument(BaseModel):
+    created_at: Optional[datetime] = Field(
+        default_factory=lambda: datetime.now(timezone.utc)
+    )
+    updated_at: Optional[datetime] = Field(
+        default_factory=lambda: datetime.now(timezone.utc)
+    )
+    expire_at: Optional[datetime] = None
+
+    class Config:
+        arbitrary_types_allowed = True

src/apis/models/destination_models.py

@@ -0,0 +1,28 @@
+from pydantic import Field
+from typing import Literal
+from .BaseModel import BaseDocument
+from bson import ObjectId
+
+
+class Destination(BaseDocument):
+    manager_id: str = Field("", description="Manager's id")
+    address: str = Field("", description="Destination's address")
+    name: str = Field("", description="Destination's name")
+    picture: list[str] = Field([], description="Destination's picture")
+    type: Literal["hotel", "restaurant", "attraction"] = Field(
+        "", description="Destination's type"
+    )
+    status: int = Field(0, description="Destination's status")
+
+    model_config = {
+        "json_schema_extra": {
+            "example": {
+                "manager_id": "1234567890",
+                "address": "1234567890",
+                "name": "ABAO Hotel",
+                "picture": ["https://example.com/picture.jpg"],
+                "type": "hotel",
+                "status": 0,
+            }
+        }
+    }

src/apis/models/hotel_models.py

@@ -0,0 +1,29 @@
+from pydantic import Field, EmailStr
+from typing import Optional
+from datetime import datetime
+from .BaseModel import BaseDocument
+
+
+class BookHotel(BaseDocument):
+    hotel_name: str = Field("", description="Hotel's name")
+    address: str = Field("", description="Hotel's address")
+    phone_number: str = Field("", description="Hotel's phone number")
+    hotel_email: EmailStr = Field("", description="Hotel's email")
+    start_time: Optional[datetime] = Field("", description="Start time of the booking")
+    end_time: Optional[datetime] = Field("", description="End time of the booking")
+    rating: str = Field("", description="Hotel's rating")
+    website: str = Field("", description="Hotel's website")
+
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "hotel_name": "Blue Lagoon Resort",
+                "address": "123 Beachside Blvd, Paradise City, Island Nation 54321",
+                "phone_number": "+1234567890",
+                "hotel_email": "baohtqe170017@fpt.edu.vn",
+                "start_time": "2025-01-05T14:00:00.000+00:00",
+                "end_time": "2025-01-10T11:00:00.000+00:00",
+                "rating": "4.5",
+                "website": "https://www.bluelagoonresort.com",
+            }
+        }

src/apis/models/post_models.py

@@ -0,0 +1,53 @@
+from pydantic import Field
+from .BaseModel import BaseDocument
+
+class Comment(BaseDocument):
+    content: str = Field("", description="Post's content")
+    user_id: str = Field("", description="User's id")
+    post_id: str = Field("", description="Post's id")
+
+    model_config = {
+        "json_schema_extra": {
+            "example": {
+                "content": "John Doe",
+                "user_id": "1234567890",
+                "destination_id": "1234567890",
+                "comment_ids": ["1234567890"],
+            }
+        }
+    }
+
+
+class Like(BaseDocument):
+    user_id: str = Field("", description="User's id")
+    post_id: str = Field("", description="Post's id")
+    comment_id: str = Field("", description="Comment's id")
+    type: int = Field(0, description="Type of like", gt=0, lt=3)
+
+    model_config = {
+        "json_schema_extra": {
+            "example": {
+                "user_id": "1234567890",
+                "post_id": "1234567890",
+                "comment_id": "1234567890",
+            }
+        }
+    }
+
+
+class Post(BaseDocument):
+    content: str = Field("", description="Post's content")
+    user_id: str = Field("", description="User's id")
+    destination_id: str = Field("", description="Destination's id")
+    comment_ids: list[str] = Field([], description="Comment's id")
+    like: list[str] = Field([], description="User's id who like this post")
+    model_config = {
+        "json_schema_extra": {
+            "example": {
+                "content": "John Doe",
+                "user_id": "1234567890",
+                "destination_id": "1234567890",
+                "comment_ids": ["1234567890"],
+            }
+        }
+    }

src/apis/models/schedule_models.py

@@ -0,0 +1,25 @@
+from pydantic import Field
+from typing import Optional
+from datetime import datetime
+from .BaseModel import BaseDocument
+
+
+class Schedule(BaseDocument):
+    id: Optional[str] = Field("", description="Activity's id")
+    user_id: str = Field("", description="User's id")
+    activity_category: str = Field("", description="Activity's category")
+    description: str = Field("", description="Activity's description")
+    start_time: Optional[datetime] = Field("", description="Activity's start time")
+    end_time: Optional[datetime] = Field("", description="Activity's end time")
+
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "id": "61f7b1b7b3b3b3b3b3b3b3",
+                "user_id": "61f7b1b7b3b3b3b3b3b3b3",
+                "activity_category": "Study",
+                "description": "Study for the final exam",
+                "start_time": "2025-01-05T14:00:00.000+00:00",
+                "end_time": "2025-01-05T16:00:00.000+00:00",
+            }
+        }

src/apis/models/user_models.py

@@ -0,0 +1,35 @@
+from pydantic import Field, EmailStr
+from .BaseModel import BaseDocument
+from bson import ObjectId
+
+
+def get_user(user) -> dict:
+    return {
+        "id": str(user["_id"]),
+        "name": user["name"],
+        "email": user["email"],
+        "picture": user["picture"],
+        "contact_number": user["contact_number"],
+    }
+
+
+def list_serial(users) -> list:
+    return [get_user(user) for user in users]
+
+
+class User(BaseDocument):
+    id: str = Field(default_factory=lambda: str(ObjectId()), alias="_id")
+    name: str = Field("", description="User's name")
+    email: EmailStr = Field("", description="User's email")
+    picture: str = Field("", title="User Picture")
+    contact_number: str = Field("", description="User's contact number")
+
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "name": "John Doe",
+                "email": "johnUS192@gmail.com",
+                "picture": "https://example.com/picture.jpg",
+                "contact_number": "1234567890",
+            }
+        }

src/apis/providers/jwt_provider.py

@@ -0,0 +1,37 @@
+from typing import AnyStr, Dict, Union
+import os
+from fastapi import HTTPException, status
+from jose import jwt, JWTError
+
+
+class JWTProvider:
+    """
+    Perform JWT Encryption and Decryption
+    """
+
+    def __init__(
+        self, secret: AnyStr = os.environ.get("JWT_SECRET"), algorithm: AnyStr = "HS256"
+    ):
+        self.secret = secret
+        self.algorithm = algorithm
+
+    def encrypt(self, data: Dict) -> AnyStr:
+        """
+        Encrypt the data with JWT
+        """
+        return jwt.encode(data, self.secret, algorithm=self.algorithm)
+
+    def decrypt(self, token: AnyStr) -> Union[Dict, None]:
+        """
+        Decrypt the token with JWT
+        """
+        try:
+            return jwt.decode(token, self.secret, algorithms=[self.algorithm])
+        except JWTError as e:
+            raise HTTPException(
+                status_code=status.HTTP_401_UNAUTHORIZED,
+                detail=f"Could not validate credentials. {str(e)}",
+            )
+
+
+jwt_provider = JWTProvider()