Upload 157 files

src/src/apis/controllers/comment_controller.py

@@ -1,12 +1,11 @@
 from typing import Dict
 from datetime import datetime
-from src.utils.mongo import CommentCRUD
+from src.utils.mongo import CommentCRUD, UserCRUD, 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
 from asyncio import gather
 
 
@@ -25,8 +24,11 @@ async def create_a_comment_controller(content: str, user_id: str, post_id: str)
             "user_id": user_id,
             "post_id": post_id,
         }
-        await CommentCRUD.create(comment)
-        return {"status": "success", "message": "Comment created successfully"}
+        output = await CommentCRUD.create(comment)
+        await PostCRUD.update(
+            {"_id": ObjectId(post_id)}, {"$inc": {"comment_count": 1}}
+        )
+        return {"status": "success", "message": output}
     except Exception as e:
         return {"status": "error", "message": str(e)}
 
@@ -107,6 +109,9 @@ async def delete_a_comment_controller(user_id: str, comment_id: str) -> Dict:
             }
 
         await CommentCRUD.delete({"_id": ObjectId(comment_id)})
+        await PostCRUD.update(
+            {"_id": ObjectId(exist_data["post_id"])}, {"$inc": {"comment_count": -1}}
+        )
         return {"status": "success", "message": "Comment deleted successfully"}
     except Exception as e:
         logger.error(f"Error deleting post: {str(e)}")

src/src/apis/controllers/destination_controller.py

@@ -2,26 +2,29 @@ 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]]:
+import json
+from src.langgraph.langchain.prompt import (
+    routing_recommender_chain,
+    characteristic_extractor_chain,
+    RoutingRecommender,
+    CharacteristicExtractor,
+)
+from src.apis.controllers.location_controller import (
+    get_lat_long_location,
+    get_places,
+)
+from src.langgraph.config.constant import available_categories
+
+
+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}"
+                f"https://abao77-destination-suggestion.hf.space/model/get_destinations_list_by_question/{question}/{top_k}"
             ) as response:
                 if response.status == 200:
                     data = await response.json()
@@ -30,8 +33,48 @@ async def destination_suggestion_controller(question: str, top_k: int = 5) -> Li
                 else:
                     raise HTTPException(
                         status_code=response.status,
-                        detail=f"Destinations request failed with status {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)}")
+            raise HTTPException(status_code=500, detail=f"Request failed: {str(e)}")
+
+
+async def destination_recommendation_func(query, top_k=5, tool_chat=False):
+    routing: RoutingRecommender = routing_recommender_chain.invoke({"query": query})
+    print("label", routing.label)
+    if routing.label == "characteristic":
+        output = await destination_suggestion_controller(query, top_k)
+        if tool_chat:
+            return output
+        output = [
+            {
+                "name": i,
+                "map_url": "https://www.google.com/maps/search/109.23333,13.76667",
+            }
+            for i in output
+        ]
+        return output
+    characteristic_extract_response: CharacteristicExtractor = (
+        await characteristic_extractor_chain.ainvoke({"query": query})
+    )
+    lat, lon = get_lat_long_location(characteristic_extract_response.main_place)
+    response = get_places(
+        lat,
+        lon,
+        5000,
+        available_categories.get(characteristic_extract_response.kind, None),
+        top_k,
+    )
+    output = json.loads(response.body)
+    if tool_chat:
+        output = [
+            {
+                "name": i["name"],
+                "address": i["address"],
+                "distance_km": i["distance_km"],
+            }
+            for i in output
+        ]
+
+    return output

src/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):
@@ -53,7 +58,6 @@ def get_places(lat, long, radius, categories, limit=20):
     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)
@@ -75,3 +79,37 @@ 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 = [place["properties"]["name"] for place in recommend_places]
+    return recommend_places

src/src/apis/controllers/post_controller.py

@@ -1,7 +1,7 @@
 from typing import Dict
 from src.utils.mongo import PostCRUD
 from src.utils.logger import logger
-from src.utils.mongo import UserCRUD
+from src.utils.mongo import UserCRUD, ReactionCRUD
 from asyncio import gather
 from src.utils.helper import call_external_api, serialize_datetime
 
@@ -16,12 +16,12 @@ async def create_a_post_controller(
             url="https://abao77-image-retrieval.hf.space/upload_image",
             json={"base64_image": images},
         )
-        print("image url", image_url)
         post = {
             "content": content,
             "user_id": user_id,
             "destination_id": destination_id,
-            "comment_ids": [],
+            "comment_count": 0,
+            "reaction_count": 0,
             "picture": image_url["public_url"] if image_url.get("public_url") else None,
             "like": [],
         }
@@ -42,8 +42,8 @@ async def get_a_post_controller(post_id: str) -> Dict:
             "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", []),
+            "comment_count": post.get("comment_count", 0),
+            "reaction_count": post.get("reaction_count", 0),
             "created_at": serialize_datetime(post.get("created_at")),
             "updated_at": serialize_datetime(post.get("updated_at")),
         }
@@ -54,27 +54,53 @@ async def get_a_post_controller(post_id: str) -> Dict:
         return {"status": "error", "message": str(e)}
 
 
-async def list_all_posts_controller():
+async def list_all_posts_controller(user_id: str):
     try:
         posts = await PostCRUD.find_all()
         user_ids = [post.get("user_id") for post in posts]
         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
         }
+        all_post_ids = {serialize_datetime(post.get("_id")) for post in posts}
+
+        formatted_user_reactions = []
+        if user_id:
+            reactions = await gather(
+                *[
+                    ReactionCRUD.read_one({"user_id": user_id, "post_id": post_id})
+                    for post_id in all_post_ids
+                ]
+            )
+            formatted_user_reactions = [
+                {
+                    "id": serialize_datetime(reaction.get("_id", None)),
+                    "post_id": reaction.get("post_id", None),
+                    "user_id": reaction.get("user_id", None),
+                    "reaction_type": reaction.get("type", None),
+                }
+                for reaction in reactions
+                if reaction is not None  # Ensure only non-None reactions are processed
+            ]
 
         serialized_posts = []
-        for post in posts:
+        for index, post in enumerate(posts):
             user_id = post.get("user_id")
             user_info = user_info_map.get(user_id)
             serialized_post = {
                 "id": serialize_datetime(post.get("_id")),
                 "content": post.get("content"),
                 "destination_id": post.get("destination_id"),
-                "comment_ids": post.get("comment_ids", []),
-                "like": post.get("like", []),
+                "comment_count": post.get("comment_count", []),
+                "reaction_count": post.get("reaction_count", []),
+                "current_user_reaction": (
+                    formatted_user_reactions[index]
+                    if formatted_user_reactions
+                    else None
+                ),
                 "picture": post.get("picture", []),
                 "created_at": serialize_datetime(post.get("created_at")),
                 "updated_at": serialize_datetime(post.get("updated_at")),

src/src/apis/controllers/reaction_controller.py

@@ -1,9 +1,8 @@
 from typing import Dict
 from datetime import datetime
-from src.utils.mongo import ReactionCRUD
+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
@@ -26,6 +25,9 @@ async def create_a_reaction_controller(user_id: str, post_id: str, type: int) ->
             "type": type,
         }
         await ReactionCRUD.create(reaction)
+        await PostCRUD.update(
+            {"_id": ObjectId(post_id)}, {"$inc": {"reaction_count": 1}}
+        )
         return {"status": "success", "message": "Reaction created successfully"}
     except Exception as e:
         return {"status": "error", "message": str(e)}
@@ -70,7 +72,9 @@ async def list_all_reaction_controller(post_id: str) -> Dict:
         return {"status": "error", "message": str(e)}
 
 
-async def update_a_reaction_controller(user_id: str, reaction_id: str, type: int) -> Dict:
+async def update_a_reaction_controller(
+    user_id: str, reaction_id: str, type: int
+) -> Dict:
     try:
         exist_data = await ReactionCRUD.find_by_id(reaction_id)
         if exist_data["user_id"] != user_id:
@@ -103,6 +107,9 @@ async def delete_a_reaction_controller(user_id: str, reaction_id: str) -> Dict:
         if exist_data is None:
             return {"status": "error", "message": "Reaction not found"}
         await ReactionCRUD.delete({"_id": ObjectId(reaction_id)})
+        await PostCRUD.update(
+            {"_id": ObjectId(exist_data["post_id"])}, {"$inc": {"reaction_count": -1}}
+        )
         return {"status": "success", "message": "Reaction deleted successfully"}
     except Exception as e:
         logger.error(f"Error deleting reaction: {str(e)}")

src/src/apis/create_app.py

@@ -26,7 +26,7 @@ api_router.include_router(router_reaction)
 def create_app():
     app = FastAPI(
         docs_url="/",
-        title="eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6IjY3M2IwZDMzNTQ5OTg5Zjc1NmZhMzk3MCJ9.a3A9B1ZpzkzIPvhLqFpasK4sk2ocqmc1M80rtyAkbmM",
+        title="eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6IjY3ZTU1ZTczYTA0MzI1YmUzNjAzYjU2MCJ9.Vdz3DdbvNUdUERDXEOyvi14EuYATRw29eOVWNGTQIYo",
     )
 
     app.add_middleware(

src/src/apis/interfaces/api_interface.py

@@ -75,15 +75,16 @@ class Location(BaseModel):
 
 
 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)
+    id: Optional[str] = Field(..., title="Destination Id", min_length=0)
+    name: Optional[str] = Field(..., title="Destination Name", min_length=1)
+    description: Optional[str] = Field(..., title="Description", min_length=0)
+    image: Optional[str] = Field(..., title="Image", min_length=0)
 
 
 class Planning(BaseModel):
     duration: str = Field("7", title="Duration")
     start_date: str = Field("June 1-7", title="Start date")
+    end_date: str = Field("June 1-7", title="End date")
     location: str = Field("Quy Nhon, Vietnam", title="Location")
     interests: str = Field("natural, cultural", title="Interests")
     nation: str = Field("Vietnamese", title="Nation")
@@ -107,3 +108,18 @@ class Planning(BaseModel):
                 "limit_interation": 3,
             }
         }
+
+
+{
+    "duration": "6",
+    "start_date": "2025-03-18",
+    "end_date": "2025-03-24",
+    "include_destination": [
+        {"id": "", "name": "KHU DÃ NGOẠI TRUNG LƯƠNG", "description": "", "image": ""},
+        {"id": "", "name": "NÚI VŨNG CHUA", "description": "", "image": ""},
+    ],
+    "interests": "natural, cultural",
+    "location": "Quy Nhon, Vietnam",
+    "nation": "Vietnamese",
+    "limit_interation": 5,
+}

src/src/apis/models/post_models.py

@@ -18,10 +18,11 @@ class Comment(BaseDocument):
         }
     }
 
+
 class Reaction(BaseDocument):
     user_id: str = Field("", description="User's id")
     post_id: str = Field("", description="Post's id")
-    type: int = Field(0, description="Type of like", gt=0, lt=5)
+    type: int = Field(0, description="Type of like", ge=0, lt=5)
 
     model_config = {
         "json_schema_extra": {
@@ -38,8 +39,8 @@ 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")
+    comment_count: int = Field(0, description="Comment's id")
+    reaction_count: int = Field(0, description="User's id who like this post")
     picture: Optional[list[str]] = Field([], description="Picture's url")
     model_config = {
         "json_schema_extra": {
@@ -47,8 +48,8 @@ class Post(BaseDocument):
                 "content": "John Doe",
                 "user_id": "1234567890",
                 "destination_id": "1234567890",
-                "comment_ids": ["1234567890"],
-                "like": ["1234567890"],
+                "comment_count": 1,
+                "reaction_count": 1,
                 "picture": ["https://example.com/picture.jpg"],
             }
         }

src/src/apis/routes/post_router.py

@@ -67,13 +67,13 @@ async def get_post(post_id: str):
 
 
 @router.get("/list", status_code=status.HTTP_200_OK)
-async def list_all_posts(background_tasks: BackgroundTasks):
-    result = await get_key_redis("all_posts")
+async def list_all_posts(user_id: Optional[str] = None):
+    # result = await get_key_redis("all_posts")
     result = None
-    result = eval(result) if result else 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)
+        result = await list_all_posts_controller(user_id)
+        # background_tasks.add_task(set_key_redis, "all_posts", str(result), 20)
     if result["status"] == "error":
         return JSONResponse(content=result, status_code=404)
     else:

src/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=3)
+    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/src/apis/routes/travel_dest_route.py

@@ -8,9 +8,11 @@ from src.apis.middlewares.auth_middleware import get_current_user
 from src.utils.logger import logger
 from src.apis.controllers.destination_controller import (
     destination_suggestion_controller,
+    destination_recommendation_func,
 )
 from fastapi.responses import JSONResponse
 from src.utils.mongo import DestinationCRUD
+
 router = APIRouter(prefix="/dest", tags=["Destination"])
 
 user_dependency = Annotated[User, Depends(get_current_user)]
@@ -53,7 +55,7 @@ def get_tourist(page: int = Query(default=1, ge=1)):
 async def get_tourist_names():
     try:
         destination_data = await DestinationCRUD.find_all()
-        
+
         # Drop the fields created_at, updated_at, expire_at from each item
 
         serialized_data = []
@@ -74,4 +76,4 @@ 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_suggestion_controller(question, top_k))
+    return JSONResponse(await destination_recommendation_func(question))

src/src/langgraph/config/constant.py

@@ -21,3 +21,17 @@ class MongoCfg:
     MAX_HISTORY_SIZE: int = 15
 class RedisCfg:
     REDIS_URL: str = os.getenv("REDIS_URL")
+
+available_categories = {
+    "food_and_beverage": "catering",
+    "accommodation": "accommodation",
+    "entertainment": "entertainment",
+    "leisure": "leisure",
+    "natural": "natural",
+    "national_park": "national_park",
+    "tourism": "tourism",
+    "camping": "camping",
+    "religion": "religion",
+    "sport": "sport",
+    "commercial": "commercial",
+}

src/src/langgraph/langchain/llm.py

@@ -6,7 +6,7 @@ from langchain_google_genai import ChatGoogleGenerativeAI
 #     max_retries=2,
 # )
 llm = ChatGoogleGenerativeAI(
-    model="gemini-2.0-flash-exp",
+    model="gemini-2.0-flash",
     temperature=0.1,
     max_retries=2,
 )

src/src/langgraph/langchain/prompt.py

@@ -1,4 +1,4 @@
-from langchain.prompts import ChatPromptTemplate
+from langchain.prompts import ChatPromptTemplate, PromptTemplate
 from datetime import datetime
 from pydantic import BaseModel, Field
 from langchain_core.messages import HumanMessage
@@ -7,6 +7,8 @@ import pytz
 from src.langgraph.state import State
 from src.utils.logger import logger
 from langchain_core.prompts import PromptTemplate
+from .llm import llm, llm_flash
+from src.langgraph.config.constant import available_categories
 
 vietnam_timezone = pytz.timezone("Asia/Ho_Chi_Minh")
 vietnam_time = datetime.now(vietnam_timezone).strftime("%Y-%m-%d %H:%M:%S")
@@ -95,7 +97,7 @@ scheduling_prompt = ChatPromptTemplate.from_messages(
             - Not required user typing in the format of tool call. You must naturally respond to the user's messages.
             - You must call "CompleteOrRoute" than say you can't handle the user's request.
             - Answer in {language} language
-            <<Current time: {current_time}>>
+            <<Current time: {current_time}>> (Focus on current_time in the present moment, rather than the past conversation)
             """,
         ),
         ("placeholder", "{history}"),
@@ -138,6 +140,53 @@ book_hotel_prompt = ChatPromptTemplate.from_messages(
     ]
 ).partial(current_time=vietnam_time)
 
+routing_recommender_prompt = PromptTemplate.from_template(
+    """You are a tour guide.
+### Instruction:
+You are given a query sentence
+Classify the query as 'characteristic' or 'geographic' based on its content.
+
+- 'Characteristic' if it asks about a place's features (e.g., camping, relaxing, scenic).
+- 'Geographic' if it involves location specifics (e.g., near a city, in a province, on a road).
+
+###
+Query sentence: {query}
+"""
+)
+characteristic_extractor_prompt = PromptTemplate.from_template(
+    """You are a tour guide.
+### Instruction:
+Read the sentence carefully
+Given a query about a destination, extract two things:
+1. **Kind**: Choose one from {available_categories}.
+2. **Main Place**: Identify the main place mentioned in the query. Include 'Quy Nhon' or 'Binh Dinh' term in the main place response
+
+Query sentence: {query}
+."""
+).partial(available_categories=list(available_categories.keys()))
+
+
+class RoutingRecommender(BaseModel):
+    label: str = Field(..., description="is 'characteristic' or 'geographic'")
+
+
+class CharacteristicExtractor(BaseModel):
+    kind: str = Field(
+        ...,
+        description=f"Choose one from {list(available_categories.keys())}",
+    )
+    main_place: str = Field(..., description="main place mentioned in the query")
+
+
+routing_recommender_chain = (
+    routing_recommender_prompt | llm_flash.with_structured_output(RoutingRecommender)
+)
+
+characteristic_extractor_chain = (
+    characteristic_extractor_prompt
+    | llm_flash.with_structured_output(CharacteristicExtractor)
+)
+
 
 class CompleteOrRoute(BaseModel):
     """Call this function to complete the current assistant's task and route the conversation back to the primary assistant."""

src/src/langgraph/models/model_validator.py

@@ -1,4 +1,6 @@
-# from pydantic import BaseModel, Field, EmailStr
+from pydantic import BaseModel, Field, EmailStr
+
+
 # from typing import Optional
 # from datetime import datetime, timezone
 
@@ -46,3 +48,24 @@
 #                 "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:
+        json_schema_extra = {
+            "example": {"query": "Địa điểm gần Hà Nội" "places" "Hà Nội"}
+        }

src/src/langgraph/tools/destination_tools.py

@@ -1,18 +1,34 @@
 from langchain_core.tools import tool
 from src.apis.controllers.destination_controller import (
     destination_suggestion_controller,
+    destination_recommendation_func,
 )
 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
+from src.langgraph.langchain.prompt import (
+    routing_recommender_chain,
+    characteristic_extractor_chain,
+    RoutingRecommender,
+    CharacteristicExtractor,
+)
+import json
 
 
 @tool
 async def destination_recommendation(query: str, config: RunnableConfig):
     """Call tool when user want to recommend a travel destination(tourist attractions, restaurants). Not require user typing anything.
     Args:
-    query (str): query related to wanting to go somewhere. Auto extracted from user's message. Using Vietnamese language for better results.
-    Output: A list of recommended destinations.
+    query (str): query related to wanting to go somewhere locations near a certain area/location or location's characteristics user want to go. Auto extracted from user's message.
+    Using Vietnamese language for better results
     """
     logger.info(f"Destination recommendation query: {query}")
-    output = await destination_suggestion_controller(query, 3)
-    return output
+    response = await destination_recommendation_func(query)
+    logger.info(f"Destination recommendation output: {response}")
+    return response

src/src/utils/helper.py

@@ -104,8 +104,8 @@ def format_geoapify_response(
         if include_latnlong:
             formatted_item["lat"] = place_lat
             formatted_item["lon"] = place_lon
-        formatted_item["Accommodation Name"] = feature["properties"]["address_line1"]
-        formatted_item["Address"] = feature["properties"]["formatted"]
+        formatted_item["name"] = feature["properties"]["address_line1"]
+        formatted_item["address"] = feature["properties"]["formatted"]
         formatted_item["distance_km"] = str(round(distance, 2)) + " km"
 
         if "contact" in feature["properties"]:
@@ -116,6 +116,7 @@ def format_geoapify_response(
 
         if "accommodation" in feature["properties"]:
             formatted_item["accommodation"] = feature["properties"]["accommodation"]
+        formatted_item["map_url"] = get_google_map_url(place_lat, place_lon)
 
         formatted_data.append(formatted_item)
 
@@ -301,3 +302,7 @@ def serialize_datetime(obj):
     if isinstance(obj, ObjectId):
         return str(obj)
     return obj
+
+
+def get_google_map_url(lat, long):
+    return f"https://www.google.com/maps/search/{lat},{long}"

src/src/utils/mongo.py

@@ -93,12 +93,24 @@ 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"] = 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)
-        ordered_update = self._order_fields(update_data)
-        result = await self.collection.update_many(query, {"$set": ordered_update})
+
+        # Check if update operators like $inc, $set, etc., are used
+        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)
+                )
+            }
+
+        result = await self.collection.update_many(query, update_data)
         return result.modified_count
 
     async def delete(self, query: Dict) -> int:
@@ -106,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/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)