finished product api

Author: snu-BuMinSeong

carrot/app/auction/models.py

@@ -4,7 +4,7 @@
 from sqlalchemy import String, Integer, ForeignKey, Boolean, DateTime
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 from sqlalchemy.sql import func
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Optional
 
 from carrot.db.common import Base
 
@@ -24,7 +24,7 @@ class Auction(Base):
     id: Mapped[str] = mapped_column(String(36), primary_key=True, index=True, default=lambda: str(uuid.uuid4()))
     product_id: Mapped[str] = mapped_column(String(36), ForeignKey("product.id", ondelete="CASCADE"), nullable=False, unique=True, index=True)
 
-    starting_price: Mapped[int] = mapped_column(Integer, nullable=False)    # 시작가
+    # starting_price: Mapped[int] = mapped_column(Integer, nullable=False)    # 시작가
     current_price: Mapped[int] = mapped_column(Integer, nullable=False)     # 현재가
     # is_sold: Mapped[bool] = mapped_column(Boolean, default=False)         # Product의 is_sold와 중복
     end_at: Mapped[datetime] = mapped_column(DateTime, nullable=False)      # 경매 종료 시간
@@ -34,11 +34,13 @@ class Auction(Base):
     product: Mapped["Product"] = relationship("Product", back_populates="auction", uselist=False)
     bids: Mapped[list["Bid"]] = relationship("Bid", back_populates="auction", cascade="all, delete-orphan")
 
-    @property
-    def top_bid(self):
-        if not self.bids:
-            return None
-        return max(self.bids, key=lambda bid: bid.bid_price)
+    top_bid: Mapped[Optional["Bid"]] = relationship(
+        "Bid",
+        primaryjoin="and_(Auction.id==Bid.auction_id)",
+        order_by="desc(Bid.bid_price)",
+        uselist=False,
+        viewonly=True,
+    )
 
     @property
     def owner_id(self):

carrot/app/auction/repositories.py

@@ -53,26 +53,29 @@ async def get_auction_by_id(self, auction_id: str) -> Optional[Auction]:
         return auction
 
     async def get_active_auctions(
-            self,
-            category_id: Optional[str] = None,
-            region_id: Optional[str] = None
-    )-> List[Auction]:
+        self,
+        category_id: Optional[str] = None,
+        region_id: Optional[str] = None,
+    ) -> List[Auction]:
         stmt = (
             select(Auction)
             .where(Auction.status == AuctionStatus.ACTIVE)
             .options(selectinload(Auction.product))
+            .order_by(Auction.end_at.asc())
         )
 
-        if category_id:
-            stmt = stmt.join(Auction.product).where(Product.category_id == category_id)
-        
-        if region_id:
-            stmt = stmt.join(Auction.product).where(Product.region_id == region_id)
-        
-        stmt = stmt.order_by(Auction.end_at.asc())
+        # ✅ 필터가 있을 때만 join 한 번
+        if category_id or region_id:
+            stmt = stmt.join(Auction.product)
+
+            if category_id:
+                stmt = stmt.where(Product.category_id == category_id)
+
+            if region_id:
+                stmt = stmt.where(Product.region_id == region_id)
 
         result = await self.session.execute(stmt)
-        return result.scalars().all()
+        return result.scalars().unique().all()
 
     async def delete_auction(self, auction: Auction) -> None:
         await self.session.delete(auction)

carrot/app/auction/router.py

@@ -6,49 +6,48 @@
 from carrot.app.auth.utils import login_with_header
 
 from carrot.app.auction.services import AuctionService
-from carrot.app.auction.schemas import AuctionCreate, AuctionResponse, BidCreate, BidResponse # Pydantic 모델 가정
+from carrot.app.auction.schemas import AuctionListResponse, AuctionResponse, BidCreate, BidResponse # Pydantic 모델 가정
 
 from carrot.app.user.models import User
 
 from carrot.app.product.schemas import ProductPostRequest
 
 auction_router = APIRouter()
 
-# 1. 경매 등록
-@auction_router.post("/", response_model=AuctionResponse)
-async def create_new_auction(
-    owner: Annotated[User, Depends(login_with_header)],
-    product_data: ProductPostRequest,
-    auction_data: AuctionCreate,
-    service: Annotated[AuctionService, Depends(AuctionService.create)],
-) -> AuctionResponse:
-    auction = await service.create_auction_with_product(
-        owner_id=owner.id,
-        region_id=owner.region_id,
-        product_data=product_data,
-        auction_data=auction_data
-    )
-    return AuctionResponse.model_validate(auction)
+# # 1. 경매 등록
+# @auction_router.post("/", response_model=AuctionResponse)
+# async def create_new_auction(
+#     owner: Annotated[User, Depends(login_with_header)],
+#     product_data: ProductPostRequest,
+#     auction_data: AuctionCreate,
+#     service: Annotated[AuctionService, Depends(AuctionService.create)],
+# ) -> AuctionResponse:
+#     auction = await service.create_auction_with_product(
+#         owner_id=owner.id,
+#         region_id=owner.region_id,
+#         product_data=product_data,
+#         auction_data=auction_data
+#     )
+#     return AuctionResponse.model_validate(auction)
 
 # 2. 경매 목록 조회 (카테고리, 지역 필터링)
-@auction_router.get("/", response_model=List[AuctionResponse])
+@auction_router.get("/", response_model=List[AuctionListResponse])
 async def get_auctions(
     service: Annotated[AuctionService, Depends(AuctionService.create)],
     category_id: Optional[str] = Query(None, description="카테고리 ID로 필터링"),
     region_id: Optional[str] = Query(None, description="지역 ID로 필터링"),
-) -> List[AuctionResponse]:
-    
+) -> List[AuctionListResponse]:
     auctions = await service.list_auctions(category_id, region_id)
-    return auctions
+    return [AuctionListResponse.model_validate(a) for a in auctions]
 
-# 3. 경매 상세 조회
-@auction_router.get("/{auction_id}", response_model=AuctionResponse)
-async def get_auction_detail(
-    auction_id: str,
-    service: Annotated[AuctionService, Depends(AuctionService.create)],
-) -> AuctionResponse:
-    auction = await service.get_auction_details(auction_id)
-    return AuctionResponse.model_validate(auction)
+# # 3. 경매 상세 조회
+# @auction_router.get("/{auction_id}", response_model=AuctionResponse)
+# async def get_auction_detail(
+#     auction_id: str,
+#     service: Annotated[AuctionService, Depends(AuctionService.create)],
+# ) -> AuctionResponse:
+#     auction = await service.get_auction_details(auction_id)
+#     return AuctionResponse.model_validate(auction)
 
 # 4. 입찰하기
 @auction_router.post("/{auction_id}/bids", response_model=BidResponse)

carrot/app/auction/schemas.py

@@ -3,8 +3,6 @@
 from typing import List, Optional
 from enum import Enum
 
-from carrot.app.product.schemas import ProductResponse
-
 from sqlalchemy import func
 
 # 경매 상태 Enum (모델과 맞춤)
@@ -15,7 +13,7 @@ class AuctionStatus(str, Enum):
     CANCELED = "canceled"
 
 class AuctionCreate(BaseModel):
-    starting_price: int = Field(..., gt=0, description="경매 시작 가격")
+    # starting_price: int = Field(..., gt=0, description="경매 시작 가격")
     end_at: datetime = Field(..., description="경매 종료 시간")
 
     @field_validator("end_at")
@@ -32,15 +30,50 @@ def validate_end_at(cls, v: datetime) -> datetime:
             raise ValueError("경매 종료 시간은 현재 시간보다 미래여야 합니다.")
         return v
 
+class AuctionProductSummary(BaseModel):
+    id: str
+    owner_id: str
+    title: str
+    image_ids: List[str]
+    content: str | None
+    price: int
+    like_count: int
+    category_id: str
+    region_id: str
+    is_sold: bool
+
+    class Config:
+        from_attributes = True
+
+class BidSummaryResponse(BaseModel):
+    id: str
+    bidder_id: str
+    bid_price: int
+    bid_at: datetime
+
+    class Config:
+        from_attributes = True
+    
+class AuctionListResponse(BaseModel):
+    id: str
+    product_id: str
+    current_price: int
+    end_at: datetime
+    bid_count: int
+    status: AuctionStatus
+
+    product: AuctionProductSummary
+
+    class Config:
+        from_attributes = True
+
 class AuctionResponse(BaseModel):
     id: str
     product_id: str
-    starting_price: int
     current_price: int
     end_at: datetime
     bid_count: int
     status: AuctionStatus
-    product: ProductResponse
 
     class Config:
         from_attributes = True
@@ -56,4 +89,5 @@ class BidResponse(BaseModel):
     bid_at: datetime
 
     class Config:
-        from_attributes = True
+        from_attributes = True
+

carrot/app/image/repositories.py

@@ -1,30 +1,24 @@
-from typing import Annotated
-
-from fastapi import Depends
-from sqlalchemy import select, and_
+from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from carrot.app.user.models import LocalAccount, SocialAccount, User
 from carrot.app.image.models import Image
-from carrot.db.connection import get_db_session
 
 
 class ImageRepository:
-    def __init__(self, session: Annotated[AsyncSession, Depends(get_db_session)]) -> None:
+    def __init__(self, session: AsyncSession) -> None:
         self.session = session
 
     async def upload_image(self, image: Image) -> Image:
         self.session.add(image)
-        await self.session.commit()
+        await self.session.flush()
         await self.session.refresh(image)
         return image
-    
-    async def get_image_by_image_id(self, image_id: str) -> Image:
+
+    async def get_image_by_image_id(self, image_id: str) -> Image | None:
         query = select(Image).where(Image.id == image_id)
-        posts = await self.session.execute(query)
-        
-        return posts.scalars().one_or_none()
-    
+        result = await self.session.execute(query)
+        return result.scalars().one_or_none()
+
     async def remove_image(self, image: Image) -> None:
         await self.session.delete(image)
-        await self.session.commit()
+        await self.session.flush()

carrot/app/image/router.py

@@ -1,53 +1,52 @@
 from typing import Annotated
-from fastapi import APIRouter, Depends
-from fastapi import FastAPI, File, UploadFile, HTTPException
-from fastapi.responses import StreamingResponse
-import boto3
-import io
-
-from carrot.app.auth.utils import login_with_header, partial_login_with_header
-from carrot.app.user.models import User
-from carrot.app.image.schemas import (
-    ImageResponse,
-)
+
+from fastapi import APIRouter, Depends, File, UploadFile
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from carrot.db.connection import get_session_factory
+from carrot.app.image.schemas import ImageResponse
 from carrot.app.image.services import ImageService
 
 image_router = APIRouter()
 
+
 @image_router.post("/product", status_code=201, response_model=ImageResponse)
 async def upload_product_image(
-    service: Annotated[ImageService, Depends()],
+    session: Annotated[AsyncSession, Depends(get_session_factory)],
     file: UploadFile = File(...),
 ) -> ImageResponse:
-    image = await service.upload_image(
-        file,
-    )
+    service = ImageService(session)
+    async with session.begin():
+        image = await service.upload_image(file)
     return ImageResponse.model_validate(image)
 
+
 @image_router.post("/user", status_code=201, response_model=ImageResponse)
 async def upload_profile_image(
-    service: Annotated[ImageService, Depends()],
+    session: Annotated[AsyncSession, Depends(get_session_factory)],
     file: UploadFile = File(...),
 ) -> ImageResponse:
-    image = await service.upload_image(
-        file,
-    )
+    service = ImageService(session)
+    async with session.begin():
+        image = await service.upload_image(file)
     return ImageResponse.model_validate(image)
 
+
 @image_router.get("/product/{image_id}", status_code=200, response_model=ImageResponse)
 async def view_product_image(
-    service: Annotated[ImageService, Depends()],
-    image_id: str
+    session: Annotated[AsyncSession, Depends(get_session_factory)],
+    image_id: str,
 ) -> ImageResponse:
+    service = ImageService(session)
     image = await service.view_image(image_id)
-    
     return ImageResponse.model_validate(image)
 
+
 @image_router.get("/user/{image_id}", status_code=200, response_model=ImageResponse)
 async def view_profile_image(
-    service: Annotated[ImageService, Depends()],
-    image_id: str
+    session: Annotated[AsyncSession, Depends(get_session_factory)],
+    image_id: str,
 ) -> ImageResponse:
+    service = ImageService(session)
     image = await service.view_image(image_id)
-    
-    return ImageResponse.model_validate(image)
+    return ImageResponse.model_validate(image)