[Feat/#228] 아티클 목록 조회(무한스크롤) API 추가

api-repo/src/main/kotlin/com/few/api/repo/dao/article/ArticleDao.kt

@@ -6,6 +6,7 @@ import com.few.api.repo.dao.article.command.InsertFullArticleRecordCommand
 import com.few.api.repo.dao.article.query.SelectArticleRecordQuery
 import com.few.api.repo.dao.article.query.SelectWorkBookArticleRecordQuery
 import com.few.api.repo.dao.article.query.SelectWorkbookMappedArticleRecordsQuery
+import com.few.api.repo.dao.article.record.SelectArticleContentsRecord
 import com.few.api.repo.dao.article.record.SelectArticleRecord
 import com.few.api.repo.dao.article.record.SelectWorkBookArticleRecord
 import com.few.api.repo.dao.article.record.SelectWorkBookMappedArticleRecord
@@ -108,4 +109,15 @@ class ArticleDao(
 
         return mstId.getValue(ArticleMst.ARTICLE_MST.ID)
     }
+
+    fun selectArticleContents(articleIds: Set<Long>): List<SelectArticleContentsRecord> =
+        selectArticleContentsQuery(articleIds)
+            .fetchInto(SelectArticleContentsRecord::class.java)
+
+    fun selectArticleContentsQuery(articleIds: Set<Long>) = dslContext.select(
+        ArticleIfo.ARTICLE_IFO.ARTICLE_MST_ID.`as`(SelectArticleContentsRecord::articleId.name),
+        ArticleIfo.ARTICLE_IFO.CONTENT.`as`(SelectArticleContentsRecord::content.name)
+    ).from(ArticleIfo.ARTICLE_IFO)
+        .where(ArticleIfo.ARTICLE_IFO.ARTICLE_MST_ID.`in`(articleIds))
+        .and(ArticleIfo.ARTICLE_IFO.DELETED_AT.isNull)
 }

api-repo/src/main/kotlin/com/few/api/repo/dao/article/ArticleMainCardDao.kt

@@ -0,0 +1,116 @@
+package com.few.api.repo.dao.article
+
+import jooq.jooq_dsl.tables.ArticleMst.ARTICLE_MST
+import jooq.jooq_dsl.tables.MappingWorkbookArticle.MAPPING_WORKBOOK_ARTICLE
+import jooq.jooq_dsl.tables.Member.MEMBER
+import jooq.jooq_dsl.tables.Workbook.WORKBOOK
+import com.few.api.repo.dao.article.record.ArticleMainCardRecord
+import com.few.api.repo.dao.article.support.CommonJsonMapper
+import jooq.jooq_dsl.tables.ArticleMainCard.ARTICLE_MAIN_CARD
+import org.jooq.*
+import org.jooq.impl.DSL.*
+import org.springframework.stereotype.Repository
+import java.time.LocalDateTime
+
+@Repository
+class ArticleMainCardDao(
+    private val dslContext: DSLContext,
+    private val commonJsonMapper: CommonJsonMapper,
+) {
+
+    fun selectArticleMainCardsRecord(articleIds: Set<Long>): Set<ArticleMainCardRecord> {
+        return selectArticleMainCardsRecordQuery(articleIds)
+            .fetchInto(ArticleMainCardRecord::class.java)
+            .toSet()
+    }
+
+    private fun selectArticleMainCardsRecordQuery(articleIds: Set<Long>) = dslContext.select(
+        ARTICLE_MAIN_CARD.ID.`as`(ArticleMainCardRecord::articleId.name),
+        ARTICLE_MAIN_CARD.TITLE.`as`(ArticleMainCardRecord::articleTitle.name),
+        ARTICLE_MAIN_CARD.MAIN_IMAGE_URL.`as`(ArticleMainCardRecord::mainImageUrl.name),
+        ARTICLE_MAIN_CARD.CATEGORY_CD.`as`(ArticleMainCardRecord::categoryCd.name),
+        ARTICLE_MAIN_CARD.CREATED_AT.`as`(ArticleMainCardRecord::createdAt.name),
+        ARTICLE_MAIN_CARD.WRITER_ID.`as`(ArticleMainCardRecord::writerId.name),
+        ARTICLE_MAIN_CARD.WRITER_EMAIL.`as`(ArticleMainCardRecord::writerEmail.name),
+        jsonGetAttributeAsText(ARTICLE_MAIN_CARD.WRITER_DESCRIPTION, "name").`as`(ArticleMainCardRecord::writerName.name),
+        jsonGetAttribute(ARTICLE_MAIN_CARD.WRITER_DESCRIPTION, "url").`as`(ArticleMainCardRecord::writerImgUrl.name)
+    ).from(ARTICLE_MAIN_CARD)
+        .where(ARTICLE_MAIN_CARD.ID.`in`(articleIds))
+        .query
+
+    fun selectByArticleMstAndMemberAndMappingWorkbookArticleAndWorkbook(articleIds: Set<Long>): Set<ArticleMainCardRecord> {
+        return selectByArticleMstAndMemberAndMappingWorkbookArticleAndWorkbookQuery(articleIds)
+            .fetchInto(ArticleMainCardRecord::class.java)
+            .toSet()
+    }
+
+    private fun selectByArticleMstAndMemberAndMappingWorkbookArticleAndWorkbookQuery(articleIds: Set<Long>):
+        SelectQuery<Record9<Long, String, String, Byte, LocalDateTime, Long, String, String, JSON>> {
+        val a = ARTICLE_MST.`as`("a")
+        val m = MEMBER.`as`("m")
+        val mwa = MAPPING_WORKBOOK_ARTICLE.`as`("mwa")
+        val w = WORKBOOK.`as`("w")
+
+        return dslContext.select(
+            a.ID.`as`(ArticleMainCardRecord::articleId.name),
+            a.TITLE.`as`(ArticleMainCardRecord::articleTitle.name),
+            a.MAIN_IMAGE_URL.`as`(ArticleMainCardRecord::mainImageUrl.name),
+            a.CATEGORY_CD.`as`(ArticleMainCardRecord::categoryCd.name),
+            a.CREATED_AT.`as`(ArticleMainCardRecord::createdAt.name),
+            m.ID.`as`(ArticleMainCardRecord::writerId.name),
+            m.EMAIL.`as`(ArticleMainCardRecord::writerEmail.name),
+            jsonGetAttributeAsText(m.DESCRIPTION, "name").`as`(ArticleMainCardRecord::writerName.name),
+            jsonGetAttribute(m.DESCRIPTION, "url").`as`(ArticleMainCardRecord::writerImgUrl.name)
+        )
+            .from(a)
+            .join(m).on(a.MEMBER_ID.eq(m.ID)).and(a.DELETED_AT.isNull).and(m.DELETED_AT.isNull)
+            .leftJoin(mwa).on(a.ID.eq(mwa.ARTICLE_ID)).and(mwa.DELETED_AT.isNull)
+            .leftJoin(w).on(mwa.WORKBOOK_ID.eq(w.ID)).and(w.DELETED_AT.isNull)
+            .where(a.ID.`in`(articleIds))
+            .groupBy(a.ID)
+            .query
+    }
+
+    fun insertArticleMainCardsBulk(commands: Set<ArticleMainCardRecord>) {
+        dslContext.batch(
+            insertArticleMainCardsBulkQuery(commands)
+        ).execute()
+    }
+
+    fun insertArticleMainCardsBulkQuery(commands: Set<ArticleMainCardRecord>):
+        InsertValuesStep8<jooq.jooq_dsl.tables.records.ArticleMainCardRecord, Long, String, String, Byte, LocalDateTime, Long, String, JSON> {
+        val insertStep = dslContext.insertInto(
+            ARTICLE_MAIN_CARD,
+            ARTICLE_MAIN_CARD.ID,
+            ARTICLE_MAIN_CARD.TITLE,
+            ARTICLE_MAIN_CARD.MAIN_IMAGE_URL,
+            ARTICLE_MAIN_CARD.CATEGORY_CD,
+            ARTICLE_MAIN_CARD.CREATED_AT,
+            ARTICLE_MAIN_CARD.WRITER_ID,
+            ARTICLE_MAIN_CARD.WRITER_EMAIL,
+            ARTICLE_MAIN_CARD.WRITER_DESCRIPTION
+        )
+
+        for (command in commands) {
+            insertStep.values(
+                command.articleId,
+                command.articleTitle,
+                command.mainImageUrl.toString(),
+                command.categoryCd,
+                command.createdAt,
+                command.writerId,
+                command.writerEmail,
+                JSON.valueOf(
+                    commonJsonMapper.toJsonStr(
+                        mapOf(
+                            "name" to command.writerName,
+                            "url" to command.writerImgUrl
+                        )
+                    )
+                )
+            )
+        }
+
+        return insertStep
+    }
+}

api-repo/src/main/kotlin/com/few/api/repo/dao/article/ArticleViewCountDao.kt

@@ -2,8 +2,14 @@ package com.few.api.repo.dao.article
 
 import com.few.api.repo.dao.article.command.ArticleViewCountCommand
 import com.few.api.repo.dao.article.query.ArticleViewCountQuery
+import com.few.api.repo.dao.article.query.SelectArticlesOrderByViewsQuery
+import com.few.api.repo.dao.article.query.SelectRankByViewsQuery
+import com.few.api.repo.dao.article.record.SelectArticleViewsRecord
 import jooq.jooq_dsl.tables.ArticleViewCount.ARTICLE_VIEW_COUNT
 import org.jooq.DSLContext
+import org.jooq.Record2
+import org.jooq.SelectQuery
+import org.jooq.impl.DSL.*
 import org.springframework.stereotype.Repository
 
 @Repository
@@ -21,6 +27,13 @@ class ArticleViewCountDao(
             .execute()
     }
 
+    fun insertArticleViewCountToZero(query: ArticleViewCountQuery) = insertArticleViewCountToZeroQuery(query).execute()
+
+    fun insertArticleViewCountToZeroQuery(query: ArticleViewCountQuery) = dslContext.insertInto(ARTICLE_VIEW_COUNT)
+        .set(ARTICLE_VIEW_COUNT.ARTICLE_ID, query.articleId)
+        .set(ARTICLE_VIEW_COUNT.VIEW_COUNT, 0)
+        .set(ARTICLE_VIEW_COUNT.CATEGORY_CD, query.categoryType.code)
+
     fun selectArticleViewCount(command: ArticleViewCountCommand): Long? {
         return dslContext.select(
             ARTICLE_VIEW_COUNT.VIEW_COUNT
@@ -29,4 +42,47 @@ class ArticleViewCountDao(
             .and(ARTICLE_VIEW_COUNT.DELETED_AT.isNull)
             .fetchOneInto(Long::class.java)
     }
+
+    fun selectRankByViews(query: SelectRankByViewsQuery): Long? {
+        return selectRankByViewsQuery(query)
+            .fetchOneInto(Long::class.java)
+    }
+
+    fun selectRankByViewsQuery(query: SelectRankByViewsQuery) = dslContext
+        .select(field("offset"))
+        .from(
+            dslContext.select(
+                ARTICLE_VIEW_COUNT.ARTICLE_ID,
+                rowNumber().over(orderBy(ARTICLE_VIEW_COUNT.VIEW_COUNT.desc())).`as`("offset")
+            ).from(ARTICLE_VIEW_COUNT.`as`("RankedRows"))
+        )
+        .where(field("RankedRows.article_id").eq(query.articleId))
+        .query
+
+    fun selectArticlesOrderByViews(query: SelectArticlesOrderByViewsQuery): Set<SelectArticleViewsRecord> {
+        return selectArticlesOrderByViewsQuery(query)
+            .fetchInto(SelectArticleViewsRecord::class.java)
+            .toSet()
+    }
+
+    fun selectArticlesOrderByViewsQuery(query: SelectArticlesOrderByViewsQuery): SelectQuery<Record2<Long, Long>> {
+        val articleViewCountOffsetTb = select()
+            .from(ARTICLE_VIEW_COUNT)
+            .where(ARTICLE_VIEW_COUNT.DELETED_AT.isNull)
+            .orderBy(ARTICLE_VIEW_COUNT.VIEW_COUNT.desc())
+            .limit(query.offset, Long.MAX_VALUE)
+            .asTable("article_view_count_offset_tb")
+
+        val sql = dslContext.select(
+            articleViewCountOffsetTb.field(ARTICLE_VIEW_COUNT.ARTICLE_ID.`as`(SelectArticleViewsRecord::articleId.name)),
+            articleViewCountOffsetTb.field(ARTICLE_VIEW_COUNT.VIEW_COUNT.`as`(SelectArticleViewsRecord::views.name))
+        )
+            .from(articleViewCountOffsetTb)
+
+        if (query.category != null) {
+            sql.where(field("article_view_count_offset_tb.category_cd").eq(query.category.code))
+        }
+
+        return sql.limit(10).query
+    }
 }

api-repo/src/main/kotlin/com/few/api/repo/dao/article/query/SelectArticlesOrderByViewsQuery.kt

@@ -0,0 +1,8 @@
+package com.few.api.repo.dao.article.query
+
+import com.few.data.common.code.CategoryType
+
+data class SelectArticlesOrderByViewsQuery(
+    val offset: Long,
+    val category: CategoryType?,
+)

api-repo/src/main/kotlin/com/few/api/repo/dao/article/query/SelectRankByViewsQuery.kt

@@ -0,0 +1,5 @@
+package com.few.api.repo.dao.article.query
+
+data class SelectRankByViewsQuery(
+    val articleId: Long,
+)

api-repo/src/main/kotlin/com/few/api/repo/dao/article/record/ArticleMainCardRecord.kt

@@ -0,0 +1,26 @@
+package com.few.api.repo.dao.article.record
+
+import java.net.URL
+import java.time.LocalDateTime
+
+data class ArticleMainCardRecord(
+    val articleId: Long,
+    val articleTitle: String,
+    val mainImageUrl: URL,
+    val categoryCd: Byte,
+    val createdAt: LocalDateTime,
+    val writerId: Long,
+    val writerEmail: String,
+    val writerName: String,
+    val writerImgUrl: URL,
+) {
+    var content: String = ""
+        set(value) {
+            field = value
+        }
+
+    var views: Long = 0L
+        set(value) {
+            field = value
+        }
+}

api-repo/src/main/kotlin/com/few/api/repo/dao/article/record/SelectArticleContentsRecord.kt

@@ -0,0 +1,6 @@
+package com.few.api.repo.dao.article.record
+
+data class SelectArticleContentsRecord(
+    val articleId: Long,
+    val content: String,
+)

api-repo/src/main/kotlin/com/few/api/repo/dao/article/record/SelectArticleViewsRecord.kt

@@ -0,0 +1,6 @@
+package com.few.api.repo.dao.article.record
+
+data class SelectArticleViewsRecord(
+    val articleId: Long,
+    val views: Long,
+)

api-repo/src/main/kotlin/com/few/api/repo/dao/article/support/CommonJsonMapper.kt

@@ -0,0 +1,13 @@
+package com.few.api.repo.dao.article.support
+
+import com.fasterxml.jackson.databind.ObjectMapper
+import org.springframework.stereotype.Component
+
+@Component
+class CommonJsonMapper( // TODO: common 성 패키지 위치로 이동
+    private val objectMapper: ObjectMapper,
+) {
+    fun toJsonStr(map: Map<String, Any>): String {
+        return objectMapper.writeValueAsString(map)
+    }
+}

api-repo/src/test/kotlin/com/few/api/repo/dao/member/support/WriterDescriptionJsonMapperTest.kt → api-repo/src/test/kotlin/com/few/api/repo/dao/member/support/CommonJsonMapperTest.kt

@@ -6,7 +6,7 @@ import org.junit.jupiter.api.Test
 
 import java.net.URL
 
-class WriterDescriptionJsonMapperTest {
+class CommonJsonMapperTest {
 
     private var writerDescriptionJsonMapper: WriterDescriptionJsonMapper = WriterDescriptionJsonMapper(ObjectMapper())
 

api/src/main/kotlin/com/few/api/domain/admin/document/usecase/AddArticleUseCase.kt

@@ -8,7 +8,9 @@ import com.few.api.domain.admin.document.utils.ObjectPathGenerator
 import com.few.api.exception.common.ExternalIntegrationException
 import com.few.api.exception.common.NotFoundException
 import com.few.api.repo.dao.article.ArticleDao
+import com.few.api.repo.dao.article.ArticleViewCountDao
 import com.few.api.repo.dao.article.command.InsertFullArticleRecordCommand
+import com.few.api.repo.dao.article.query.ArticleViewCountQuery
 import com.few.api.repo.dao.document.DocumentDao
 import com.few.api.repo.dao.document.command.InsertDocumentIfoCommand
 import com.few.api.repo.dao.member.MemberDao
@@ -31,6 +33,7 @@ class AddArticleUseCase(
     private val memberDao: MemberDao,
     private val problemDao: ProblemDao,
     private val documentDao: DocumentDao,
+    private val articleViewCountDao: ArticleViewCountDao,
     private val convertDocumentService: ConvertDocumentService,
     private val putDocumentService: PutDocumentService,
     private val getUrlService: GetUrlService,
@@ -78,9 +81,11 @@ class AddArticleUseCase(
 
                 htmlSource
             }
+
             useCaseIn.contentType.lowercase(Locale.getDefault()) == "html" -> {
                 useCaseIn.contentSource
             }
+
             else -> {
                 throw IllegalArgumentException("Unsupported content type: ${useCaseIn.contentType}")
             }
@@ -116,6 +121,12 @@ class AddArticleUseCase(
             problemDao.insertProblems(commands)
         }
 
+        ArticleViewCountQuery(
+            articleMstId,
+            CategoryType.fromCode(CategoryType.convertToCode(useCaseIn.category))
+                ?: throw NotFoundException("article.invalid.category")
+        ).let { articleViewCountDao.insertArticleViewCountToZero(it) }
+
         return AddArticleUseCaseOut(articleMstId)
     }
 }