Upload 157 files

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
 
 
@@ -26,6 +25,9 @@ async def create_a_comment_controller(content: str, user_id: str, post_id: str)
             "post_id": post_id,
         }
         await CommentCRUD.create(comment)
+        await PostCRUD.update(
+            {"_id": ObjectId(post_id)}, {"$inc": {"comment_count": 1}}
+        )
         return {"status": "success", "message": "Comment created successfully"}
     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/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/apis/controllers/reaction_controller.py

@@ -1,6 +1,6 @@
 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
@@ -26,6 +26,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 +73,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 +108,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/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/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/utils/mongo.py

@@ -93,12 +93,18 @@ 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: