Upload 164 files

src/apis/controllers/post_controller.py

@@ -7,6 +7,8 @@ from src.utils.helper import call_external_api, serialize_datetime
 from datetime import datetime
 from bson import ObjectId
 import math
+from src.utils.helper import deserialize_objectid
+from typing import List
 
 
 async def create_a_post_controller(
@@ -60,6 +62,148 @@ async def get_a_post_controller(post_id: str) -> Dict:
         return {"status": "error", "message": str(e)}
 
 
+async def list_all_posts_controller_priority(
+    user_id: str,
+    page: int = 1,
+    top_5_destinations: List[str] = [],
+    view_post_ids: List[str] = [],
+):
+    try:
+        PAGE_SIZE = 10
+        TOP_LIMIT = int(PAGE_SIZE * 0.7)
+        OTHER_LIMIT = PAGE_SIZE - TOP_LIMIT
+        skip_top = (page - 1) * TOP_LIMIT
+        skip_other = (page - 1) * OTHER_LIMIT
+
+        excluded_ids = [deserialize_objectid(pid) for pid in view_post_ids]
+
+        # Tạo filter cho 2 nhóm
+        top_filter = {
+            "destination_id": {"$in": top_5_destinations},
+            "_id": {"$nin": excluded_ids},
+        }
+        other_filter = {
+            "destination_id": {"$nin": top_5_destinations},
+            "_id": {"$nin": excluded_ids},
+        }
+
+        # Đếm tổng số bài viết mỗi nhóm để tính total_items/pages
+        total_top = await PostCRUD.count(top_filter)
+        total_other = await PostCRUD.count(other_filter)
+        total_items = total_top + total_other
+        total_pages = math.ceil(total_items / PAGE_SIZE)
+
+        # Lấy bài viết đã tính điểm
+        top_posts = await PostCRUD.find_many_with_score(
+            filter=top_filter,
+            top_destinations=top_5_destinations,
+            limit=TOP_LIMIT,
+            skip=skip_top,
+        )
+
+        other_posts = await PostCRUD.find_many_with_score(
+            filter=other_filter,
+            top_destinations=[],
+            limit=OTHER_LIMIT,
+            skip=skip_other,
+        )
+
+        # Xen kẽ
+        combined_posts = []
+        i = j = 0
+        while len(combined_posts) < PAGE_SIZE and (i < len(top_posts) or j < len(other_posts)):
+            if i < len(top_posts):
+                combined_posts.append(top_posts[i])
+                i += 1
+            if j < len(other_posts) and len(combined_posts) < PAGE_SIZE:
+                combined_posts.append(other_posts[j])
+                j += 1
+
+        # Enrich thông tin
+        user_ids = list({post.get("user_id") for post in combined_posts})
+        destination_ids = list({post.get("destination_id") for post in combined_posts})
+        post_ids = [post["_id"] for post in combined_posts]
+
+        user_infos, destination_infos, reactions = await gather(
+            *[
+                gather(*[UserCRUD.find_by_id(uid) for uid in user_ids]),
+                gather(*[DestinationCRUD.find_by_id(did) for did in destination_ids]),
+                gather(
+                    *[
+                        ReactionCRUD.read_one(
+                            {"user_id": user_id, "post_id": serialize_datetime(pid)}
+                        )
+                        for pid in post_ids
+                    ]
+                ),
+            ]
+        )
+
+        user_info_map = {
+            info["_id"]: {
+                "user_id": info["_id"],
+                "name": info["name"],
+                "picture": info.get("picture"),
+            }
+            for info in user_infos
+            if info
+        }
+
+        destination_info_map = {
+            info["_id"]: info["name"] for info in destination_infos if info
+        }
+
+        user_reaction_map = {}
+        for reaction in reactions:
+            if reaction:
+                post_id = reaction.get("post_id")
+                user_reaction_map[post_id] = {
+                    "id": serialize_datetime(reaction["_id"]),
+                    "post_id": post_id,
+                    "user_id": reaction.get("user_id"),
+                    "reaction_type": reaction.get("type"),
+                }
+
+        serialized_posts = []
+        for post in combined_posts:
+            pid = serialize_datetime(post["_id"])
+            uid = post.get("user_id")
+            dest_id = post.get("destination_id")
+            serialized_posts.append(
+                {
+                    "id": pid,
+                    "content": post.get("content"),
+                    "destination_id": dest_id,
+                    "destination_name": destination_info_map.get(dest_id),
+                    "comment_count": post.get("comment_count", 0),
+                    "reaction_count": post.get("reaction_count", 0),
+                    "current_user_reaction": user_reaction_map.get(pid),
+                    "picture": post.get("picture", []),
+                    "created_at": serialize_datetime(post.get("created_at")),
+                    "updated_at": serialize_datetime(post.get("updated_at")),
+                    "priority_score": post.get("PriorityScore", 0),
+                    "destination_score": post.get("DestinationScore", 0),
+                    "engagement_score": post.get("EngagementScore", 0),
+                    "freshness_score": post.get("FreshnessScore", 0),
+                    "user_info": user_info_map.get(uid),
+                }
+            )
+
+        return {
+            "status": "success",
+            "message": {
+                "data": serialized_posts,
+                "page": page,
+                "total_pages": total_pages,
+                "total_items": total_items,
+                "page_size": PAGE_SIZE,
+            },
+        }
+
+    except Exception as e:
+        logger.error(f"Error listing personalized posts: {str(e)}")
+        return {"status": "error", "message": str(e)}
+
 async def list_all_posts_controller(user_id: str, page: int = 1):
     try:
         PAGE_SIZE = 5

src/apis/routes/post_router.py

@@ -1,5 +1,5 @@
 from fastapi import APIRouter, status, Depends, BackgroundTasks, Query
-from typing import Annotated, Optional
+from typing import Annotated, Optional, List
 from fastapi.responses import JSONResponse
 from pydantic import Field
 from src.apis.models.user_models import User
@@ -12,6 +12,7 @@ from src.apis.controllers.post_controller import (
     get_a_post_controller,
     update_a_post_controller,
     delete_a_post_controller,
+    list_all_posts_controller_priority,
 )
 from src.utils.redis import set_key_redis, get_key_redis
 from src.utils.logger import logger
@@ -97,6 +98,23 @@ async def list_all_posts_destination(
     else:
         return JSONResponse(content=result, status_code=200)
 
+@router.get("/list_post_priority", status_code=status.HTTP_200_OK)
+async def list_all_posts_priority(
+    user_id: Optional[str] = Query(None),
+    page: int = Query(default=1, ge=1),
+    top_5_destinations: List[str] = Query(default=[]),
+    view_post_ids: List[str] = Query(default=[]),
+):
+    # 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_priority(user_id, page, top_5_destinations, view_post_ids)
+        # background_tasks.add_task(set_key_redis, "all_posts", str(result),20)
+    if result["status"] == "error":
+        return JSONResponse(content=result, status_code=404)
+    else:
+        return JSONResponse(content=result, status_code=200)
 
 class BodyUpdatePost(BaseDocument):
     content: str = Field(..., description="Post's content", min_length=1)

src/apis/routes/travel_dest_route.py

@@ -155,7 +155,9 @@ async def get_tourist_names():
 
 @router.get("/suggest")
 async def destination_suggestion(
-    question: str,
+    question: str = Query(
+        default="", min_length=1, max_length=50, description="User's question"
+    ),
     user_id: str = Query(
         default=None, description="User ID for personalized recommendations"
     ),

src/utils/helper.py

@@ -12,6 +12,15 @@ from fastapi import HTTPException
 from bson import ObjectId
 
 
+
+def deserialize_objectid(id_str: str) -> ObjectId:
+    """Chuyển string thành ObjectId (nếu hợp lệ), nếu không thì raise lỗi."""
+    try:
+        return ObjectId(id_str)
+    except Exception as e:
+        raise ValueError(f"Invalid ObjectId string: {id_str}") from e
+
+
 def handle_validator_raise(func):
     """
     Custom decorator to handle exceptions raised by the validator
@@ -58,9 +67,7 @@ def format_weather_data(weather_data):
         location = f"Latitude: {lat}, Longitude: {lon}"
         icon_url = f"http://openweathermap.org/img/wn/{current_weather['weather'][0]['icon']}@2x.png"
         formatted_weather = f"In {location}, the current weather is as follows:\n"
-        formatted_weather += (
-            f"  <img src='{icon_url}' width='100' height='100'/>\n"
-        )
+        formatted_weather += f"  <img src='{icon_url}' width='100' height='100'/>\n"
         formatted_weather += (
             f"  Detailed status: {current_weather['weather'][0]['description']}\n"
         )

src/utils/mongo.py

@@ -196,6 +196,114 @@ class MongoCRUD:
             return 0
 
 
+from motor.motor_asyncio import AsyncIOMotorCollection
+from bson.son import SON
+from datetime import datetime, timedelta
+
+from typing import List, Dict
+
+
+class PostMongoCRUD(MongoCRUD):
+    async def find_many_with_score(
+        self,
+        filter: Dict,
+        top_destinations: List[str],
+        limit: int = 10,
+        skip: int = 0,
+    ) -> List[Dict]:
+        now = datetime.now(timezone.utc)
+
+        destination_score_branches = [
+            {"case": {"$eq": ["$destination_id", did]}, "then": (5 - i) * 2}
+            for i, did in enumerate(top_destinations)
+        ]
+
+        pipeline = [
+            {"$match": filter},
+            {
+                "$addFields": {
+                    "BaseScore": 1,
+                    "DestinationScore": (
+                        {
+                            "$switch": {
+                                "branches": destination_score_branches,
+                                "default": 0,
+                            }
+                        }
+                        if top_destinations
+                        else 0
+                    ),
+                    "EngagementScore": {
+                        "$min": [
+                            {
+                                "$divide": [
+                                    {
+                                        "$add": [
+                                            "$reaction_count",
+                                            {"$multiply": ["$comment_count", 2]},
+                                        ]
+                                    },
+                                    100,
+                                ]
+                            },
+                            5,
+                        ]
+                    },
+                    "FreshnessScore": {
+                        "$switch": {
+                            "branches": [
+                                {
+                                    "case": {
+                                        "$gte": ["$created_at", now - timedelta(days=1)]
+                                    },
+                                    "then": 5,
+                                },
+                                {
+                                    "case": {
+                                        "$gte": ["$created_at", now - timedelta(days=3)]
+                                    },
+                                    "then": 3,
+                                },
+                                {
+                                    "case": {
+                                        "$gte": ["$created_at", now - timedelta(days=7)]
+                                    },
+                                    "then": 2,
+                                },
+                            ],
+                            "default": 1,
+                        }
+                    },
+                }
+            },
+            {
+                "$addFields": {
+                    "PriorityScore": {
+                        "$add": [
+                            "$BaseScore",
+                            "$DestinationScore",
+                            "$EngagementScore",
+                            "$FreshnessScore",
+                        ]
+                    }
+                }
+            },
+            {"$sort": SON([("PriorityScore", -1), ("created_at", -1)])},
+            {"$skip": skip},
+            {"$limit": limit},
+        ]
+
+        cursor = self.collection.aggregate(pipeline)
+        results = []
+        async for doc in cursor:
+            doc["_id"] = str(doc["_id"])
+            results.append(doc)
+        return results
+
+
+PostCRUD = PostMongoCRUD(database[MongoCfg.POST], Post)
+
+
 def chat_messages_history(
     session_id: str, number_of_messages: int = MongoCfg.MAX_HISTORY_SIZE, db="mongo"
 ):
@@ -221,7 +329,6 @@ def chat_messages_history(
 BookHotelCRUD = MongoCRUD(database[MongoCfg.BOOK_HOTEL], BookHotel)
 ScheduleCRUD = MongoCRUD(database[MongoCfg.ACTIVITY], Schedule)
 UserCRUD = MongoCRUD(database[MongoCfg.USER], User)
-PostCRUD = MongoCRUD(database[MongoCfg.POST], Post)
 ReactionCRUD = MongoCRUD(database[MongoCfg.REACTION], Reaction)
 CommentCRUD = MongoCRUD(database[MongoCfg.COMMENT], Comment)
 DestinationCRUD = MongoCRUD(database[MongoCfg.DESTINATION], Destination)