Merge branch 'feat/14-notice-crud'

Author: KIMB0B

app/main.py

@@ -14,6 +14,7 @@
 from app.modules.member.router import router as member_router
 from app.modules.project.router import router as project_router
 from app.modules.work.router import work_router, project_work_router
+from app.modules.notice.router import router as notice_router
 from app.modules.skill.models import Skill
 from app.modules.member.models import Member
 from app.modules.favorite.models import Favorite
@@ -47,6 +48,7 @@ def create_app() -> FastAPI:
     app.include_router(project_router)
     app.include_router(work_router)
     app.include_router(project_work_router)
+    app.include_router(notice_router)
 
     # Static Files
     app.mount("/static", StaticFiles(directory="app/static"), name="static")

app/modules/notice/dependencies.py

@@ -0,0 +1,15 @@
+from typing import Annotated
+
+from fastapi import Depends
+
+from app.core.database import DbSessionDep
+from app.modules.notice.repository import NoticeRepository
+from app.modules.notice.service import NoticeService
+
+
+def get_notice_service(session: DbSessionDep) -> NoticeService:
+    repository = NoticeRepository(session)
+    return NoticeService(session, repository)
+
+
+NoticeServiceDep = Annotated[NoticeService, Depends(get_notice_service)]

app/modules/notice/repository.py

@@ -0,0 +1,90 @@
+from datetime import datetime, timezone
+from uuid import UUID
+
+from sqlalchemy import func, or_
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlmodel import select
+
+from app.modules.notice.models import Notice
+
+
+class NoticeRepository:
+    def __init__(self, session: AsyncSession):
+        self.session = session
+
+    async def get_by_id(self, notice_id: UUID, *, include_deleted: bool = False) -> Notice | None:
+        query = select(Notice).where(Notice.id == notice_id)
+        if not include_deleted:
+            query = query.where(Notice.is_deleted == False)
+        return await self.session.scalar(query)
+
+    async def list(
+            self,
+            *,
+            keyword: str | None = None,
+            project_id: UUID | None = None,
+            offset: int = 0,
+            limit: int = 100,
+            include_deleted: bool = False,
+    ) -> list[Notice]:
+        stmt = select(Notice)
+
+        if keyword:
+            stmt = stmt.where(
+                or_(
+                    Notice.title.ilike(f"%{keyword}%"),
+                    Notice.detail.ilike(f"%{keyword}%")
+                )
+            )
+
+        if project_id:
+            stmt = stmt.where(Notice.project_id == project_id)
+
+        if not include_deleted:
+            stmt = stmt.where(Notice.is_deleted == False)
+
+        stmt = stmt.order_by(Notice.created_at.desc()).offset(offset).limit(limit)
+        return (await self.session.scalars(stmt)).all()
+
+    async def count(
+            self,
+            *,
+            keyword: str | None = None,
+            project_id: UUID | None = None,
+            include_deleted: bool = False
+    ) -> int:
+        stmt = select(func.count()).select_from(Notice)
+
+        if keyword:
+            stmt = stmt.where(
+                or_(
+                    Notice.title.ilike(f"%{keyword}%"),
+                    Notice.detail.ilike(f"%{keyword}%")
+                )
+            )
+
+        if project_id:
+            stmt = stmt.where(Notice.project_id == project_id)
+
+        if not include_deleted:
+            stmt = stmt.where(Notice.is_deleted == False)
+
+        return int(await self.session.scalar(stmt) or 0)
+
+    async def save(self, notice: Notice) -> Notice:
+        self.session.add(notice)
+        await self.session.flush()
+        await self.session.refresh(notice)
+        return notice
+
+    async def soft_delete(self, notice: Notice) -> Notice:
+        notice.is_deleted = True
+        notice.deleted_at = datetime.now(timezone.utc)
+
+        await self.session.flush()
+        await self.session.refresh(notice)
+        return notice
+
+    async def hard_delete(self, notice: Notice) -> None:
+        await self.session.delete(notice)
+        await self.session.flush()

app/modules/notice/router.py

@@ -0,0 +1,174 @@
+from typing import Annotated
+from uuid import UUID
+
+from fastapi import APIRouter, Query, Path
+from starlette import status
+
+from app.modules.project.dependencies import ProjectParticipantDep, ProjectLeaderDep
+from app.modules.notice.dependencies import NoticeServiceDep
+from app.modules.notice.schemas import NoticeOut, NoticeCreateIn, NoticeUpdateIn
+from app.shared.schemas import ApiResponse, PageOut
+
+router = APIRouter(prefix="/project/{project_id}/notice", tags=["Notice"])
+
+@router.get(
+    path="",
+    response_model=ApiResponse[PageOut[NoticeOut]],
+    summary="프로젝트 공지 목록 조회",
+    description="해당 프로젝트의 공지 목록을 조회합니다. 프로젝트 참여자만 가능합니다.",
+)
+async def list_project_notices(
+        project: ProjectParticipantDep,
+        service: NoticeServiceDep,
+        keyword: Annotated[str | None, Query(description="검색 키워드(제목, 상세내용)")] = None,
+        page: Annotated[int, Query(ge=1, description="페이지 번호")] = 1,
+        size: Annotated[int, Query(ge=1, le=100, description="페이지 크기")] = 50,
+        include_deleted: Annotated[bool, Query(description="soft delete된 데이터 포함 여부")] = False,
+):
+    result = await service.list(
+        keyword=keyword,
+        project_id=project.id,
+        page=page,
+        size=size,
+        include_deleted=include_deleted,
+    )
+
+    return ApiResponse.success(
+        code="PROJECT_NOTICE_LIST_FETCHED",
+        message="프로젝트 공지 목록 조회 성공",
+        data=PageOut[NoticeOut](
+            items=[NoticeOut.model_validate(item) for item in result["items"]],
+            page=result["page"],
+            size=result["size"],
+            total=result["total"],
+        )
+    )
+
+@router.post(
+    path="",
+    response_model=ApiResponse[NoticeOut],
+    status_code=status.HTTP_201_CREATED,
+    summary="공지 생성",
+    description="프로젝트 내에 공지를 생성합니다. 프로젝트 리더만 가능합니다.",
+)
+async def create_notice(
+        project: ProjectLeaderDep,
+        data: NoticeCreateIn,
+        service: NoticeServiceDep,
+):
+    # 입력된 project_id가 경로의 project_id와 일치하는지 확인 (보안 강화)
+    if data.project_id != project.id:
+        from app.core.exceptions import AppError
+        raise AppError.bad_request("경로의 프로젝트 ID와 요청 바디의 프로젝트 ID가 일치하지 않습니다.")
+
+    created = await service.create(data=data)
+    return ApiResponse.success(
+        code="NOTICE_CREATED",
+        message="공지 생성 성공",
+        data=NoticeOut.model_validate(created)
+    )
+
+@router.get(
+    path="/{notice_id}",
+    response_model=ApiResponse[NoticeOut],
+    summary="공지 단건 조회",
+    description="프로젝트 내의 특정 공지를 조회합니다.",
+)
+async def get_project_notice(
+        project: ProjectParticipantDep,
+        service: NoticeServiceDep,
+        notice_id: Annotated[UUID, Path(..., description="조회할 notice의 id")],
+        include_deleted: Annotated[bool, Query(description="soft delete된 데이터 포함 여부")] = False,
+):
+    notice = await service.get(notice_id, include_deleted=include_deleted)
+    
+    # 해당 공지가 해당 프로젝트의 것인지 확인
+    if notice.project_id != project.id:
+        from app.core.exceptions import AppError
+        raise AppError.not_found("해당 프로젝트에서 해당 공지를 찾을 수 없습니다.")
+        
+    return ApiResponse.success(
+        code="NOTICE_FETCHED",
+        message="공지 조회 성공",
+        data=NoticeOut.model_validate(notice)
+    )
+
+@router.patch(
+    path="/{notice_id}",
+    response_model=ApiResponse[NoticeOut],
+    summary="공지 정보 수정",
+    description="기존 공지를 수정합니다. 프로젝트 리더만 가능합니다."
+)
+async def update_project_notice(
+        project: ProjectLeaderDep,
+        service: NoticeServiceDep,
+        notice_id: Annotated[UUID, Path(description="수정할 notice의 ID")],
+        data: NoticeUpdateIn,
+):
+    # 해당 공지가 해당 프로젝트의 것인지 확인
+    notice = await service.get(notice_id)
+    if notice.project_id != project.id:
+        from app.core.exceptions import AppError
+        raise AppError.not_found("해당 프로젝트에서 해당 공지를 찾을 수 없습니다.")
+
+    updated = await service.update(
+        target_notice_id=notice_id,
+        data=data
+    )
+    return ApiResponse.success(
+        code="NOTICE_UPDATED",
+        message="공지 수정 성공",
+        data=NoticeOut.model_validate(updated),
+    )
+
+@router.delete(
+    path="/{notice_id}",
+    response_model=ApiResponse[None],
+    summary="공지 삭제",
+    description="기존 공지를 삭제합니다. 프로젝트 리더만 가능합니다.",
+)
+async def delete_project_notice(
+        project: ProjectLeaderDep,
+        service: NoticeServiceDep,
+        notice_id: Annotated[UUID, Path(description="삭제할 공지의 ID")],
+        hard: Annotated[bool, Query(description="true면 hard delete, false면 soft delete")] = False,
+):
+    # 해당 공지가 해당 프로젝트의 것인지 확인
+    notice = await service.get(notice_id, include_deleted=True)
+    if notice.project_id != project.id:
+        from app.core.exceptions import AppError
+        raise AppError.not_found("해당 프로젝트에서 해당 공지를 찾을 수 없습니다.")
+
+    await service.delete(
+        target_notice_id=notice_id,
+        hard=hard
+    )
+    return ApiResponse.success(
+        code="NOTICE_DELETED",
+        message="공지 삭제 성공",
+        data=None
+    )
+
+@router.patch(
+    path="/{notice_id}/restore",
+    response_model=ApiResponse[NoticeOut],
+    summary="공지 복구",
+    description="soft delete 된 공지를 복구합니다. 프로젝트 리더만 가능합니다."
+)
+async def restore_project_notice(
+        project: ProjectLeaderDep,
+        service: NoticeServiceDep,
+        notice_id: Annotated[UUID, Path(description="복구할 notice의 ID")],
+):
+    # 해당 공지가 해당 프로젝트의 것인지 확인
+    notice = await service.get(notice_id, include_deleted=True)
+    if notice.project_id != project.id:
+        from app.core.exceptions import AppError
+        raise AppError.not_found("해당 프로젝트에서 해당 공지를 찾을 수 없습니다.")
+
+    restored = await service.restore(notice_id)
+    return ApiResponse.success(
+        code="NOTICE_RESTORED",
+        message="공지 복구 성공",
+        data=NoticeOut.model_validate(restored)
+    )

app/modules/notice/schemas.py

@@ -0,0 +1,55 @@
+from datetime import datetime
+from uuid import UUID
+
+from sqlmodel import SQLModel, Field
+
+
+class NoticeCreateIn(SQLModel):
+    project_id: UUID = Field(description="프로젝트 고유키")
+    title: str = Field(description="공지 제목")
+    detail: str = Field(description="공지 상세 내용")
+
+    model_config = {
+        "json_schema_extra": {
+            "example": {
+                "project_id": "3e1672cf-8d99-4b1c-9b5e-9c3ece11b089",
+                "title": "공지사항 제목",
+                "detail": "공지사항 상세 내용입니다."
+            }
+        }
+    }
+
+
+class NoticeUpdateIn(SQLModel):
+    title: str | None = Field(default=None, description="공지 제목")
+    detail: str | None = Field(default=None, description="공지 상세 내용")
+
+    model_config = {
+        "json_schema_extra": {
+            "example": {
+                "title": "수정된 공지 제목",
+                "detail": "수정된 공지 상세 내용"
+            }
+        }
+    }
+
+
+class NoticeOut(SQLModel):
+    id: UUID = Field(description="공지 ID")
+    project_id: UUID = Field(description="프로젝트 고유키")
+    title: str = Field(description="공지 제목")
+    detail: str = Field(description="공지 상세 내용")
+    created_at: datetime = Field(description="생성 일시")
+    updated_at: datetime | None = Field(default=None, description="수정 일시")
+
+    model_config = {
+        "json_schema_extra": {
+            "example": {
+                "id": "5f1672kf-8d99-4b1c-9b5e-9c3ece11b089",
+                "project_id": "3e1672cf-8d99-4b1c-9b5e-9c3ece11b089",
+                "title": "공지사항 제목",
+                "detail": "공지사항 상세 내용입니다.",
+                "created_at": "2026-04-27T10:00:00"
+            }
+        }
+    }