2025 SSF Public

Backend/router/endpoints/avatar.py

@@ -0,0 +1,49 @@
+from fastapi import APIRouter, HTTPException, Depends
+from ...schemas.avatar import (
+    AvatarUpdate,
+    AvatarResponse,
+    AvatarOptions,
+)
+from ...services.avatar_service import AvatarService
+from ...core.security import get_current_user
+from ...schemas.user import User
+
+router = APIRouter(prefix="/avatar", tags=["avatar"])
+avatar_service = AvatarService()
+
+
+@router.get("", response_model=AvatarResponse)
+async def get_my_avatar(
+    current_user: User = Depends(get_current_user),
+) -> AvatarResponse:
+    try:
+        avatar = await avatar_service.get_or_create_avatar(current_user.id)
+        return avatar.to_response()
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@router.put("", response_model=AvatarResponse)
+async def update_avatar(
+    avatar_data: AvatarUpdate, current_user: User = Depends(get_current_user)
+) -> AvatarResponse:
+    try:
+        avatar = await avatar_service.update_avatar(current_user.id, avatar_data)
+        return avatar.to_response()
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@router.get("/options", response_model=AvatarOptions)
+async def get_avatar_options() -> AvatarOptions:
+    try:
+        return await avatar_service.get_avatar_options()
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+@router.get("/{user_id}", response_model=AvatarResponse)
+async def get_avatar_by_userId(user_id: int) -> AvatarResponse:
+    avatar = await avatar_service.get_avatar_by_userId(user_id)
+    if not avatar:
+        raise HTTPException(status_code=404, detail="Avatar not found")
+    return avatar.to_response()

Backend/router/endpoints/diary.py

@@ -0,0 +1,102 @@
+from fastapi import (
+    APIRouter,
+    HTTPException,
+    Depends,
+    UploadFile,
+    File,
+)
+from typing import List, Optional
+from ...schemas.diary import DiaryCreate, DiaryUpdate, DiaryResponse, Diary
+from ...services.diary_service import DiaryService
+from ...core.security import get_current_user
+from ...schemas.user import User
+
+router = APIRouter(prefix="/diary", tags=["diary"])
+diary_service = DiaryService()
+
+
+@router.post("", response_model=DiaryResponse)
+async def create_diary(
+    diary_data: DiaryCreate = Depends(DiaryCreate.as_form),
+    file: List[UploadFile] = File(default=None),
+    current_user: User = Depends(get_current_user),
+) -> DiaryResponse:
+    try:
+        diary = await diary_service.create_diary(current_user.id, diary_data, file)
+        return diary.to_response()
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@router.get("", response_model=List[DiaryResponse])
+async def get_user_diaries(
+    skip: int = 0,
+    limit: int = 20,
+    category: Optional[str] = None,
+    current_user: User = Depends(get_current_user),
+) -> List[DiaryResponse]:
+    try:
+        diaries = await diary_service.get_user_diaries(
+            current_user.id, skip, limit, category
+        )
+        return [diary.to_response() for diary in diaries]
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@router.get("/w/{target_user_id}", response_model=List[DiaryResponse])
+async def get_target_user_diaries(
+    target_user_id: int,
+    skip: int = 0,
+    limit: int = 20,
+    category: Optional[str] = None,
+) -> List[DiaryResponse]:
+    try:
+        diaries = await diary_service.get_user_diaries(
+            target_user_id, skip, limit, category
+        )
+        return [diary.to_response() for diary in diaries]
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@router.get("/{diary_id}", response_model=DiaryResponse)
+async def get_diary(diary_id: int) -> DiaryResponse:
+    try:
+        diary = await diary_service.get_diary_by_id(diary_id)
+        if not diary:
+            raise HTTPException(status_code=404, detail="Diary not found")
+        return diary.to_response()
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@router.put("/{diary_id}", response_model=DiaryResponse)
+async def update_diary(
+    diary_id: int,
+    diary_data: DiaryUpdate = Depends(DiaryUpdate.as_form),
+    file: List[UploadFile] = File(default=None),
+    current_user: User = Depends(get_current_user),
+) -> DiaryResponse:
+    try:
+        diary = await diary_service.update_diary(
+            diary_id, current_user.id, diary_data, file
+        )
+        if not diary:
+            raise HTTPException(status_code=404, detail="Diary not found")
+        return diary.to_response()
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@router.delete("/{diary_id}")
+async def delete_diary(
+    diary_id: int, current_user: User = Depends(get_current_user)
+) -> dict:
+    try:
+        success = await diary_service.delete_diary(diary_id, current_user.id)
+        if not success:
+            raise HTTPException(status_code=404, detail="Diary not found")
+        return {"message": "Diary deleted successfully"}
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))

Backend/router/endpoints/friendship.py

@@ -0,0 +1,81 @@
+from fastapi import APIRouter, HTTPException, Depends
+from typing import List, Optional
+from ...schemas.friendship import (
+    FriendshipRequest,
+    FriendshipResponse,
+)
+from ...services.friendship_service import FriendshipService
+from ...core.security import get_current_user
+from ...schemas.user import User
+
+router = APIRouter(prefix="/friendship", tags=["friendship"])
+friendship_service = FriendshipService()
+
+
+@router.post("/request", response_model=FriendshipResponse)
+async def send_friendship_request(
+    request_data: FriendshipRequest, current_user: User = Depends(get_current_user)
+) -> FriendshipResponse:
+    try:
+        friendship = await friendship_service.send_friendship_request(
+            current_user.id, request_data.friend_username
+        )
+        return friendship
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@router.put("/{friendship_id}/accept", response_model=FriendshipResponse)
+async def accept_friendship_request(
+    friendship_id: int, current_user: User = Depends(get_current_user)
+) -> FriendshipResponse:
+    try:
+        friendship = await friendship_service.accept_friendship_request(
+            friendship_id, current_user.id
+        )
+        if not friendship:
+            raise HTTPException(status_code=404, detail="Friendship request not found")
+        return friendship
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@router.get("", response_model=List[FriendshipResponse])
+async def get_friendships(
+    status: Optional[str] = None, current_user: User = Depends(get_current_user)
+) -> List[FriendshipResponse]:
+    try:
+        friendships = await friendship_service.get_user_friendships(
+            current_user.id, status
+        )
+        return friendships
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@router.delete("/{friendship_id}")
+async def delete_friendship(
+    friendship_id: int, current_user: User = Depends(get_current_user)
+) -> dict:
+    try:
+        success = await friendship_service.delete_friendship(
+            friendship_id, current_user.id
+        )
+        if not success:
+            raise HTTPException(status_code=404, detail="Friendship not found")
+        return {"message": "Friendship deleted successfully"}
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@router.get("/pending", response_model=List[FriendshipResponse])
+async def get_pending_requests(
+    current_user: User = Depends(get_current_user),
+) -> List[FriendshipResponse]:
+    try:
+        pending_requests = await friendship_service.get_pending_requests(
+            current_user.id
+        )
+        return pending_requests
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))

Backend/router/endpoints/guestbook.py

@@ -0,0 +1,63 @@
+from typing import List
+from fastapi import APIRouter, HTTPException, Depends, status
+from Backend.core.security import get_current_user
+from Backend.schemas.guestbook import (
+    GuestBookCreate,
+    GuestbookUpdate,
+    GuestbookResponse,
+)
+from Backend.schemas.user import User
+from Backend.services.guestbook_service import GuestbookService
+
+router = APIRouter(prefix="/guestbook", tags=["guestbook"])
+
+guestbook_service = GuestbookService()
+
+
+@router.post("", status_code=status.HTTP_201_CREATED, response_model=GuestbookResponse)
+async def create_guestbook(
+    guestbook: GuestBookCreate, current_user: User = Depends(get_current_user)
+) -> GuestbookResponse:
+    try:
+        response = await guestbook_service.create_guestbook(guestbook, current_user)
+        return response
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@router.get("/{target_user_id}", response_model=List[GuestbookResponse])
+async def get_guestbook(target_user_id: int):
+    try:
+        response = await guestbook_service.get_target_user_guestbooks(target_user_id)
+        response.reverse()
+        return response
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@router.put("/{id}", response_model=GuestbookResponse)
+async def update_guestbook(
+    id: int,
+    guestbook: GuestbookUpdate,
+) -> GuestbookResponse:
+    try:
+        response = await guestbook_service.update_guestbook_by_id(id, guestbook.content)
+        return response
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@router.delete("/{id}")
+async def delete_guestbook(
+    id: int,
+    user: User = Depends(get_current_user),
+) -> dict:
+    try:
+        is_success = await guestbook_service.delete_guestbook_by_id(id, user.id)
+        if is_success:
+            return {"detail": "success"}
+        else:
+            raise HTTPException(status_code=404, detail="guestbook not found")
+
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))

Backend/router/endpoints/letter.py

@@ -0,0 +1,79 @@
+# from fastapi import APIRouter, HTTPException, Depends
+#
+# from ...schemas.letter import LetterCreate, LetterResponse, EmailRequest
+# from ...services.letter_service import LetterService
+# from ...core.security import get_current_user
+# from ...schemas.user import User
+#
+# router = APIRouter(prefix="/letter", tags=["letter"])
+# letter_service = LetterService()
+#
+#
+# @router.post("", response_model=LetterResponse)
+# async def create_letter(
+#     letter_data: LetterCreate,
+#     current_user: User = Depends(get_current_user),
+# ) -> LetterResponse:
+#     try:
+#         letter = await letter_service.create_letter(current_user.id, letter_data)
+#         return letter.to_response()
+#     except Exception as e:
+#         raise HTTPException(status_code=400, detail=str(e))
+#
+#
+# @router.get("/{letter_id}", response_model=LetterResponse)
+# async def get_letter(
+#     letter_id: int, current_user: User = Depends(get_current_user)
+# ) -> LetterResponse:
+#     try:
+#         letter = await letter_service.get_letter_by_id(letter_id, current_user.id)
+#         if not letter:
+#             raise HTTPException(status_code=404, detail="Letter not found")
+#         return letter.to_response()
+#     except Exception as e:
+#         raise HTTPException(status_code=400, detail=str(e))
+#
+#
+# @router.delete("/{letter_id}")
+# async def delete_letter(letter_id: int, current_user: User = Depends(get_current_user)):
+#     try:
+#         is_success = await letter_service.delete_letter(letter_id, current_user.id)
+#         if not is_success:
+#             raise HTTPException(status_code=404, detail="Letter not found")
+#         return {"detail": "Letter deleted"}
+#     except Exception as e:
+#         raise HTTPException(status_code=400, detail=str(e))
+#
+#
+# @router.put("/{letter_id}", response_model=LetterResponse)
+# async def update_letter(
+#     letter_id: int,
+#     letter_data: LetterCreate,
+#     current_user: User = Depends(get_current_user),
+# ):
+#     try:
+#         letter = await letter_service.update_letter(
+#             letter_id, current_user.id, letter_data.content
+#         )
+#         if not letter:
+#             raise HTTPException(status_code=404, detail="Letter not found")
+#         return letter.to_response()
+#     except Exception as e:
+#         raise HTTPException(status_code=400, detail=str(e))
+#
+#
+# @router.post("/{letter_id}/send")
+# async def send_letter(
+#     letter_id: int,
+#     letter_data: EmailRequest,
+#     current_user: User = Depends(get_current_user),
+# ):
+#     try:
+#         letter = await letter_service.get_letter_by_id(letter_id, current_user.id)
+#         if not letter:
+#             raise HTTPException(status_code=404, detail="Letter not found")
+#
+#         await letter_service.send_letter(letter, letter_data)
+#         return {"message": "Email sent successfully!"}
+#     except Exception as e:
+#         raise HTTPException(status_code=400, detail=str(e))

Backend/router/endpoints/photo.py

@@ -0,0 +1,117 @@
+# from fastapi import APIRouter, HTTPException, Depends, UploadFile, File, Query, Form
+# from typing import List
+# from ...schemas.photo import (
+#     PhotoUpload,
+#     PhotoResponse,
+#     CommentCreate,
+#     CommentResponse,
+#     FilterRequest,
+# )
+# from ...services.photo_service import PhotoService
+# from ...core.security import get_current_user
+# from ...schemas.user import User
+# from pydantic import ValidationError
+#
+# router = APIRouter(prefix="/photo", tags=["photo"])
+# photo_service = PhotoService()
+#
+#
+# @router.post("/upload", response_model=PhotoResponse)
+# async def upload_photo(
+#     photo_data: UploadFile = Form(...),
+#     file: UploadFile = File(...),
+#     current_user: User = Depends(get_current_user),
+# ) -> PhotoResponse:
+#     import json
+#
+#     try:
+#         photo_data_bytes = await photo_data.read()
+#         photo_info = json.loads(photo_data_bytes.decode("utf-8"))
+#         photo_data = PhotoUpload(**photo_info)
+#     except (json.JSONDecodeError, ValidationError) as e:
+#         raise HTTPException(status_code=400, detail="Invalid photo data format")
+#     try:
+#         photo = await photo_service.upload_photo(current_user.id, photo_data, file)
+#         return photo.to_response()
+#     except Exception as e:
+#         raise HTTPException(status_code=400, detail=str(e))
+#
+#
+# @router.get("", response_model=List[PhotoResponse])
+# async def get_user_photos(
+#     skip: int = 0,
+#     limit: int = 20,
+#     album_name: str = None,
+#     current_user: User = Depends(get_current_user),
+# ) -> List[PhotoResponse]:
+#     try:
+#         photos = await photo_service.get_user_photos(
+#             current_user.id, skip, limit, album_name
+#         )
+#         return [photo.to_response() for photo in photos]
+#     except Exception as e:
+#         raise HTTPException(status_code=400, detail=str(e))
+#
+#
+# @router.post("/{photo_id}/comment", response_model=CommentResponse)
+# async def add_photo_comment(
+#     photo_id: int,
+#     comment_data: CommentCreate,
+#     current_user: User = Depends(get_current_user),
+# ) -> CommentResponse:
+#     try:
+#         is_friend = await photo_service.check_friendship(current_user.id, photo_id)
+#         if not is_friend:
+#             raise HTTPException(
+#                 status_code=403, detail="Only friends can comment on photos"
+#             )
+#
+#         comment = await photo_service.add_comment(
+#             photo_id, current_user.id, comment_data
+#         )
+#         return comment.to_response(current_user.username)
+#     except Exception as e:
+#         raise HTTPException(status_code=400, detail=str(e))
+#
+#
+# @router.get("/{photo_id}/comments", response_model=List[CommentResponse])
+# async def get_photo_comments(
+#     photo_id: int, current_user: User = Depends(get_current_user)
+# ) -> List[CommentResponse]:
+#     try:
+#         comments = await photo_service.get_photo_comments(photo_id)
+#         return comments
+#     except Exception as e:
+#         raise HTTPException(status_code=400, detail=str(e))
+#
+#
+# @router.post("/edit-filter")
+# async def apply_photo_filter(
+#     filter_request: FilterRequest, current_user: User = Depends(get_current_user)
+# ) -> dict:
+#     if filter_request.cover and filter_request.title is None:
+#         raise HTTPException(status_code=400, detail="title must be Not Null")
+#     try:
+#         filtered_image_path = await photo_service.apply_filter(
+#             filter_request.photo_id,
+#             filter_request.filter_type,
+#             current_user.id,
+#             filter_request.cover,
+#             filter_request.title,
+#         )
+#         return {"filtered_image_path": filtered_image_path}
+#     except Exception as e:
+#         raise HTTPException(status_code=400, detail=str(e))
+#
+#
+# @router.delete("/{photo_id}")
+# async def delete_photo(
+#     photo_id: int, current_user: User = Depends(get_current_user)
+# ) -> dict:
+#     try:
+#         success = await photo_service.delete_photo(photo_id, current_user.id)
+#         if not success:
+#             raise HTTPException(status_code=404, detail="Photo not found")
+#         return {"message": "Photo deleted successfully"}
+#     except Exception as e:
+#         raise HTTPException(status_code=400, detail=str(e))

Backend/router/endpoints/room.py

@@ -0,0 +1,110 @@
+from fastapi import APIRouter, Depends, HTTPException
+from typing import List
+from Backend.schemas.room import (
+    FurnitureItem,
+    RoomFurniturePlacement,
+    FurniturePlacementRequest,
+    RoomNameUpdateRequest,
+    UpdateRoomTypeRequest,
+    RoomResponse,
+    RoomTypeResponse,
+    RoomFurnitureResponse,
+)
+from Backend.schemas.user import User
+from Backend.core.security import get_current_user
+from Backend.services.room_service import RoomService
+
+router = APIRouter(prefix="/room", tags=["room"])
+room_service = RoomService()
+
+
+@router.get("/catalog", response_model=List[FurnitureItem])
+async def get_furniture_catalog() -> List[FurnitureItem]:
+    return await room_service.get_furniture_catalog()
+
+
+@router.get("/layout", response_model=RoomFurnitureResponse)
+async def get_my_room_layout(current_user: User = Depends(get_current_user)):
+    room_id = await room_service.get_or_create_room(current_user.id)
+    return await room_service.get_room_furnitures(room_id)
+
+
+@router.get("/layout/{user_id}", response_model=RoomFurnitureResponse)
+async def get_user_room_layout(user_id: int) -> RoomFurnitureResponse:
+    room_id = await room_service.get_or_create_room(user_id)
+    return await room_service.get_room_furnitures(room_id)
+
+
+@router.post("/furniture")
+async def place_furniture(
+    request: FurniturePlacementRequest, current_user: User = Depends(get_current_user)
+):
+    room_id = await room_service.get_or_create_room(current_user.id)
+    try:
+        await room_service.place_furniture(room_id, request)
+        return {"message": "Furniture placed successfully"}
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@router.delete("/furniture")
+async def remove_furniture(
+    x: int, y: int, furniture_name: str, current_user: User = Depends(get_current_user)
+):
+    room_id = await room_service.get_or_create_room(current_user.id)
+    await room_service.remove_furniture(room_id, x, y, furniture_name)
+    return {"message": "Furniture removed successfully"}
+
+
+@router.put("/")
+async def update_room_name(
+    data: RoomNameUpdateRequest, current_user: User = Depends(get_current_user)
+):
+    try:
+        room_id = await room_service.get_or_create_room(current_user.id)
+        await room_service.update_room_name(room_id, data.new_name)
+        return {"message": "Room name updated successfully"}
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@router.get("/")
+async def get_my_room(current_user: User = Depends(get_current_user)) -> RoomResponse:
+    try:
+        room_id = await room_service.get_or_create_room(current_user.id)
+        return (await room_service.get_room_by_id(room_id)).to_response()
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@router.get("/types")
+async def get_room_types() -> List[RoomTypeResponse]:
+    return await room_service.get_room_types()
+
+
+@router.patch("/")
+async def update_room_type(
+    data: UpdateRoomTypeRequest, current_user: User = Depends(get_current_user)
+) -> RoomResponse:
+    try:
+        room_id = await room_service.get_or_create_room(current_user.id)
+        return (await room_service.update_room_type(room_id, data.type)).to_response()
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@router.get("/my")
+async def get_my_furniture(current_user: User = Depends(get_current_user)):
+    try:
+        list_ = await room_service.get_user_furniture(current_user.id)
+        return list_
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    
+@router.get("/{user_id}", response_model=RoomResponse)
+async def get_room_by_userId(user_id: int) -> RoomResponse:
+    try:
+        room = await room_service.get_room_by_userId(user_id)
+        return room.to_response()
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))

Backend/router/endpoints/store.py

@@ -0,0 +1,48 @@
+from fastapi import APIRouter, Depends, HTTPException
+from ...core.security import get_current_user
+from ...schemas.user import User
+from Backend.services.store_service import StoreService
+from ...services.room_service import RoomService
+
+router = APIRouter(prefix="/store", tags=["store"])
+store_service = StoreService()
+room_service = RoomService()
+
+
+@router.get("")
+async def get_dotory(
+    current_user: User = Depends(get_current_user),
+):
+    try:
+        dotory = await store_service.get_dotory_by_id(current_user.id)
+        return {"dotory": dotory}
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@router.post("/{product_id}")
+async def buy_product(
+    product_id: int,
+    product_name: str,
+    current_user: User = Depends(get_current_user),
+):
+    try:
+        response = await store_service.buy_product(product_id, current_user.id)
+        if response["isSuccess"]:
+            await room_service.add_furniture(current_user.id, product_name)
+            return {"dotory": response["dotory"]}
+        raise HTTPException(status_code=404, detail="Product not found")
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@router.put("")
+async def update_dotory(
+    dotory_num: int,
+    current_user: User = Depends(get_current_user),
+):
+    try:
+        dotory = await store_service.update_user_dotory(current_user.id, dotory_num)
+        return {"dotory": dotory}
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))

Backend/router/endpoints/user.py

@@ -0,0 +1,116 @@
+from typing import List
+
+from fastapi import APIRouter, HTTPException, status, UploadFile, File, Depends
+from Backend.schemas.user import UserCreate, UserLogin, UserResponse, User, UserUpdate
+from Backend.services.user_service import UserService
+from Backend.core.security import create_access_token, get_current_user
+
+router = APIRouter(prefix="/user", tags=["user"])
+
+user_service = UserService()
+
+
+@router.post(
+    "/register", response_model=UserResponse, status_code=status.HTTP_201_CREATED
+)
+async def register_user(
+    user_data: UserCreate = Depends(UserCreate.as_form),
+    profile_file: UploadFile = File(default=None),
+) -> UserResponse:
+    existing_user = # 작성 #
+    if existing_user:
+        raise HTTPException(
+            status_code=# 작성 #
+            detail="# 작성 #"
+        )
+
+    existing_email = # 작성 #
+    if existing_email:
+        raise HTTPException(
+            status_code=# 작성 #
+            detail="# 작성 #"
+        )
+
+    try:
+        user = # 작성 #
+        return user.to_response()
+    except Exception as e:
+        raise HTTPException(
+            status_code=
+            detail="# 작성 #"
+        )
+
+@router.post("/login")
+async def login_user(login_data: UserLogin) -> dict:
+    user = await user_service.authenticate_user(
+        
+    )
+
+    if not user:
+        raise HTTPException(
+            status_code=
+            detail=
+        )
+
+    if not user.is_active:
+        raise HTTPException(
+            status_code=, detail=""
+        )
+
+    access_token = 
+
+    return {"access_token": access_token, "token_type": "bearer"}
+
+
+
+@router.get("/profile/{username}", response_model=UserResponse)
+async def get_user_profile(username: str) -> UserResponse:
+    user = await user_service.get_user_by_username(username)
+
+    if not user:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail="User not found"
+        )
+
+    return user.to_response()
+
+
+@router.get("/me", response_model=UserResponse)
+async def get_user_me(user: User = Depends(get_current_user)) -> UserResponse:
+    return user.to_response()
+
+
+@router.delete("/{username}")
+async def delete_user(username: str) -> dict:
+    is_success = await user_service.delete_user(username)
+    if not is_success:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail="User not found"
+        )
+    return {"detail": "User deleted"}
+
+
+@router.get("/find/{username}", response_model=List[UserResponse])
+async def find_user(username: str) -> List[UserResponse]:
+    users = await user_service.find_user(username)
+    return users
+
+
+@router.put("/", response_model=UserResponse)
+async def update_user(
+    current_user: User = Depends(get_current_user),
+    user_data: UserUpdate = Depends(UserUpdate.as_form),
+    profile_file: UploadFile = File(default=None),
+) -> UserResponse:
+    try:
+        updated_user = await user_service.update_user(
+            user=current_user, user_data=user_data, profile_file=profile_file
+        )
+        return updated_user.to_response()
+    except ValueError as e:
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e))
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to update user: {str(e)}",
+        )

Backend/router/router.py

@@ -0,0 +1,21 @@
+import os
+import traceback
+from fastapi import APIRouter
+from fastapi.logger import logger
+
+
+router = APIRouter()
+
+for router_file in os.listdir("Backend/router/endpoints"):
+    try:
+        if router_file.endswith(".py"):
+            module_name = "Backend.router.endpoints." + router_file[:-3]
+            module = __import__(module_name, fromlist=[""])
+            router_object = getattr(module, "router")
+            prefix = getattr(module, "prefix", router_file[:-3])
+
+            router.include_router(router_object, prefix="/api", tags=[router_file[:-3]])
+            print(f"Loaded router: /api/{prefix} - {router_file}")
+
+    except Exception as e:
+        logger.error(f"Error loading router {router_file}:\n{traceback.format_exc()}")