[feature] notice 관련 기능 구현

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

@@ -0,0 +1,36 @@
+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() : BaseEntity() {
+    constructor(
+        title: String,
+        content: String,
+    ) : this() {
+        this.title = title
+        this.content = content
+    }
+
+    @Column(nullable = false)
+    var title: String = ""
+        set(value) {
+            validateValue(value)
+            field = value
+        }
+
+    @Column(nullable = false)
+    var content: String = ""
+        set(value) {
+            validateValue(value)
+            field = value
+        }
+
+    private fun validateValue(value: String) {
+        require(value.isNotBlank())
+    }
+}

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

@@ -0,0 +1,35 @@
+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 org.springframework.data.repository.findByIdOrNull
+import org.springframework.stereotype.Service
+import org.springframework.transaction.annotation.Transactional
+
+@Service
+@Transactional
+class NoticeCommandService(
+    private val repository: NoticeRepository,
+) {
+    fun create(request: CreateNoticeCommand): Long {
+        return repository.save(Notice(request.title, request.content)).id
+    }
+
+    fun update(noticeId: Long, command: UpdateNoticeCommand) {
+        val (newTitle, newContent) = command
+        val notice = repository.findByIdOrNull(noticeId)?.apply {
+            title = newTitle
+            content = newContent
+        } ?: throw IllegalArgumentException()
+
+        repository.save(notice)
+    }
+
+    fun deleteById(noticeId: Long) {
+        val notice = repository.findByIdOrNull(noticeId) ?: return
+
+        repository.delete(notice)
+    }
+}

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

@@ -0,0 +1,6 @@
+package com.mjucow.eatda.domain.notice.service.command.dto
+
+data class CreateNoticeCommand(
+    val title: String,
+    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
+
+
+@Service
+@Transactional(readOnly = true)
+class NoticeQueryService(
+    private val repository: NoticeRepository,
+) {
+    fun findAll(): Notices {
+        return Notices(repository.findAllByOrderByIdDesc().map(NoticeDto::from))
+    }
+
+    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/domain/store/entity/Category.kt

@@ -23,6 +23,7 @@ class Category() : BaseEntity() {
     private fun validateName(name: String) {
         require(name.isNotBlank() && name.trim().length <= MAX_NAME_LENGTH)
     }
+
     companion object {
         const val MAX_NAME_LENGTH = 31
     }

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 findAllByOrderByIdDesc(): List<Notice>
+}

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

@@ -0,0 +1,65 @@
+package com.mjucow.eatda.presentation.notice
+
+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 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 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)
     }
 

src/main/resources/application.yml

@@ -51,4 +51,4 @@ spring:
       connection-timeout: 1100
       keepalive-time: 30000
       validation-timeout: 1000
-      max-lifetime: 600000
+      max-lifetime: 600000

src/main/resources/db/changelog/230925-init.sql

@@ -9,4 +9,4 @@ CREATE TABLE category (
 );
 
 ALTER TABLE category ADD CONSTRAINT PK_CATEGORY PRIMARY KEY (id);
-CREATE UNIQUE INDEX idx_category_name ON category(name);
+CREATE UNIQUE INDEX idx_category_name ON category(name);

src/main/resources/db/changelog/231004-notioce.sql

@@ -0,0 +1,11 @@
+-- liquibase formatted sql
+
+-- changeset liquibase:2
+CREATE TABLE notice
+(
+    id         bigserial   NOT NULL PRIMARY KEY,
+    title      varchar(31) NOT NULL,
+    content    text        NOT NULL,
+    created_at timestamp   NOT NULL DEFAULT NOW(),
+    updated_at timestamp   NOT NULL
+);

src/test/kotlin/com/mjucow/eatda/domain/notice/entity/NoticeTest.kt

@@ -0,0 +1,79 @@
+package com.mjucow.eatda.domain.notice.entity
+
+import org.assertj.core.api.Assertions
+import org.junit.jupiter.api.DisplayName
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.EmptySource
+
+class NoticeTest {
+    @DisplayName("제목이 빈 값일 경우 예외를 반환한다")
+    @ParameterizedTest
+    @EmptySource
+    fun task1(title: String) {
+        // given
+        val content = "content"
+
+        // when
+        val throwable = Assertions.catchThrowable { Notice(title, content) }
+
+        // then
+        Assertions.assertThat(throwable).isInstanceOf(RuntimeException::class.java)
+    }
+
+    @DisplayName("내용이 빈 값일 경우 예외를 반환한다")
+    @ParameterizedTest
+    @EmptySource
+    fun task2(content: String) {
+        // given
+        val title = "title"
+
+        // when
+        val throwable = Assertions.catchThrowable { Notice(title, content) }
+
+        // then
+        Assertions.assertThat(throwable).isInstanceOf(RuntimeException::class.java)
+    }
+
+    @DisplayName("새로운 제목이 빈 값일 경우 예외를 반환한다")
+    @ParameterizedTest
+    @EmptySource
+    fun task3(newTitle: String) {
+        // given
+        val notice = Notice("title", "content")
+
+        // when
+        val throwable = Assertions.catchThrowable { notice.title = newTitle }
+
+        // then
+        Assertions.assertThat(throwable).isInstanceOf(RuntimeException::class.java)
+    }
+
+    @DisplayName("새로운 내용이 빈 값일 경우 예외를 반환한다")
+    @ParameterizedTest
+    @EmptySource
+    fun task4(newContent: String) {
+        // given
+        val notice = Notice("title", "content")
+
+        // when
+        val throwable = Assertions.catchThrowable { notice.content = newContent }
+
+        // then
+        Assertions.assertThat(throwable).isInstanceOf(RuntimeException::class.java)
+    }
+
+    @DisplayName("정상적인 경우 객체가 생성된다")
+    @Test
+    fun task5() {
+        // given
+        val title = "title"
+        val content = "content"
+
+        // when
+        val notice = Notice(title, content)
+
+        // then
+        Assertions.assertThat(notice).isNotNull
+    }
+}