[feature] notice 관련 기능 구현

src/main/kotlin/com/mjucow/eatda/domain/notice/entity/Notice.kt

@@ -0,0 +1,13 @@
+package com.mjucow.eatda.domain.notice.entity
+
+import com.mjucow.eatda.domain.common.BaseEntity
+import jakarta.persistence.Column
+import jakarta.persistence.Entity
+import jakarta.persistence.Table
+
+@Entity
+@Table(name = "notice")
+class Notice(
+    @Column(nullable = false) var title: String,
+    @Column(nullable = false) var content: String,
+) : BaseEntity()

src/main/kotlin/com/mjucow/eatda/domain/notice/service/command/NoticeCommandService.kt

@@ -0,0 +1,39 @@
+package com.mjucow.eatda.domain.notice.service.command
+
+import com.mjucow.eatda.domain.notice.entity.Notice
+import com.mjucow.eatda.domain.notice.service.command.dto.CreateNoticeCommand
+import com.mjucow.eatda.domain.notice.service.command.dto.UpdateNoticeCommand
+import com.mjucow.eatda.persistence.notice.NoticeRepository
+import jakarta.persistence.EntityNotFoundException
+import org.springframework.data.repository.findByIdOrNull
+import org.springframework.stereotype.Service
+import org.springframework.transaction.annotation.Transactional
+
+@Transactional
+@Service
+class NoticeCommandService(
+    private val repository: NoticeRepository,
+) {
+    fun create(request: CreateNoticeCommand): Long {
+        return repository.save(Notice(request.title, request.content)).id
+    }
+
+    @Throws(EntityNotFoundException::class)
+    fun update(noticeId: Long, request: UpdateNoticeCommand) {
+        val notice = repository.findByIdOrNull(noticeId)
+            ?: throw EntityNotFoundException("공지사항이 존재하지 않습니다.")
+        val (newTitle, newContent) = request
+        notice.let {
+            if (newTitle != null) it.title = newTitle
+            if (newContent != null) it.content = newContent
+        }
+
+        repository.save(notice)
+    }
+
+    fun deleteById(noticeId: Long) {
+        val notice = repository.findByIdOrNull(noticeId) ?: throw IllegalArgumentException()
+
+        repository.delete(notice)
+    }
+}

src/main/kotlin/com/mjucow/eatda/domain/notice/service/command/dto/CreateNoticeCommand.kt

@@ -0,0 +1,10 @@
+package com.mjucow.eatda.domain.notice.service.command.dto
+
+import jakarta.validation.constraints.NotBlank
+
+data class CreateNoticeCommand(
+    @field:NotBlank(message = "공지사항 제목은 필수 입력 값입니다.")
+    val title: String,
+    @field:NotBlank(message = "공지사항 내용은 필수 입력 값입니다.")
+    val content: String,
+)

src/main/kotlin/com/mjucow/eatda/domain/notice/service/command/dto/UpdateNoticeCommand.kt

@@ -0,0 +1,6 @@
+package com.mjucow.eatda.domain.notice.service.command.dto
+
+data class UpdateNoticeCommand(
+    val title: String?,
+    val content: String?,
+)

src/main/kotlin/com/mjucow/eatda/domain/notice/service/query/NoticeQueryService.kt

@@ -0,0 +1,27 @@
+package com.mjucow.eatda.domain.notice.service.query
+
+import com.mjucow.eatda.domain.notice.service.query.dto.NoticeDto
+import com.mjucow.eatda.domain.notice.service.query.dto.Notices
+import com.mjucow.eatda.persistence.notice.NoticeRepository
+import jakarta.persistence.EntityNotFoundException
+import org.springframework.data.repository.findByIdOrNull
+import org.springframework.stereotype.Service
+import org.springframework.transaction.annotation.Transactional
+
+@Transactional
+@Service
+class NoticeQueryService(
+    private val repository: NoticeRepository,
+) {
+    fun findAll(): Notices {
+        return Notices(repository.findAllByOrderByCreatedAtDesc().map(NoticeDto::from))
+    }
+
+    @Throws(EntityNotFoundException::class)
+    fun findById(noticeId: Long): NoticeDto {
+        val notice = repository.findByIdOrNull(noticeId)
+            ?: throw EntityNotFoundException("공지사항이 존재하지 않습니다.")
+
+        return NoticeDto.from(notice)
+    }
+}

src/main/kotlin/com/mjucow/eatda/domain/notice/service/query/dto/NoticeDto.kt

@@ -0,0 +1,22 @@
+package com.mjucow.eatda.domain.notice.service.query.dto
+
+import com.mjucow.eatda.domain.notice.entity.Notice
+import java.time.Instant
+
+data class NoticeDto(
+    val id: Long,
+    val title: String,
+    val content: String,
+    val createdAt: Instant,
+) {
+    companion object {
+        fun from(domain: Notice): NoticeDto {
+            return NoticeDto(
+                domain.id,
+                domain.title,
+                domain.content,
+                domain.createdAt
+            )
+        }
+    }
+}

src/main/kotlin/com/mjucow/eatda/domain/notice/service/query/dto/Notices.kt

@@ -0,0 +1,5 @@
+package com.mjucow.eatda.domain.notice.service.query.dto
+
+data class Notices(
+    val noticeList: List<NoticeDto>,
+) : ArrayList<NoticeDto>(noticeList)

src/main/kotlin/com/mjucow/eatda/persistence/notice/NoticeRepository.kt

@@ -0,0 +1,8 @@
+package com.mjucow.eatda.persistence.notice
+
+import com.mjucow.eatda.domain.notice.entity.Notice
+import org.springframework.data.jpa.repository.JpaRepository
+
+interface NoticeRepository : JpaRepository<Notice, Long> {
+    fun findAllByOrderByCreatedAtDesc(): List<Notice>
+}

src/main/kotlin/com/mjucow/eatda/presentation/common/GlobalExceptionHandler.kt

@@ -2,11 +2,18 @@ package com.mjucow.eatda.presentation.common
 
 import jakarta.persistence.EntityNotFoundException
 import org.springframework.http.HttpStatus
+import org.springframework.web.bind.MethodArgumentNotValidException
 import org.springframework.web.bind.annotation.ExceptionHandler
 import org.springframework.web.bind.annotation.ResponseStatus
 
 @GlobalControllerAdvice
 class GlobalExceptionHandler {
+    @ResponseStatus(HttpStatus.BAD_REQUEST)
+    @ExceptionHandler(MethodArgumentNotValidException::class)
+    fun handleMethodArgumentNotValidException(exception: MethodArgumentNotValidException): ApiResponse<Unit> {
+        return ApiResponse.error(exception.bindingResult.allErrors.joinToString(" ") { it.defaultMessage.toString() })
+    }
+
     @ResponseStatus(HttpStatus.BAD_REQUEST)
     @ExceptionHandler(IllegalArgumentException::class)
     fun handleIllegalArgumentException(exception: IllegalArgumentException): ApiResponse<Unit> {

src/main/kotlin/com/mjucow/eatda/presentation/notice/controller/NoticeController.kt

@@ -0,0 +1,67 @@
+package com.mjucow.eatda.presentation.notice.controller
+
+import com.mjucow.eatda.domain.notice.service.command.NoticeCommandService
+import com.mjucow.eatda.domain.notice.service.command.dto.CreateNoticeCommand
+import com.mjucow.eatda.domain.notice.service.command.dto.UpdateNoticeCommand
+import com.mjucow.eatda.domain.notice.service.query.NoticeQueryService
+import com.mjucow.eatda.domain.notice.service.query.dto.NoticeDto
+import com.mjucow.eatda.domain.notice.service.query.dto.Notices
+import com.mjucow.eatda.presentation.common.ApiResponse
+import jakarta.validation.Valid
+import org.springframework.http.HttpStatus
+import org.springframework.web.bind.annotation.DeleteMapping
+import org.springframework.web.bind.annotation.GetMapping
+import org.springframework.web.bind.annotation.PatchMapping
+import org.springframework.web.bind.annotation.PathVariable
+import org.springframework.web.bind.annotation.PostMapping
+import org.springframework.web.bind.annotation.RequestBody
+import org.springframework.web.bind.annotation.RequestMapping
+import org.springframework.web.bind.annotation.ResponseStatus
+import org.springframework.web.bind.annotation.RestController
+
+@RequestMapping("/api/v1/notices")
+@RestController
+class NoticeController(
+    private val noticeQueryService: NoticeQueryService,
+    private val noticeCommandService: NoticeCommandService,
+) {
+    @PostMapping
+    @ResponseStatus(HttpStatus.CREATED)
+    fun create(
+        @RequestBody @Valid
+        command: CreateNoticeCommand,
+    ): ApiResponse<Long> {
+        return ApiResponse.success(noticeCommandService.create(command))
+    }
+
+    @GetMapping
+    @ResponseStatus(HttpStatus.OK)
+    fun findAll(): ApiResponse<Notices> {
+        return ApiResponse.success(noticeQueryService.findAll())
+    }
+
+    @GetMapping("/{noticeId}")
+    @ResponseStatus(HttpStatus.OK)
+    fun findById(
+        @PathVariable("noticeId") noticeId: Long,
+    ): ApiResponse<NoticeDto> {
+        return ApiResponse.success(noticeQueryService.findById(noticeId))
+    }
+
+    @PatchMapping("/{noticeId}")
+    @ResponseStatus(HttpStatus.OK)
+    fun update(
+        @PathVariable("noticeId") noticeId: Long,
+        @RequestBody command: UpdateNoticeCommand,
+    ) {
+        noticeCommandService.update(noticeId, command)
+    }
+
+    @DeleteMapping("/{noticeId}")
+    @ResponseStatus(HttpStatus.NO_CONTENT)
+    fun deleteById(
+        @PathVariable("noticeId") noticeId: Long,
+    ) {
+        noticeCommandService.deleteById(noticeId)
+    }
+}

src/main/kotlin/com/mjucow/eatda/presentation/store/category/CategoryController.kt

@@ -34,6 +34,7 @@ class CategoryController(
     @ResponseStatus(HttpStatus.CREATED)
     fun create(@RequestBody command: CreateCommand): ApiResponse<Long> {
         val id = categoryCommandService.create(command)
+
         return ApiResponse.success(id)
     }
 
@@ -57,4 +58,4 @@ class CategoryController(
     ) {
         categoryCommandService.updateName(id, command)
     }
-}
+}