Upload 157 files

src/apis/controllers/location_controller.py

@@ -1,8 +1,13 @@
 from src.utils.logger import logger
-from src.utils.helper import format_geoapify_response, format_weather_data
+from src.utils.helper import (
+    format_geoapify_response,
+    format_weather_data,
+    get_google_map_url,
+)
 from fastapi.responses import JSONResponse
 import requests
 import os
+import json
 
 
 def get_location_details(lat, long):
@@ -35,6 +40,7 @@ def get_nearby_places(lat, long, radius, kinds):
         "apikey": api_key,
     }
     response = requests.get(url, params=params, headers={"accept": "application/json"})
+    # print(response.json())
     if response.status_code == 200:
         logger.info("Places fetched successfully")
         return JSONResponse(
@@ -75,3 +81,43 @@ def get_weather(lat, long):
         return JSONResponse(
             content={"error": "Error fetching weather"}, status_code=500
         )
+
+
+def get_lat_long_location(location_name):
+    """
+    Retrieve the latitude and longitude for a given location name using Geoapify's Geocoding API.
+
+    Parameters:
+    - location_name (str): The name of the location to geocode.
+    - api_key (str): Your Geoapify API key.
+
+    Returns:
+    - tuple: (latitude, longitude) if the location is found; otherwise, (None, None).
+    """
+    api_key = os.getenv("GEOAPIFY_API_KEY", None)
+    base_url = "https://api.geoapify.com/v1/geocode/search"
+    params = {"text": location_name, "apiKey": api_key}
+    response = requests.get(base_url, params=params)
+    data = response.json()
+    if response.status_code == 200 and data.get("features"):
+        # Extract latitude and longitude from the response
+        latitude = data["features"][0]["properties"]["lat"]
+        longitude = data["features"][0]["properties"]["lon"]
+        return latitude, longitude
+    else:
+        print(f"Location '{location_name}' not found.")
+        return None, None
+
+
+def get_geometry_nearby_places(lat, lon, radius, kinds):
+    res = get_nearby_places(lat=lat, long=lon, radius=radius, kinds=kinds)
+    data = json.loads(res.body)
+    recommend_places = data.get("places", [])
+    recommend_places = [
+        {
+            "name": place["properties"]["name"],
+            "link_google_map": get_google_map_url(place["geometry"]["coordinates"]),
+        }
+        for place in recommend_places
+    ]
+    return recommend_places

src/apis/controllers/reaction_controller.py

@@ -3,7 +3,6 @@ from datetime import datetime
 from src.utils.mongo import ReactionCRUD, PostCRUD
 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

src/apis/routes/reaction_route.py

@@ -1,5 +1,5 @@
 from fastapi import APIRouter, status, Depends
-from typing import Annotated
+from typing import Annotated, Optional
 from fastapi.responses import JSONResponse
 from pydantic import Field
 from src.apis.models.user_models import User
@@ -11,8 +11,10 @@ from src.apis.controllers.reaction_controller import (
     update_a_reaction_controller,
     delete_a_reaction_controller,
 )
+from src.utils.mongo import ReactionCRUD, PostCRUD
 from src.utils.redis import set_key_redis, get_key_redis
 from src.utils.logger import logger
+from bson import ObjectId
 
 router = APIRouter(prefix="/reaction", tags=["Reaction"])
 
@@ -21,7 +23,7 @@ user_dependency = Annotated[User, Depends(get_current_user)]
 
 class BodyLike(BaseDocument):
     post_id: str = Field("", description="Post's id", min_length=1)
-    type: int = Field(0, description="Type of like", gt=0, lt=5)
+    type: int = Field(0, description="Type of like", ge=0, lt=5)
 
     class Config:
         json_schema_extra = {
@@ -59,7 +61,7 @@ async def get_reactions_of_a_post(post_id: str):
 
 class BodyUpdateReaction(BaseDocument):
     reaction_id: str = Field("", description="Reaction's id")
-    type: str = Field("", description="Type of like", gt=0, lt=3)
+    type: str = Field("", description="Type of like", gt=0, lt=5)
 
     class Config:
         json_schema_extra = {
@@ -70,6 +72,53 @@ class BodyUpdateReaction(BaseDocument):
         }
 
 
+class BodyUpdateReactionInteract(BaseDocument):
+    reaction_id: Optional[str] = Field("", description="Reaction's id")
+    post_id: str = Field("", description="Post's id", min_length=1)
+    current_type: int = Field("", description="Current type of like", ge=0, lt=5)
+    type: int = Field(0, description="Type of like", ge=0, lt=5)
+    model_config = {
+        "json_schema_extra": {
+            "examples": [
+                {
+                    "reaction_id": "1234567890",
+                    "post_id": "1234567890",
+                    "current_type": 1,
+                    "type": 2,
+                },
+            ]
+        }
+    }
+
+
+@router.post("/interact/", status_code=status.HTTP_200_OK)
+async def interact_reaction(body: BodyUpdateReactionInteract, user: user_dependency):
+    if user is None:
+        return JSONResponse(content={"message": "User not found"}, status_code=404)
+    if not body.reaction_id:
+        response = await ReactionCRUD.create(
+            {"user_id": user["id"], "post_id": body.post_id, "type": body.type}
+        )
+        await PostCRUD.update(
+            {"_id": ObjectId(body.post_id)}, {"$inc": {"reaction_count": 1}}
+        )
+
+        return JSONResponse(content={"reaction_id": str(response)}, status_code=201)
+    elif body.current_type == body.type:
+        await ReactionCRUD.delete_one({"_id": ObjectId(body.reaction_id)})
+        await PostCRUD.update(
+            {"_id": ObjectId(body.post_id)}, {"$inc": {"reaction_count": -1}}
+        )
+        return JSONResponse(content={"message": "Reaction deleted"}, status_code=200)
+    elif body.current_type != body.type:
+        await ReactionCRUD.update(
+            {"_id": ObjectId(body.reaction_id)}, {"$set": {"type": body.type}}
+        )
+        return JSONResponse(content={"message": "Reaction updated"}, status_code=200)
+
+    return JSONResponse(content={"message": "Reaction not found"}, status_code=404)
+
+
 @router.patch("/update/", status_code=status.HTTP_200_OK)
 async def update_reaction(body: BodyUpdateReaction, user: user_dependency):
     if user is None:

src/langgraph/models/model_validator.py

@@ -1,4 +1,5 @@
-# from pydantic import BaseModel, Field, EmailStr
+from pydantic import BaseModel, Field, EmailStr
+
 # from typing import Optional
 # from datetime import datetime, timezone
 
@@ -46,3 +47,22 @@
 #                 "website": "https://www.bluelagoonresort.com",
 #             }
 #         }
+
+
+class NearlyDestinationRecommendation(BaseModel):
+    query: str = Field(
+        ...,
+        title="Query related to wanting to go somewhere",
+        description="Auto extracted from user's message. Using Vietnamese language for better results.",
+    )
+    places: str = Field(..., title="Places", description="place mention in query")
+    kinds: str = Field(
+        ...,
+        title="Kinds",
+        description="""
+        Kinds of places you want to find choose one of options: 
+        ["architecture", "historic", "cultural", "natural", "sport", "religion", "accomodations", "foods", "shops", "other"]""",
+    )
+
+    class Config:
+        schema_extra = {"example": {"query": "Địa điểm gần Hà Nội" "places" "Hà Nội"}}

src/langgraph/multi_agent/chat/chat_flow.py

@@ -16,12 +16,12 @@ from src.langgraph.utils_function.function_graph import (
     get_history,
     save_history,
 )
-from src.langgraph.tools.destination_tools import destination_recommendation
+from src.langgraph.tools.destination_tools import destination_recommendation, nearly_destination_recommendation
 from src.utils.logger import logger
 
 primary_assistant_tools = [
     TavilySearchResults(max_results=2),
-    destination_recommendation,
+    destination_recommendation,nearly_destination_recommendation
 ]
 
 assistant_runnable = primary_assistant_prompt | llm.bind_tools(
@@ -58,6 +58,7 @@ class ChatBot:
         self.primary_assistant_tools = [
             TavilySearchResults(max_results=2),
             destination_recommendation,
+            nearly_destination_recommendation
         ]
         self.assistant_runnable = assistant_runnable
 

src/langgraph/tools/destination_tools.py

@@ -4,6 +4,15 @@ from src.apis.controllers.destination_controller import (
 )
 from langchain_core.runnables.config import RunnableConfig
 from src.utils.logger import logger
+from src.apis.controllers.location_controller import (
+    get_nearby_places,
+    get_lat_long_location,
+    get_geometry_nearby_places,
+)
+from src.langgraph.models.model_validator import NearlyDestinationRecommendation
+from src.utils.helper import get_google_map_url
+
+import json
 
 
 @tool
@@ -16,3 +25,15 @@ async def destination_recommendation(query: str, config: RunnableConfig):
     logger.info(f"Destination recommendation query: {query}")
     output = await destination_suggestion_controller(query, 3)
     return output
+
+
+@tool(args_schema=NearlyDestinationRecommendation)
+async def nearly_destination_recommendation(
+    query: str, places, kinds, config: RunnableConfig
+):
+    """Gọi tool này khi query đề cập đến việc tìm địa điểm gần một khu vực/ địa điểm nào đó"""
+    radius = 1000
+    lat, lon = get_lat_long_location(places)
+    recommend_places = get_geometry_nearby_places(lat, lon, radius, kinds)
+    logger.info(f"Nearly Destination recommendation: {places} >> {kinds} >> {recommend_places}")
+    return recommend_places

src/utils/helper.py

@@ -301,3 +301,6 @@ def serialize_datetime(obj):
     if isinstance(obj, ObjectId):
         return str(obj)
     return obj
+
+def get_google_map_url(geometry:list):
+    return f"https://www.google.com/maps/search/{geometry[1]},{geometry[0]}"

src/utils/mongo.py

@@ -93,16 +93,22 @@ 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()
-        
+
         # Check if update operators like $inc, $set, etc., are used
-        if any(key.startswith('$') for key in data.keys()):
+        if any(key.startswith("$") for key in data.keys()):
             update_data = data
         else:
             # If no MongoDB operators are used, treat it as a normal update
             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 = {"$set": self._order_fields(self.model(**data).model_dump(exclude_unset=True))}
+                data["expire_at"] = data["updated_at"] + timedelta(
+                    seconds=self.ttl_seconds
+                )
+            update_data = {
+                "$set": self._order_fields(
+                    self.model(**data).model_dump(exclude_unset=True)
+                )
+            }
 
         result = await self.collection.update_many(query, update_data)
         return result.modified_count
@@ -112,6 +118,11 @@ class MongoCRUD:
         result = await self.collection.delete_many(query)
         return result.deleted_count
 
+    async def delete_one(self, query: Dict) -> int:
+        """Delete a single document from the collection based on a query asynchronously."""
+        result = await self.collection.delete_one(query)
+        return result.deleted_count
+
     async def find_by_id(self, id: str) -> Optional[Dict]:
         """Find a document by its ID asynchronously."""
         return await self.read_one({"_id": ObjectId(id)})

src/utils/redis.py

@@ -1,19 +1,19 @@
 from src.langgraph.config.constant import RedisCfg
 import redis.asyncio as redis
 
-redis_client = redis.from_url(
-    RedisCfg.REDIS_URL, encoding="utf-8", decode_responses=True
-)
+# redis_client = redis.from_url(
+#     RedisCfg.REDIS_URL, encoding="utf-8", decode_responses=True
+# )
 
 
 async def set_key_redis(key, value, time=300):
-    await redis_client.set(key, value, time)
+    return None #redis_client.set(key, value, time)
 
 
 async def get_key_redis(key):
     
-    return await redis_client.get(key)
+    return None #await redis_client.get(key)
 
 
 async def delete_key_redis(key):
-    await redis_client.delete(key)
+    return None#redis_client.delete(key)