Upload 148 files

src/apis/config/firebase_config.py

@@ -0,0 +1,36 @@
+import firebase_admin
+from firebase_admin import credentials
+from firebase_admin import storage
+
+import os
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+firebase_url_storageBucket = os.getenv("FIREBASE_URL_STORAGEBUCKET")
+
+# Get credentials from environment variables
+credential_firebase = {
+    "type": os.getenv("TYPE"),
+    "project_id": os.getenv("PROJECT_ID"),
+    "private_key_id": os.getenv("FIREBASE_PRIVATE_KEY_ID"),
+    "private_key": os.getenv("PRIVATE_KEY"),
+    "client_email": os.getenv("CLIENT_EMAIL"),
+    "client_id": os.getenv("CLIENT_ID"),
+    "auth_uri": os.getenv("AUTH_URI"),
+    "token_uri": os.getenv("TOKEN_URI"),
+    "auth_provider_x509_cert_url": os.getenv("AUTH_PROVIDER_X509_CERT_URL"),
+    "client_x509_cert_url": os.getenv("CLIENT_X509_CERT_URL"),
+    "universe_domain": os.getenv("UNIVERSE_DOMAIN"),
+}
+
+
+# Check if the app is not initialized yet
+if not firebase_admin._apps:
+    # Initialize the app with the credentials
+    cred = credentials.Certificate(credential_firebase)
+    firebase_admin.initialize_app(cred, {"storageBucket": firebase_url_storageBucket})
+
+# Initialize Firestore
+firebase_bucket = storage.bucket(app=firebase_admin.get_app())
+print("Storage connected")

src/apis/controllers/chat_controller.py

@@ -65,7 +65,7 @@ async def save_history(user_id, human_message, ai_message, intent):
     #     )
     #     return {"message": "History updated"}
     # await set_key_redis(f"chat_history_{user_id}", str(messages_add_to_history_cache))
-    # return {"message": "History created"}
+    return {"message": "History created"}
 
 
 async def chat_streaming_function(user, data: Chat, background_tasks: BackgroundTasks):

src/apis/controllers/comment_controller.py

@@ -0,0 +1,113 @@
+from typing import Dict
+from datetime import datetime
+from src.utils.mongo import CommentCRUD, LikeCRUD
+from src.utils.logger import logger
+from datetime import datetime
+from bson import ObjectId
+from datetime import datetime
+from bson import ObjectId
+from src.utils.mongo import UserCRUD
+from asyncio import gather
+
+
+def serialize_datetime(obj):
+    if isinstance(obj, datetime):
+        return obj.isoformat()
+    if isinstance(obj, ObjectId):
+        return str(obj)
+    return obj
+
+
+async def create_a_comment_controller(content: str, user_id: str, post_id: str) -> Dict:
+    try:
+        comment = {
+            "content": content,
+            "user_id": user_id,
+            "post_id": post_id,
+        }
+        await CommentCRUD.create(comment)
+        return {"status": "success", "message": "Comment created successfully"}
+    except Exception as e:
+        return {"status": "error", "message": str(e)}
+
+
+async def get_comments_of_a_post_controller(post_id: str) -> Dict:
+    try:
+        comments = await CommentCRUD.read({"post_id": post_id})
+        logger.info(f"COMMENTS: {comments}")
+        user_ids = [comment.get("user_id") for comment in comments]
+        user_infos = await gather(
+            *[UserCRUD.find_by_id(user_id) for user_id in user_ids]
+        )
+        user_info_map = {
+            user_info.get("_id"): user_info for user_info in user_infos if user_info
+        }
+
+        serialized_comments = []
+        for comment in comments:
+            user_id = comment.get("user_id")
+            user_info = user_info_map.get(user_id)
+            serialized_comment = {
+                "id": serialize_datetime(comment.get("_id")),
+                "content": comment.get("content"),
+                "user_id": comment.get("user_id"),
+                "post_id": comment.get("post_id"),
+                "created_at": serialize_datetime(comment.get("created_at")),
+                "updated_at": serialize_datetime(comment.get("updated_at")),
+                "user_info": (
+                    {
+                        "name": user_info.get("name"),
+                        "picture": user_info.get("picture"),
+                    }
+                    if user_info
+                    else None
+                ),
+            }
+            serialized_comments.append(serialized_comment)
+        return {"status": "success", "message": serialized_comments}
+    except Exception as e:
+        logger.error(f"Error getting post: {str(e)}")
+        return {"status": "error", "message": str(e)}
+
+
+async def update_a_comment_controller(
+    user_id: str, comment_id: str, content: str
+) -> Dict:
+    try:
+        exist_data = await CommentCRUD.find_by_id(comment_id)
+        if exist_data is None:
+            return {"status": "error", "message": "Comment not found"}
+        if exist_data["user_id"] != user_id:
+            return {
+                "status": "error",
+                "message": "You are not allowed to update this comment",
+            }
+
+        await CommentCRUD.update(
+            {"_id": ObjectId(comment_id)},
+            {
+                "content": content,
+            },
+        )
+        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_comment_controller(user_id: str, comment_id: str) -> Dict:
+    try:
+        exist_data = await CommentCRUD.find_by_id(comment_id)
+        if exist_data is None:
+            return {"status": "error", "message": "Comment not found"}
+        if exist_data["user_id"] != user_id:
+            return {
+                "status": "error",
+                "message": "You are not allowed to delete this comment",
+            }
+
+        await CommentCRUD.delete({"_id": ObjectId(comment_id)})
+        return {"status": "success", "message": "Comment deleted successfully"}
+    except Exception as e:
+        logger.error(f"Error deleting post: {str(e)}")
+        return {"status": "error", "message": str(e)}

src/apis/create_app.py

@@ -8,6 +8,7 @@ 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
 api_router = APIRouter()
 api_router.include_router(router_chat)
 api_router.include_router(router_auth)
@@ -17,6 +18,7 @@ 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)
 
 
 def create_app():

src/apis/models/post_models.py

@@ -1,6 +1,7 @@
 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")
@@ -11,8 +12,7 @@ class Comment(BaseDocument):
             "example": {
                 "content": "John Doe",
                 "user_id": "1234567890",
-                "destination_id": "1234567890",
-                "comment_ids": ["1234567890"],
+                "post_id": "1234567890",
             }
         }
     }

src/apis/providers/firebase_provider.py

@@ -0,0 +1,64 @@
+from src.apis.config.firebase_config import firebase_bucket
+
+
+def upload_file_to_storage(file_path, file_name):
+    """
+    Upload a file to Firebase Storage
+    param:
+        file_path: str - The path of the file on local machine to be uploaded
+    return:
+        str - The public URL of the uploaded file
+    """
+    file_name = file_name
+    blob = firebase_bucket.blob(file_name)
+    blob.upload_from_filename(file_path)
+    blob.make_public()
+
+    return blob.public_url
+
+
+def delete_file_from_storage(file_name):
+    """
+    Delete a file from Firebase Storage
+    param:
+        file_name: str - The name of the file to be deleted
+    return:
+        bool - True if the file is deleted successfully, False if the file is not found
+    """
+    try:
+        blob = firebase_bucket.blob(file_name)
+        blob.delete()
+        return True
+    except Exception as e:
+        print("Error:", e)
+        return False
+
+
+def list_all_files_in_storage():
+    """
+    View all files in Firebase Storage
+    return:
+        dict - Dictionary with keys are names and values are url of all files in Firebase Storage
+    """
+    blobs = firebase_bucket.list_blobs()
+    blob_dict = {blob.name: blob.public_url for blob in blobs}
+    return blob_dict
+
+
+def download_file_from_storage(file_name, destination_path):
+    """
+    Download a file from Firebase Storage
+    param:
+        file_name: str - The name of the file to be downloaded
+        destination_path: str - The path to save the downloaded file
+    return:
+        bool - True if the file is downloaded successfully, False if the file is not found
+    """
+    try:
+        blob = firebase_bucket.blob(file_name)
+        blob.download_to_filename(destination_path)
+        print("da tai xun thanh cong")
+        return True
+    except Exception as e:
+        print("Error:", e)
+        return False

src/apis/routes/comment_route.py

@@ -0,0 +1,98 @@
+from fastapi import APIRouter, status, Depends, BackgroundTasks
+from typing import Annotated, Optional
+from fastapi.responses import JSONResponse
+from pydantic import Field
+from src.apis.models.user_models import User
+from src.apis.models.BaseModel import BaseDocument
+from src.apis.middlewares.auth_middleware import get_current_user
+from src.apis.controllers.comment_controller import (
+    create_a_comment_controller,
+    get_comments_of_a_post_controller,
+    update_a_comment_controller,
+    delete_a_comment_controller,
+)
+from src.utils.redis import set_key_redis, get_key_redis
+from src.utils.logger import logger
+
+router = APIRouter(prefix="/comment", tags=["Comment"])
+
+user_dependency = Annotated[User, Depends(get_current_user)]
+
+
+class BodyComment(BaseDocument):
+    content: str = Field("", description="Comment's content")
+    post_id: str = Field("", description="Post's id")
+
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "content": "John Doe",
+                "post_id": "1234567890",
+            }
+        }
+
+
+@router.post("/create", status_code=status.HTTP_201_CREATED)
+async def create_comment(body: BodyComment, user: user_dependency):
+    if user is None:
+        return JSONResponse(content={"message": "User not found"}, status_code=404)
+    user_id = user["id"]
+    result = await create_a_comment_controller(
+        body.content,
+        user_id,
+        body.post_id,
+    )
+    if result["status"] == "error":
+        return JSONResponse(content=result, status_code=404)
+    else:
+        return JSONResponse(content=result, status_code=201)
+
+
+@router.get("/get/{post_id}", status_code=status.HTTP_200_OK)
+async def get_comments_of_a_post(post_id: str):
+    result = await get_comments_of_a_post_controller(post_id)
+    if result["status"] == "error":
+        return JSONResponse(content=result, status_code=404)
+    else:
+        return JSONResponse(content=result, status_code=200)
+
+
+class BodyUpdateComment(BaseDocument):
+    comment_id: str = Field("", description="Comment's id")
+    content: Optional[str] = Field("", description="Comment's content")
+
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "comment_id": "1234567890",
+                "content": "John Doe",
+            }
+        }
+
+
+@router.patch("/update/", status_code=status.HTTP_200_OK)
+async def update_comment(body: BodyUpdateComment, user: user_dependency):
+    if user is None:
+        return JSONResponse(content={"message": "User not found"}, status_code=404)
+    result = await update_a_comment_controller(
+        user["id"],
+        body.comment_id,
+        body.content,
+    )
+    logger.info(f"RESULT: {result}")
+    if result["status"] == "error":
+        return JSONResponse(content=result, status_code=404)
+    else:
+        return JSONResponse(content=result, status_code=200)
+
+
+@router.delete("/delete/{comment_id}", status_code=status.HTTP_200_OK)
+async def delete_comment(comment_id: str, user: user_dependency):
+    if user is None:
+        return JSONResponse(content={"message": "User not found"}, status_code=404)
+    result = await delete_a_comment_controller(user["id"], comment_id)
+    logger.info(f"RESULT: {result}")
+    if result["status"] == "error":
+        return JSONResponse(content=result, status_code=404)
+    else:
+        return JSONResponse(content=result, status_code=200)

src/apis/routes/post_router.py

@@ -1,4 +1,4 @@
-from fastapi import APIRouter, status, Depends
+from fastapi import APIRouter, status, Depends, BackgroundTasks
 from typing import Annotated, Optional
 from fastapi.responses import JSONResponse
 from pydantic import Field
@@ -12,6 +12,7 @@ from src.apis.controllers.post_controller import (
     update_a_post_controller,
     delete_a_post_controller,
 )
+from src.utils.redis import set_key_redis, get_key_redis
 from src.utils.logger import logger
 
 router = APIRouter(prefix="/post", tags=["Post"])
@@ -60,8 +61,13 @@ async def get_post(post_id: str):
 
 
 @router.get("/list", status_code=status.HTTP_200_OK)
-async def list_all_posts():
-    result = await list_all_posts_controller()
+async def list_all_posts(background_tasks: BackgroundTasks):
+    # result = await get_key_redis("all_posts")
+    result = None
+    result = eval(result) if result else None
+    if not result:
+        result = await list_all_posts_controller()
+        # background_tasks.add_task(set_key_redis, "all_posts", str(result),20)
     if result["status"] == "error":
         return JSONResponse(content=result, status_code=404)
     else:
@@ -69,8 +75,9 @@ async def list_all_posts():
 
 
 class BodyUpdatePost(BaseDocument):
-    content: Optional[str] = Field("", description="Post's content")
-    destination_id: Optional[str] = Field("", description="Destination's id")
+    content: str = Field(..., description="Post's content", min_length=1)
+    post_id: str = Field(..., description="Post's id", min_length=1)
+    destination_id: str = Field(..., description="Destination's id", min_length=1)
 
     class Config:
         json_schema_extra = {
@@ -81,13 +88,13 @@ class BodyUpdatePost(BaseDocument):
         }
 
 
-@router.patch("/update/{post_id}", status_code=status.HTTP_200_OK)
-async def update_post(post_id: str, body: BodyUpdatePost, user: user_dependency):
+@router.patch("/update/", status_code=status.HTTP_200_OK)
+async def update_post(body: BodyUpdatePost, user: user_dependency):
     if user is None:
         return JSONResponse(content={"message": "User not found"}, status_code=404)
     result = await update_a_post_controller(
         user["id"],
-        post_id,
+        body.post_id,
         body.content,
         body.destination_id,
     )

src/langgraph/multi_agent/chat/chat_flow.py

@@ -1,4 +1,4 @@
-from langgraph.graph import END, StateGraph, START
+from langgraph.graph import END, START, StateGraph
 from langchain_community.tools.tavily_search import TavilySearchResults
 from langgraph.prebuilt import tools_condition
 from src.langgraph.langchain.llm import llm
@@ -19,7 +19,6 @@ from src.langgraph.utils_function.function_graph import (
 from src.langgraph.tools.destination_tools import destination_recommendation
 from src.utils.logger import logger
 
-# Primary Assistant
 primary_assistant_tools = [
     TavilySearchResults(max_results=2),
     destination_recommendation,
@@ -96,7 +95,6 @@ class ChatBot:
         raise ValueError("Invalid route")
 
     def node(self):
-
         self.builder.add_node("leave_skill", leave_skill_fn)
         self.builder.add_node("fetch_history", get_history)
         self.builder.add_node("classify_intent", classify_user_intent_fn)

src/langgraph/multi_agent/planner/react_agent.py

@@ -20,100 +20,6 @@ def create_react_agent(
     *,
     stop_sequence: Union[bool, List[str]] = True,
 ) -> Runnable:
-    """Create an agent that uses ReAct prompting.
-
-    Based on paper "ReAct: Synergizing Reasoning and Acting in Language Models"
-    (https://arxiv.org/abs/2210.03629)
-
-    .. warning::
-       This implementation is based on the foundational ReAct paper but is older and not well-suited for production applications.
-       For a more robust and feature-rich implementation, we recommend using the `create_react_agent` function from the LangGraph library.
-       See the [reference doc](https://langchain-ai.github.io/langgraph/reference/prebuilt/#langgraph.prebuilt.chat_agent_executor.create_react_agent)
-       for more information.
-
-    Args:
-        llm: LLM to use as the agent.
-        tools: Tools this agent has access to.
-        prompt: The prompt to use. See Prompt section below for more.
-        output_parser: AgentOutputParser for parse the LLM output.
-        tools_renderer: This controls how the tools are converted into a string and
-            then passed into the LLM. Default is `render_text_description`.
-        stop_sequence: bool or list of str.
-            If True, adds a stop token of "Observation:" to avoid hallucinates.
-            If False, does not add a stop token.
-            If a list of str, uses the provided list as the stop tokens.
-
-            Default is True. You may to set this to False if the LLM you are using
-            does not support stop sequences.
-
-    Returns:
-        A Runnable sequence representing an agent. It takes as input all the same input
-        variables as the prompt passed in does. It returns as output either an
-        AgentAction or AgentFinish.
-
-    Examples:
-
-        .. code-block:: python
-
-            from langchain import hub
-            from langchain_community.llms import OpenAI
-            from langchain.agents import AgentExecutor, create_react_agent
-
-            prompt = hub.pull("hwchase17/react")
-            model = OpenAI()
-            tools = ...
-
-            agent = create_react_agent(model, tools, prompt)
-            agent_executor = AgentExecutor(agent=agent, tools=tools)
-
-            agent_executor.invoke({"input": "hi"})
-
-            # Use with chat history
-            from langchain_core.messages import AIMessage, HumanMessage
-            agent_executor.invoke(
-                {
-                    "input": "what's my name?",
-                    # Notice that chat_history is a string
-                    # since this prompt is aimed at LLMs, not chat models
-                    "chat_history": "Human: My name is Bob\\nAI: Hello Bob!",
-                }
-            )
-
-    Prompt:
-
-        The prompt must have input keys:
-            * `tools`: contains descriptions and arguments for each tool.
-            * `tool_names`: contains all tool names.
-            * `agent_scratchpad`: contains previous agent actions and tool outputs as a string.
-
-        Here's an example:
-
-        .. code-block:: python
-
-            from langchain_core.prompts import PromptTemplate
-
-            template = '''Answer the following questions as best you can. You have access to the following tools:
-
-            {tools}
-
-            Use the following format:
-
-            Question: the input question you must answer
-            Thought: you should always think about what to do
-            Action: the action to take, should be one of [{tool_names}]
-            Action Input: the input to the action
-            Observation: the result of the action
-            ... (this Thought/Action/Action Input/Observation can repeat N times)
-            Thought: I now know the final answer
-            Final Answer: the final answer to the original input question
-
-            Begin!
-
-            Question: {input}
-            Thought:{agent_scratchpad}'''
-
-            prompt = PromptTemplate.from_template(template)
-    """  # noqa: E501
     missing_vars = {"tools", "tool_names", "agent_scratchpad"}.difference(
         prompt.input_variables + list(prompt.partial_variables)
     )
@@ -125,7 +31,11 @@ def create_react_agent(
         tool_names=", ".join([t.name for t in tools]),
     )
     if stop_sequence:
-        stop = ["\nObservation","\nFinal", "Answer:"] if stop_sequence is True else stop_sequence
+        stop = (
+            ["\nObservation", "\nFinal", "Answer:"]
+            if stop_sequence is True
+            else stop_sequence
+        )
         llm_with_stop = llm.bind(stop=stop)
     else:
         llm_with_stop = llm

src/utils/mongo.py

@@ -93,7 +93,7 @@ class MongoCRUD:
     async def update(self, query: Dict, data: Dict) -> int:
         """Update documents in the collection based on a query asynchronously."""
         await self._ensure_ttl_index()
-        data["updated_at"] = datetime.now(timezone.utc)
+        data["updated_at"] = get_date_time().replace(tzinfo=None)
         if self.ttl_seconds is not None:
             data["expire_at"] = data["updated_at"] + timedelta(seconds=self.ttl_seconds)
         update_data = self.model(**data).model_dump(exclude_unset=True)

src/utils/redis.py

@@ -11,6 +11,7 @@ async def set_key_redis(key, value, time=300):
 
 
 async def get_key_redis(key):
+    
     return await redis_client.get(key)