feat : 링크별 owner 정보 추가 (#284)

Author: dlswns2480

adapters/in-web/src/main/kotlin/com/pokit/content/dto/response/ContentsResponse.kt

@@ -18,6 +18,7 @@ data class ContentsResponse(
     val isFavorite: Boolean,
     val keyword: String,
     val memoExists: Boolean,
+    val author: AuthorProfile,
 )
 
 fun ContentsResult.toResponse(): ContentsResponse {
@@ -37,5 +38,6 @@ fun ContentsResult.toResponse(): ContentsResponse {
         isFavorite = this.isFavorite,
         keyword = this.keyword,
         memoExists = this.memoExists,
+        author = this.author,
     )
 }

adapters/out-persistence/src/main/kotlin/com/pokit/out/persistence/category/impl/CategoryAdapter.kt

@@ -28,6 +28,10 @@ class CategoryAdapter(
     override fun existsByNameAndUserId(name: String, userId: Long): Boolean =
         categoryRepository.existsByNameAndUserIdAndDeleted(name, userId, false)
 
+    override fun existsByNameAndUserIdAndIdNot(id: Long, name: String, userId: Long): Boolean {
+        return categoryRepository.existsByNameAndUserIdAndDeletedAndIdNot(name, userId, false, id)
+    }
+
     override fun persist(category: Category): Category {
         val categoryEntity = CategoryEntity.of(category)
         return categoryRepository.save(categoryEntity).toDomain()

adapters/out-persistence/src/main/kotlin/com/pokit/out/persistence/category/persist/CategoryRepository.kt

@@ -9,6 +9,7 @@ import org.springframework.data.repository.query.Param
 
 interface CategoryRepository : JpaRepository<CategoryEntity, Long> {
     fun existsByNameAndUserIdAndDeleted(name: String, userId: Long, deleted: Boolean): Boolean
+    fun existsByNameAndUserIdAndDeletedAndIdNot(name: String, userId: Long, deleted: Boolean, id: Long): Boolean
     fun findByUserIdAndDeleted(userId: Long, deleted: Boolean, pageable: Pageable): Slice<CategoryEntity>
     fun findByIdAndUserIdAndDeleted(id: Long, userId: Long, deleted: Boolean): CategoryEntity?
     fun countByUserIdAndDeleted(userId: Long, deleted: Boolean): Int

adapters/out-persistence/src/main/kotlin/com/pokit/out/persistence/content/impl/ContentAdapter.kt

@@ -16,6 +16,8 @@ import com.pokit.out.persistence.content.persist.QContentEntity.contentEntity
 import com.pokit.out.persistence.content.persist.QReportedContentEntity.reportedContentEntity
 import com.pokit.out.persistence.content.persist.toDomain
 import com.pokit.out.persistence.log.persist.QUserLogEntity.userLogEntity
+import com.pokit.out.persistence.user.persist.QUserEntity.userEntity
+import com.pokit.out.persistence.user.persist.QUserImageEntity.userImageEntity
 import com.pokit.user.model.InterestType
 import com.querydsl.core.types.OrderSpecifier
 import com.querydsl.core.types.Predicate
@@ -71,11 +73,20 @@ class ContentAdapter(
                 reportedContentEntity.isDeleted.isFalse
             )
 
-        val query = queryFactory.select(contentEntity, categoryEntity.name, userLogEntity.count(), bookmarkEntity.count())
+        val query = queryFactory.select(
+            contentEntity,
+            categoryEntity.name,
+            userLogEntity.count(),
+            bookmarkEntity.count(),
+            userEntity.nickname,
+            userImageEntity.url
+        )
             .from(contentEntity)
             .leftJoin(userLogEntity).on(userLogEntity.contentId.eq(contentEntity.id))
             .join(categoryEntity).on(categoryEntity.id.eq(contentEntity.categoryId))
             .leftJoin(bookmarkEntity).on(bookmarkEntity.contentId.eq(contentEntity.id).and(bookmarkEntity.deleted.isFalse))
+            .join(userEntity).on(userEntity.id.eq(contentEntity.userId))
+            .leftJoin(userImageEntity).on(userImageEntity.id.eq(userEntity.image.id))
 
         if(condition.favorites == true) { // 즐겨찾기 필터링
             query.where(bookmarkEntity.isNotNull)
@@ -92,7 +103,7 @@ class ContentAdapter(
             containsWord(condition.searchWord),
         )
             .offset(pageable.offset)
-            .groupBy(contentEntity)
+            .groupBy(contentEntity, userEntity.nickname, userImageEntity.url)
             .orderBy(getSortOrder(contentEntity.createdAt, "createdAt", pageable))
             .limit(pageable.pageSize + 1L)
 
@@ -105,26 +116,37 @@ class ContentAdapter(
                 it[contentEntity]!!.toDomain(),
                 it[categoryEntity.name]!!,
                 it[userLogEntity.count()]!!,
-                it[bookmarkEntity.count()]!!
+                it[bookmarkEntity.count()]!!,
+                it[userEntity.nickname]!!,
+                it[userImageEntity.url]
             )
         }
 
         return SliceImpl(contents, pageable, hasNext)
     }
 
     override fun loadByUserIdAndCategoryName(userId: Long, categoryName: String, pageable: Pageable): Slice<ContentsResult> {
-        val contents = queryFactory.select(contentEntity, categoryEntity.name, userLogEntity.count(), bookmarkEntity.count())
+        val contents = queryFactory.select(
+            contentEntity,
+            categoryEntity.name,
+            userLogEntity.count(),
+            bookmarkEntity.count(),
+            userEntity.nickname,
+            userImageEntity.url
+        )
             .from(contentEntity)
             .leftJoin(userLogEntity).on(userLogEntity.contentId.eq(contentEntity.id))
             .join(categoryEntity).on(categoryEntity.id.eq(contentEntity.categoryId))
             .leftJoin(bookmarkEntity).on(bookmarkEntity.contentId.eq(contentEntity.id).and(bookmarkEntity.deleted.isFalse))
+            .join(userEntity).on(userEntity.id.eq(contentEntity.userId))
+            .leftJoin(userImageEntity).on(userImageEntity.id.eq(userEntity.image.id))
             .where(
                 categoryEntity.userId.eq(userId),
                 categoryEntity.name.eq(categoryName),
                 contentEntity.deleted.isFalse,
             )
             .offset(pageable.offset)
-            .groupBy(contentEntity)
+            .groupBy(contentEntity, userEntity.nickname, userImageEntity.url)
             .limit((pageable.pageSize + 1).toLong())
             .orderBy(getSortOrder(contentEntity.createdAt, "createdAt", pageable))
             .fetch()
@@ -136,28 +158,39 @@ class ContentAdapter(
                 it[contentEntity]!!.toDomain(),
                 it[categoryEntity.name]!!,
                 it[userLogEntity.count()]!!,
-                it[bookmarkEntity.count()]!!
+                it[bookmarkEntity.count()]!!,
+                it[userEntity.nickname]!!,
+                it[userImageEntity.url]
             )
         }
 
         return SliceImpl(contentResults, pageable, hasNext)
     }
 
     override fun loadBookmarkedContentsByUserId(userId: Long, pageable: Pageable): Slice<ContentsResult> {
-        val contents = queryFactory.select(contentEntity, categoryEntity.name, userLogEntity.count(), bookmarkEntity.count())
+        val contents = queryFactory.select(
+            contentEntity,
+            categoryEntity.name,
+            userLogEntity.count(),
+            bookmarkEntity.count(),
+            userEntity.nickname,
+            userImageEntity.url
+        )
             .from(contentEntity)
             .leftJoin(userLogEntity).on(userLogEntity.contentId.eq(contentEntity.id))
             .join(categoryEntity).on(categoryEntity.id.eq(contentEntity.categoryId))
             .leftJoin(reportedContentEntity).on(reportedContentEntity.contentId.eq(contentEntity.id))
             .leftJoin(bookmarkEntity).on(bookmarkEntity.contentId.eq(contentEntity.id).and(bookmarkEntity.deleted.isFalse))
+            .join(userEntity).on(userEntity.id.eq(contentEntity.userId))
+            .leftJoin(userImageEntity).on(userImageEntity.id.eq(userEntity.image.id))
             .where(
                 categoryEntity.userId.eq(userId),
                 reportedContentEntity.reporterId.ne(userId).or(reportedContentEntity.reporterId.isNull),
                 contentEntity.deleted.isFalse,
                 bookmarkEntity.deleted.isFalse,
             )
             .offset(pageable.offset)
-            .groupBy(contentEntity)
+            .groupBy(contentEntity, userEntity.nickname, userImageEntity.url)
             .limit((pageable.pageSize + 1).toLong())
             .orderBy(getSortOrder(contentEntity.createdAt, "createdAt", pageable))
             .fetch()
@@ -169,7 +202,9 @@ class ContentAdapter(
                 it[contentEntity]!!.toDomain(),
                 it[categoryEntity.name]!!,
                 it[userLogEntity.count()]!!,
-                it[bookmarkEntity.count()]!!
+                it[bookmarkEntity.count()]!!,
+                it[userEntity.nickname]!!,
+                it[userImageEntity.url]
             )
         }
 
@@ -230,10 +265,18 @@ class ContentAdapter(
     }
 
     override fun loadAllByKeyword(userId: Long, searchKeywords: List<InterestType>, pageable: Pageable): Slice<ContentsResult> {
-        val contents = queryFactory.select(contentEntity, categoryEntity.name, categoryEntity.keyword)
+        val contents = queryFactory.select(
+            contentEntity,
+            categoryEntity.name,
+            categoryEntity.keyword,
+            userEntity.nickname,
+            userImageEntity.url
+        )
             .from(contentEntity)
             .join(categoryEntity).on(contentEntity.categoryId.eq(categoryEntity.id))
             .leftJoin(reportedContentEntity).on(reportedContentEntity.contentId.eq(contentEntity.id))
+            .join(userEntity).on(userEntity.id.eq(contentEntity.userId))
+            .leftJoin(userImageEntity).on(userImageEntity.id.eq(userEntity.image.id))
             .where(
                 reportedContentEntity.reporterId.ne(userId).or(reportedContentEntity.reporterId.isNull),
                 categoryEntity.openType.eq(OpenType.PUBLIC),
@@ -242,7 +285,7 @@ class ContentAdapter(
                 contentEntity.deleted.isFalse
             )
             .offset(pageable.offset)
-            .groupBy(contentEntity)
+            .groupBy(contentEntity, userEntity.nickname, userImageEntity.url)
             .limit((pageable.pageSize + 1).toLong())
             .orderBy(getSortOrder(contentEntity.createdAt, "createdAt", pageable))
             .fetch()
@@ -253,8 +296,10 @@ class ContentAdapter(
             ContentsResult.of(
                 it[contentEntity]!!.toDomain(),
                 it[categoryEntity.name]!!,
-                0,
-                0,
+                0L,
+                0L,
+                it[userEntity.nickname]!!,
+                it[userImageEntity.url],
                 it[categoryEntity.keyword]!!.kor
             )
         }

application/src/main/kotlin/com/pokit/category/port/out/CategoryPort.kt

@@ -10,6 +10,7 @@ interface CategoryPort {
     fun loadByIdAndUserId(id: Long, userId: Long): Category?
     fun loadById(id: Long): Category?
     fun existsByNameAndUserId(name: String, userId: Long): Boolean
+    fun existsByNameAndUserIdAndIdNot(id: Long, name: String, userId: Long): Boolean
     fun persist(category: Category): Category
     fun delete(category: Category)
     fun countByUserId(userId: Long): Int

application/src/main/kotlin/com/pokit/category/port/service/CategoryService.kt

@@ -47,7 +47,7 @@ class CategoryService(
             throw InvalidRequestException(CategoryErrorCode.UNAVAILABLE_CATEGORY_NAME)
         }
 
-        categoryPort.existsByNameAndIdOrThrow(command.categoryName, userId)
+        categoryPort.existsByNameAndUserIdOrThrow(command.categoryName, userId)
 
         if (categoryPort.countByUserId(userId) >= MAX_CATEGORY_COUNT) {
             throw InvalidRequestException(CategoryErrorCode.MAX_CATEGORY_LIMIT_EXCEEDED)
@@ -84,7 +84,7 @@ class CategoryService(
         val categoryImage = categoryImagePort.loadById(categoryCommand.categoryImageId)
             ?: throw NotFoundCustomException(CategoryErrorCode.NOT_FOUND_CATEGORY_IMAGE)
 
-        categoryPort.existsByNameAndIdOrThrow(categoryCommand.categoryName, userId)
+        categoryPort.existsByNameAndUserIdAndIdNot(category.categoryId, categoryCommand.categoryName, userId)
 
         category.update(categoryCommand, categoryImage)
         return categoryPort.persist(category)
@@ -328,8 +328,14 @@ fun CategoryPort.loadByIdOrThrow(categoryId: Long) =
     loadById(categoryId)
         ?: throw NotFoundCustomException(CategoryErrorCode.NOT_FOUND_CATEGORY)
 
-fun CategoryPort.existsByNameAndIdOrThrow(categoryName: String, userId: Long) {
+fun CategoryPort.existsByNameAndUserIdOrThrow(categoryName: String, userId: Long) {
     if (existsByNameAndUserId(categoryName, userId)) {
         throw AlreadyExistsException(CategoryErrorCode.ALREADY_EXISTS_CATEGORY)
     }
 }
+
+fun CategoryPort.existsByNameAndIdNotOrThrow(categoryId: Long, categoryName: String, userId: Long) {
+    if (existsByNameAndUserIdAndIdNot(categoryId, categoryName, userId)) {
+        throw AlreadyExistsException(CategoryErrorCode.ALREADY_EXISTS_CATEGORY)
+    }
+}

domain/src/main/kotlin/com/pokit/content/dto/response/ContentsResult.kt

@@ -19,13 +19,16 @@ data class ContentsResult(
     val isFavorite: Boolean,
     val keyword: String,
     val memoExists: Boolean,
+    val author: AuthorProfile,
 ) {
     companion object {
         fun of(
             content: Content,
             categoryName: String,
             isRead: Long,
             isFavorite: Long,
+            authorNickname: String,
+            authorProfileImageUrl: String?,
             keyword: String = "default"
         ): ContentsResult {
             return ContentsResult(
@@ -42,7 +45,18 @@ data class ContentsResult(
                 isFavorite = isFavorite > 0,
                 keyword = keyword,
                 memoExists = content.memo.isNotBlank(),
+                author = AuthorProfile(
+                    userId = content.userId,
+                    nickname = authorNickname,
+                    profileImageUrl = authorProfileImageUrl
+                )
             )
         }
     }
 }
+
+data class AuthorProfile(
+    val userId: Long,
+    val nickname: String,
+    val profileImageUrl: String?
+)