Upload 159 files

src/apis/controllers/post_controller.py

@@ -6,6 +6,7 @@ from asyncio import gather
 from src.utils.helper import call_external_api, serialize_datetime
 from datetime import datetime
 from bson import ObjectId
+import math
 
 
 async def create_a_post_controller(
@@ -56,9 +57,24 @@ async def get_a_post_controller(post_id: str) -> Dict:
         return {"status": "error", "message": str(e)}
 
 
-async def list_all_posts_controller(user_id: str):
+async def list_all_posts_controller(user_id: str, page: int = 1):
     try:
-        posts = await PostCRUD.find_all()
+        PAGE_SIZE = 1
+        # Calculate skip value for pagination
+        skip = (page - 1) * PAGE_SIZE
+
+        # Get total count for pagination metadata
+        total_items = await PostCRUD.count({})
+        total_pages = math.ceil(total_items / PAGE_SIZE)
+
+        # Get paginated posts
+        posts = await PostCRUD.find_many(
+            filter={},  # Empty filter means get all
+            skip=skip,
+            limit=PAGE_SIZE,
+            sort=[("created_at", -1)],  # Sort by created_at descending
+        )
+
         user_ids = list({post.get("user_id") for post in posts})
         user_infos = await gather(*[UserCRUD.find_by_id(uid) for uid in user_ids])
         user_info_map = {
@@ -115,19 +131,53 @@ async def list_all_posts_controller(user_id: str):
             }
             serialized_posts.append(serialized_post)
 
-        return {"status": "success", "message": serialized_posts}
+        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 posts: {str(e)}")
         return {"status": "error", "message": str(e)}
 
 
-async def list_posts_by_destination_controller(destination_id: str, user_id: str):
+async def list_posts_by_destination_controller(
+    destination_id: str, user_id: str, page: int = 1
+):
     try:
-        # Filtered posts only for the given destination_id
-        posts = await PostCRUD.find_many({"destination_id": destination_id})
+        PAGE_SIZE = 1  # Changed from 1 to 5 posts per page
+        # Calculate skip value for pagination
+        skip = (page - 1) * PAGE_SIZE
+
+        # Get total count for pagination metadata
+        total_items = await PostCRUD.count({"destination_id": destination_id})
+        total_pages = math.ceil(total_items / PAGE_SIZE)
+
+        # Get paginated posts
+        posts = await PostCRUD.find_many(
+            filter={"destination_id": destination_id},
+            skip=skip,
+            limit=PAGE_SIZE,
+            sort=[("created_at", -1)],  # Sort by created_at descending
+        )
+
         if not posts:
-            return {"status": "success", "message": []}
+            return {
+                "status": "success",
+                "message": {
+                    "data": [],
+                    "page": page,
+                    "total_pages": total_pages,
+                    "total_items": total_items,
+                    "page_size": PAGE_SIZE,
+                },
+            }
 
         # Get unique user_ids
         user_ids = list({post.get("user_id") for post in posts})
@@ -186,7 +236,16 @@ async def list_posts_by_destination_controller(destination_id: str, user_id: str
             }
             serialized_posts.append(serialized_post)
 
-        return {"status": "success", "message": serialized_posts}
+        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 posts by destination: {str(e)}")

src/apis/controllers/scheduling_controller.py

@@ -2,10 +2,6 @@ from typing import Optional, Dict, Union
 from datetime import datetime
 from src.utils.mongo import ScheduleCRUD
 from src.utils.logger import logger
-from datetime import datetime
-from bson import ObjectId
-from typing import Optional, Dict
-from datetime import datetime
 from bson import ObjectId
 
 

src/apis/controllers/user_controller.py

@@ -0,0 +1,131 @@
+from datetime import datetime
+from src.utils.mongo import UserCRUD
+from src.utils.logger import logger
+from bson import ObjectId
+from fastapi.responses import JSONResponse
+from typing import Dict
+
+
+async def list_users_controller():
+    try:
+        users = await UserCRUD.find_all()
+        # Convert datetime fields to ISO format
+        for user in users:
+            if "created_at" in user and isinstance(user["created_at"], datetime):
+                user["created_at"] = user["created_at"].isoformat()
+            if "updated_at" in user and isinstance(user["updated_at"], datetime):
+                user["updated_at"] = user["updated_at"].isoformat()
+            if "expire_at" in user and isinstance(user["expire_at"], datetime):
+                user["expire_at"] = user["expire_at"].isoformat()
+        return JSONResponse(
+            content={
+                "status": "success",
+                "data": users,
+            },
+            status_code=200,
+        )
+    except Exception as e:
+        logger.error(f"Error listing users: {e}")
+        return JSONResponse(
+            content={
+                "status": "error",
+                "message": str(e),
+            },
+            status_code=500,
+        )
+
+
+async def update_user_controller(user_id: str, user_data: dict):
+    try:
+        user = await UserCRUD.update({"_id": ObjectId(user_id)}, user_data)
+
+        # Convert datetime fields to ISO format
+        if user:
+            if "created_at" in user and isinstance(user["created_at"], datetime):
+                user["created_at"] = user["created_at"].isoformat()
+            if "updated_at" in user and isinstance(user["updated_at"], datetime):
+                user["updated_at"] = user["updated_at"].isoformat()
+            if "expire_at" in user and isinstance(user["expire_at"], datetime):
+                user["expire_at"] = user["expire_at"].isoformat()
+
+            return JSONResponse(
+                content={
+                    "status": "success",
+                    "data": user,
+                },
+                status_code=200,
+            )
+        else:
+            return JSONResponse(
+                content={
+                    "status": "error",
+                    "message": "User not found",
+                },
+                status_code=404,
+            )
+    except Exception as e:
+        logger.error(f"Error updating user: {e}")
+        return JSONResponse(
+            content={
+                "status": "error",
+                "message": str(e),
+            },
+            status_code=500,
+        )
+
+
+async def delete_user_controller(user_id: str):
+    try:
+        user = await UserCRUD.delete_one({"_id": ObjectId(user_id)})
+        return JSONResponse(
+            content={
+                "status": "success",
+                "data": user,
+            },
+            status_code=200,
+        )
+    except Exception as e:
+        logger.error(f"Error deleting user: {e}")
+        return JSONResponse(
+            content={
+                "status": "error",
+                "message": str(e),
+            },
+            status_code=500,
+        )
+
+
+async def get_user_by_id_controller(user_id: str):
+    try:
+        user = await UserCRUD.find_by_id(user_id)
+        if not user:
+            return JSONResponse(
+                content={
+                    "status": "error",
+                    "message": "User not found",
+                },
+                status_code=404,
+            )
+        # Convert datetime fields to ISO format
+        if "created_at" in user and isinstance(user["created_at"], datetime):
+            user["created_at"] = user["created_at"].isoformat()
+        if "updated_at" in user and isinstance(user["updated_at"], datetime):
+            user["updated_at"] = user["updated_at"].isoformat()
+        if "expire_at" in user and isinstance(user["expire_at"], datetime):
+            user["expire_at"] = user["expire_at"].isoformat()
+        return JSONResponse(
+            content={
+                "status": "success",
+                "data": user,
+            },
+            status_code=200,
+        )
+    except Exception as e:
+        logger.error(f"Error getting user by id: {e}")
+        return JSONResponse(
+            content={
+                "status": "error",
+                "message": str(e),
+            },
+            status_code=500,
+        )

src/apis/create_app.py

@@ -10,6 +10,7 @@ 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
 from src.apis.routes.reaction_route import router as router_reaction
+
 api_router = APIRouter()
 api_router.include_router(router_chat)
 api_router.include_router(router_auth)

src/apis/models/user_models.py

@@ -18,6 +18,7 @@ def list_serial(users) -> list:
 
 
 class User(BaseDocument):
+    id: str = Field("", description="User's id")
     name: str = Field("", description="User's name")
     email: EmailStr = Field("", description="User's email")
     picture: str = Field("", title="User Picture")

src/apis/routes/auth_route.py

@@ -3,6 +3,12 @@ from fastapi.responses import JSONResponse
 from typing import Annotated
 from src.apis.models.user_models import User
 from src.apis.controllers.auth_controller import login_control
+from src.apis.controllers.user_controller import (
+    list_users_controller,
+    update_user_controller,
+    delete_user_controller,
+    get_user_by_id_controller,
+)
 from src.apis.interfaces.auth_interface import _LoginResponseInterface
 from src.apis.interfaces.auth_interface import Credential
 from src.apis.middlewares.auth_middleware import get_current_user
@@ -36,11 +42,22 @@ async def get_user_info(user: user_dependency):
         return JSONResponse(content={"message": "User not found"}, status_code=401)
     return JSONResponse(content={"user": user}, status_code=200)
 
-import time
-import asyncio
-@router.get("/test", status_code=status.HTTP_200_OK)
-async def test():
-    print("da vao")
-    await asyncio.sleep(5)  # Use asyncio.sleep for non-blocking sleep
-    print("alo")
-    return "test"
+
+@router.get("/users", status_code=status.HTTP_200_OK)
+async def get_users():
+    return await list_users_controller()
+
+
+@router.put("/users/{user_id}", status_code=status.HTTP_200_OK)
+async def update_user(user_id: str, user_data: dict):
+    return await update_user_controller(user_id, user_data)
+
+
+@router.delete("/users/{user_id}", status_code=status.HTTP_200_OK)
+async def delete_user(user_id: str):
+    return await delete_user_controller(user_id)
+
+
+@router.get("/users/{user_id}", status_code=status.HTTP_200_OK)
+async def get_user_by_id(user_id: str):
+    return await get_user_by_id_controller(user_id)

src/apis/routes/post_router.py

@@ -1,4 +1,4 @@
-from fastapi import APIRouter, status, Depends, BackgroundTasks
+from fastapi import APIRouter, status, Depends, BackgroundTasks, Query
 from typing import Annotated, Optional
 from fastapi.responses import JSONResponse
 from pydantic import Field
@@ -66,12 +66,13 @@ async def get_post(post_id: str):
 
 
 @router.get("/list", status_code=status.HTTP_200_OK)
-async def list_all_posts(user_id: Optional[str] = None):
+async def list_all_posts(user_id: Optional[str] = None, page: int = Query(default=1, ge=1)):
     # 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(user_id)
+        result = await list_all_posts_controller(user_id, page)
+        print("result", result)
         # background_tasks.add_task(set_key_redis, "all_posts", str(result), 20)
     if result["status"] == "error":
         return JSONResponse(content=result, status_code=404)
@@ -83,12 +84,13 @@ async def list_all_posts(user_id: Optional[str] = None):
 async def list_all_posts_destination(
     destination_id: str,
     user_id: Optional[str] = None,
+    page: int = Query(default=1, ge=1),
 ):
     # result = await get_key_redis("all_posts")
     result = None
     result = eval(result) if result else None
     if not result:
-        result = await list_posts_by_destination_controller(destination_id, user_id)
+        result = await list_posts_by_destination_controller(destination_id, user_id, page)
         # background_tasks.add_task(set_key_redis, "all_posts", str(result),20)
     if result["status"] == "error":
         return JSONResponse(content=result, status_code=404)

src/apis/routes/travel_dest_route.py

@@ -63,7 +63,7 @@ async def get_destinations(destination_id: str = Query(min_length=1, max_length=
         destination_data.pop("expire_at")
         destination_data["id"] = str(destination_data["_id"])
         destination_data.pop("_id")
-
+        print("destination_data", destination_data)
         return JSONResponse(content=destination_data, status_code=200)
 
     except Exception as e: