Fix place_bid

Feature/auction

Author: snu-BuMinSeong

.github/workflows/publish-ghcr.yml

@@ -105,6 +105,7 @@ jobs:
 
             # 서비스 갱신
             SERVICE_NAME="api_$TARGET"
+            docker system prune -af
             docker compose pull $SERVICE_NAME
             docker compose run --rm $SERVICE_NAME alembic upgrade head
             docker compose up -d $SERVICE_NAME

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "makefile.configureOnOpen": false
+}

carrot/api.py

@@ -6,16 +6,16 @@
 from carrot.app.product.router import product_router
 from carrot.app.region.router import region_router
 from carrot.app.pay.router import pay_router
-# from carrot.app.image.router import image_router
-# from carrot.app.chat.websocket import chat_ws_router
+from carrot.app.image.router import image_router
+from carrot.app.auction.router import auction_router
 
 api_router = APIRouter()
 
 api_router.include_router(auth_router, prefix="/auth", tags=["auth"])
 api_router.include_router(user_router, prefix="/user", tags=["user"])
 api_router.include_router(chat_router, prefix="/chat", tags=["chat"])
 api_router.include_router(product_router, prefix="/product", tags=["product"])
-# api_router.include_router(image_router, prefix="/image", tags=["image"])
+api_router.include_router(image_router, prefix="/image", tags=["image"])
 api_router.include_router(region_router, prefix="/region", tags=["region"])
 api_router.include_router(pay_router, prefix="/pay", tags=["pay"])
-# api_router.include_router(chat_ws_router, prefix="/ws", tags=["chat"])
+api_router.include_router(auction_router, prefix="/auction", tags=["auction"])

carrot/app/auction/exceptions.py

@@ -0,0 +1,27 @@
+from carrot.common.exceptions import CarrotException
+from fastapi import status
+
+
+class AuctionAlreadyExistsError(CarrotException):
+    def __init__(self) -> None:
+        super().__init__(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            error_code="AUC_001",
+            error_msg="Active auction already exists for this product.",
+        )
+
+class AuctionNotFoundError(CarrotException):
+    def __init__(self) -> None:
+        super().__init__(
+            status_code=status.HTTP_404_NOT_FOUND,
+            error_code="AUC_002",
+            error_msg="Auction not found.",
+        )
+
+class NotAllowedActionError(CarrotException):
+    def __init__(self) -> None:
+        super().__init__(
+            status_code=status.HTTP_403_FORBIDDEN,
+            error_code="AUC_003",
+            error_msg="Action not allowed on this auction.",
+        )

carrot/app/auction/models.py

@@ -0,0 +1,58 @@
+import uuid
+from datetime import datetime
+from enum import Enum
+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 carrot.db.common import Base
+
+if TYPE_CHECKING:
+    from carrot.app.product.models import Product
+    from carrot.app.user.models import User
+
+class AuctionStatus(str, Enum):
+    ACTIVE = "active"
+    FINISHED = "finished"
+    FAILED = "failed"
+    CANCELED = "canceled"
+
+class Auction(Base):
+    __tablename__ = "auction"
+
+    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, index=True)
+
+    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)      # 경매 종료 시간
+    bid_count: Mapped[int] = mapped_column(Integer, default=0)              # 입찰 횟수
+    status: Mapped[AuctionStatus] = mapped_column(String(20), default=AuctionStatus.ACTIVE)  # 경매 상태
+
+    product: Mapped["Product"] = relationship("Product", back_populates="auction")
+    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)
+    
+    @property
+    def owner_id(self):
+        return self.product.owner_id
+
+class Bid(Base):
+    __tablename__ = "bid"
+
+    id: Mapped[str] = mapped_column(String(36), primary_key=True, index=True, default=lambda: str(uuid.uuid4()))
+    auction_id: Mapped[str] = mapped_column(String(36), ForeignKey("auction.id", ondelete="CASCADE"), nullable=False, index=True)
+    bidder_id: Mapped[str] = mapped_column(String(36), ForeignKey("user.id", ondelete="CASCADE"), nullable=False, index=True)
+
+    bid_price: Mapped[int] = mapped_column(Integer, nullable=False)         # 입찰가
+    bid_at: Mapped[datetime] = mapped_column(DateTime, default=func.now())  # 입찰 시간
+
+    auction: Mapped["Auction"] = relationship("Auction", back_populates="bids")
+    bidder: Mapped["User"] = relationship("User")

carrot/app/auction/repositories.py

@@ -0,0 +1,115 @@
+from typing import Annotated, List, Optional
+
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select, update, func
+from sqlalchemy.orm import selectinload, joinedload, contains_eager
+from datetime import datetime
+from fastapi import Depends
+
+from carrot.app.auction.models import Auction, Bid, AuctionStatus
+from carrot.app.product.models import Product
+from carrot.db.connection import get_db_session
+
+from carrot.app.auction.exceptions import (
+    AuctionAlreadyExistsError,
+    AuctionNotFoundError,
+    NotAllowedActionError
+)
+
+class AuctionRepository:
+    def __init__(self, session: AsyncSession) -> None:
+        self.session = session
+
+
+    async def create_auction(self, product: Product, auction: Auction) -> Auction:
+        self.session.add(product)
+        await self.session.flush()  # Ensure product ID is generated
+
+        auction.product_id = product.id
+        self.session.add(auction)
+        
+        await self.session.commit()
+        await self.session.refresh(auction, attribute_names=["product"])
+        return auction
+    
+    async def get_auction_by_id(self, auction_id: str) -> Optional[Auction]:
+        # 1. 쿼리 작성 (bids 로딩 제거)
+        stmt = (
+            select(Auction)
+            .where(Auction.id == auction_id)
+            .options(joinedload(Auction.product))  # 상품 정보는 보통 같이 필요하니까요!
+        )
+        
+        result = await self.session.execute(stmt)
+        
+        # 2. 결과 추출
+        # 이제 1:N 조인이 없으므로 .unique()가 없어도 에러는 안 나지만, 
+        # 관습적으로 넣어두거나 scalar_one_or_none()으로 안전하게 받습니다.
+        auction = result.scalar_one_or_none()
+
+        if not auction:
+            raise AuctionNotFoundError()
+
+        return auction
+
+    async def get_active_auctions(
+            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))
+        )
+
+        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())
+
+        result = await self.session.execute(stmt)
+        return result.scalars().all()
+
+    async def delete_auction(self, auction: Auction) -> None:
+        await self.session.delete(auction)
+        await self.session.commit()
+
+    async def update_auction(self, auction: Auction) -> Auction:
+        merged = await self.session.merge(auction)
+        await self.session.commit()
+        return merged
+    
+    async def update_auction_without_commit(self, auction: Auction) -> Auction:
+        merged = await self.session.merge(auction)
+        return merged
+    
+    async def add_bid_without_commit(self, bid: Bid) -> Bid:
+        self.session.add(bid)
+        return bid
+
+    async def place_bid(self, bid: Bid) -> Bid:
+        self.session.add(bid)
+        await self.session.commit()
+        await self.session.refresh(bid)
+        return bid
+
+    async def update_bid(self, bid: Bid) -> Bid:
+        merged = await self.session.merge(bid)
+        await self.session.commit()
+        await self.session.refresh(merged)
+        return merged
+
+    async def gets_user_bids(self, user_id: str) -> List[Bid]:
+        stmt = (
+            select(Bid)
+            .where(Bid.bidder_id == user_id)
+            .options(joinedload(Bid.auction).joinedload(Auction.product))
+        )
+        result = await self.session.execute(stmt)
+        return result.scalars().all()
+
+    

carrot/app/auction/router.py

@@ -0,0 +1,68 @@
+from fastapi import APIRouter, Depends, HTTPException, Query
+from sqlalchemy.ext.asyncio import AsyncSession
+from typing import List, Optional, Annotated
+
+from carrot.db.connection import get_db_session
+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.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)
+
+# 2. 경매 목록 조회 (카테고리, 지역 필터링)
+@auction_router.get("/", response_model=List[AuctionResponse])
+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]:
+    
+    auctions = await service.list_auctions(category_id, region_id)
+    return 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)
+
+# 4. 입찰하기
+@auction_router.post("/{auction_id}/bids", response_model=BidResponse)
+async def place_bid(
+    auction_id: str,
+    bid_data: BidCreate,
+    bidder: Annotated[User, Depends(login_with_header)],
+    service: Annotated[AuctionService, Depends(AuctionService.create)],
+) -> BidResponse:
+
+    bid = await service.place_bid(
+        auction_id=auction_id,
+        bidder_id=bidder.id,
+        bid_price=bid_data.bid_price
+    )
+
+    return BidResponse.model_validate(bid)

carrot/app/auction/schemas.py

@@ -0,0 +1,59 @@
+from pydantic import BaseModel, Field, field_validator
+from datetime import datetime, timezone
+from typing import List, Optional
+from enum import Enum
+
+from carrot.app.product.schemas import ProductResponse
+
+from sqlalchemy import func
+
+# 경매 상태 Enum (모델과 맞춤)
+class AuctionStatus(str, Enum):
+    ACTIVE = "active"
+    FINISHED = "finished"
+    FAILED = "failed"
+    CANCELED = "canceled"
+
+class AuctionCreate(BaseModel):
+    starting_price: int = Field(..., gt=0, description="경매 시작 가격")
+    end_at: datetime = Field(..., description="경매 종료 시간")
+
+    @field_validator("end_at")
+    @classmethod  # Pydantic V2에서는 classmethod로 정의하는 것이 정석입니다.
+    def validate_end_at(cls, v: datetime) -> datetime:
+        # v에 시간대 정보가 없다면 UTC로 가정
+        if v.tzinfo is None:
+            v = v.replace(tzinfo=timezone.utc)
+            
+        # 현재 시간을 UTC 기준으로 가져옴
+        current_time = datetime.now(timezone.utc)
+        
+        if v <= current_time:
+            raise ValueError("경매 종료 시간은 현재 시간보다 미래여야 합니다.")
+        return v
+    
+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
+
+class BidCreate(BaseModel):
+    bid_price: int = Field(..., gt=0)
+
+class BidResponse(BaseModel):
+    id: str
+    auction_id: str
+    bidder_id: str
+    bid_price: int
+    bid_at: datetime
+    
+    class Config:
+        from_attributes = True