feat(creator-admin): 후원 메시지 조회와 일관된 숨김을 지원한다

This commit is contained in:
2026-11-20 14:08:37 +09:00
parent 09d39df3ef
commit ac23b85192
10 changed files with 710 additions and 2 deletions
@@ -106,6 +106,7 @@ class ChannelDonationMessageQueryRepositoryImpl(
startDateTime: LocalDateTime,
endDateTime: LocalDateTime
) = channelDonationMessage.creator.id.eq(creatorId)
.and(channelDonationMessage.isHidden.isFalse)
.and(channelDonationMessage.createdAt.goe(startDateTime))
.and(channelDonationMessage.createdAt.lt(endDateTime))
.let {
@@ -0,0 +1,44 @@
package kr.co.vividnext.sodalive.v2.creator.admin.commentmanagement.donation.adapter.`in`.web
import kr.co.vividnext.sodalive.common.ApiResponse
import kr.co.vividnext.sodalive.member.Member
import kr.co.vividnext.sodalive.v2.creator.admin.commentmanagement.adapter.`in`.web.requireCreator
import kr.co.vividnext.sodalive.v2.creator.admin.commentmanagement.domain.CreatorAdminCommentPolicy
import kr.co.vividnext.sodalive.v2.creator.admin.commentmanagement.donation.application.CreatorAdminDonationService
import org.springframework.security.core.annotation.AuthenticationPrincipal
import org.springframework.web.bind.annotation.DeleteMapping
import org.springframework.web.bind.annotation.GetMapping
import org.springframework.web.bind.annotation.PathVariable
import org.springframework.web.bind.annotation.RequestMapping
import org.springframework.web.bind.annotation.RequestParam
import org.springframework.web.bind.annotation.RestController
@RestController
@RequestMapping("/api/v2/creator-admin/comment-management/donations")
class CreatorAdminDonationController(private val service: CreatorAdminDonationService) {
@GetMapping
fun getDonations(
@RequestParam(defaultValue = "0") page: Int,
@RequestParam(defaultValue = "10") size: Int,
@RequestParam(defaultValue = "latest") order: String,
@RequestParam(defaultValue = "all") visibility: String,
@AuthenticationPrincipal(expression = "#this == 'anonymousUser' ? null : member") member: Member?
) = ApiResponse.ok(
service.getDonations(
creatorId = requireNotNull(requireCreator(member).id),
page = CreatorAdminCommentPolicy.parsePage(page, size),
order = CreatorAdminCommentPolicy.parseOrder(order),
visibility = CreatorAdminCommentPolicy.parseVisibility(visibility)
)
)
@DeleteMapping("/{donationId}")
fun hideDonation(
@PathVariable donationId: Long,
@AuthenticationPrincipal(expression = "#this == 'anonymousUser' ? null : member") member: Member?
): ApiResponse<Unit> {
val creator = requireCreator(member)
service.hideDonation(CreatorAdminCommentPolicy.requirePositiveId(donationId), creator)
return ApiResponse.ok<Unit>()
}
}
@@ -0,0 +1,62 @@
package kr.co.vividnext.sodalive.v2.creator.admin.commentmanagement.donation.adapter.out.persistence
import com.querydsl.jpa.impl.JPAQueryFactory
import kr.co.vividnext.sodalive.explorer.profile.channelDonation.ChannelDonationMessage
import kr.co.vividnext.sodalive.explorer.profile.channelDonation.QChannelDonationMessage.channelDonationMessage
import kr.co.vividnext.sodalive.member.QMember.member
import kr.co.vividnext.sodalive.v2.creator.admin.commentmanagement.domain.CreatorAdminCommentOrder
import kr.co.vividnext.sodalive.v2.creator.admin.commentmanagement.domain.CreatorAdminCommentPage
import kr.co.vividnext.sodalive.v2.creator.admin.commentmanagement.domain.CreatorAdminCommentVisibility
import kr.co.vividnext.sodalive.v2.creator.admin.commentmanagement.dto.CreatorAdminCommentCountsResponse
import org.springframework.stereotype.Repository
@Repository
class CreatorAdminDonationQueryRepository(private val queryFactory: JPAQueryFactory) {
fun findDonations(
creatorId: Long,
page: CreatorAdminCommentPage,
order: CreatorAdminCommentOrder,
visibility: CreatorAdminCommentVisibility
): List<ChannelDonationMessage> {
val visibilityCondition = when (visibility) {
CreatorAdminCommentVisibility.ALL -> null
CreatorAdminCommentVisibility.PUBLIC -> channelDonationMessage.isSecret.isFalse
CreatorAdminCommentVisibility.SECRET -> channelDonationMessage.isSecret.isTrue
}
val ordering = when (order) {
CreatorAdminCommentOrder.LATEST -> arrayOf(channelDonationMessage.createdAt.desc(), channelDonationMessage.id.desc())
CreatorAdminCommentOrder.OLDEST -> arrayOf(channelDonationMessage.createdAt.asc(), channelDonationMessage.id.asc())
}
return queryFactory
.selectFrom(channelDonationMessage)
.join(channelDonationMessage.member, member).fetchJoin()
.where(ownedVisibleCondition(creatorId), visibilityCondition)
.orderBy(*ordering)
.offset(page.offset)
.limit(page.size.toLong())
.fetch()
}
fun countDonations(creatorId: Long): CreatorAdminCommentCountsResponse {
val count = channelDonationMessage.id.count()
val counts = queryFactory
.select(channelDonationMessage.isSecret, count)
.from(channelDonationMessage)
.where(ownedVisibleCondition(creatorId))
.groupBy(channelDonationMessage.isSecret)
.fetch()
.associate { row -> requireNotNull(row.get(channelDonationMessage.isSecret)) to requireNotNull(row.get(count)) }
val public = counts[false] ?: 0L
val secret = counts[true] ?: 0L
return CreatorAdminCommentCountsResponse(all = public + secret, public = public, secret = secret)
}
fun findOwnerId(donationId: Long): Long? = queryFactory
.select(channelDonationMessage.creator.id)
.from(channelDonationMessage)
.where(channelDonationMessage.id.eq(donationId))
.fetchOne()
private fun ownedVisibleCondition(creatorId: Long) = channelDonationMessage.creator.id.eq(creatorId)
.and(channelDonationMessage.isHidden.isFalse)
}
@@ -0,0 +1,77 @@
package kr.co.vividnext.sodalive.v2.creator.admin.commentmanagement.donation.application
import kr.co.vividnext.sodalive.extensions.removeDeletedNicknamePrefix
import kr.co.vividnext.sodalive.extensions.toUtcIso
import kr.co.vividnext.sodalive.member.Member
import kr.co.vividnext.sodalive.v2.common.domain.toCdnUrl
import kr.co.vividnext.sodalive.v2.creator.admin.commentmanagement.domain.CreatorAdminCommentError
import kr.co.vividnext.sodalive.v2.creator.admin.commentmanagement.domain.CreatorAdminCommentException
import kr.co.vividnext.sodalive.v2.creator.admin.commentmanagement.domain.CreatorAdminCommentOrder
import kr.co.vividnext.sodalive.v2.creator.admin.commentmanagement.domain.CreatorAdminCommentPage
import kr.co.vividnext.sodalive.v2.creator.admin.commentmanagement.domain.CreatorAdminCommentVisibility
import kr.co.vividnext.sodalive.v2.creator.admin.commentmanagement.donation.adapter.out.persistence.CreatorAdminDonationQueryRepository
import kr.co.vividnext.sodalive.v2.creator.admin.commentmanagement.donation.dto.CreatorAdminDonationResponse
import kr.co.vividnext.sodalive.v2.creator.admin.commentmanagement.dto.CreatorAdminCommentPageResponse
import kr.co.vividnext.sodalive.v2.creator.admin.commentmanagement.dto.CreatorAdminCommentWriterResponse
import kr.co.vividnext.sodalive.v2.creator.channel.donation.application.HideCreatorChannelDonationService
import org.springframework.beans.factory.annotation.Value
import org.springframework.stereotype.Service
import org.springframework.transaction.annotation.Transactional
@Service
@Transactional(readOnly = true)
class CreatorAdminDonationService(
private val queryRepository: CreatorAdminDonationQueryRepository,
private val hideService: HideCreatorChannelDonationService,
@Value("\${cloud.aws.cloud-front.host}") private val cloudFrontHost: String
) {
fun getDonations(
creatorId: Long,
page: CreatorAdminCommentPage,
order: CreatorAdminCommentOrder,
visibility: CreatorAdminCommentVisibility
): CreatorAdminCommentPageResponse<CreatorAdminDonationResponse> {
val counts = queryRepository.countDonations(creatorId)
val totalCount = when (visibility) {
CreatorAdminCommentVisibility.ALL -> counts.all
CreatorAdminCommentVisibility.PUBLIC -> counts.public
CreatorAdminCommentVisibility.SECRET -> counts.secret
}
val donations = if (page.offset < totalCount) {
queryRepository.findDonations(creatorId, page, order, visibility)
} else {
emptyList()
}
val items = donations.map { donation ->
val writer = requireNotNull(donation.member)
CreatorAdminDonationResponse(
donationId = requireNotNull(donation.id),
writer = CreatorAdminCommentWriterResponse(
memberId = requireNotNull(writer.id),
nickname = writer.nickname.removeDeletedNicknamePrefix(),
profileImageUrl = writer.profileImage.toCdnUrl(cloudFrontHost)
?: "$cloudFrontHost/profile/default-profile.png"
),
content = donation.additionalMessage,
can = donation.can,
isSecret = donation.isSecret,
createdAtUtc = requireNotNull(donation.createdAt).toUtcIso()
)
}
return CreatorAdminCommentPageResponse(
items = items,
totalCount = totalCount,
page = page.page,
size = page.size,
counts = counts
)
}
@Transactional
fun hideDonation(donationId: Long, actor: Member) {
val ownerId = queryRepository.findOwnerId(donationId)
?: throw CreatorAdminCommentException(CreatorAdminCommentError.NOT_FOUND)
if (ownerId != actor.id) throw CreatorAdminCommentException(CreatorAdminCommentError.ACCESS_DENIED)
hideService.hide(ownerId, donationId, actor)
}
}
@@ -0,0 +1,14 @@
package kr.co.vividnext.sodalive.v2.creator.admin.commentmanagement.donation.dto
import com.fasterxml.jackson.annotation.JsonProperty
import kr.co.vividnext.sodalive.v2.creator.admin.commentmanagement.dto.CreatorAdminCommentWriterResponse
data class CreatorAdminDonationResponse(
val donationId: Long,
val writer: CreatorAdminCommentWriterResponse,
val content: String?,
val can: Int,
@get:JsonProperty("isSecret")
val isSecret: Boolean,
val createdAtUtc: String
)
@@ -97,7 +97,7 @@ class CreatorChannelDonationEndToEndTest @Autowired constructor(
@ParameterizedTest
@ValueSource(booleans = [false, true])
@DisplayName("실제 HTTP 숨김은 단일 공개·비밀 후원의 legacy 응답과 양수 랭킹·정산을 그대로 보존한다")
@DisplayName("실제 HTTP 숨김은 공개·비밀 후원을 legacy에서 제외하고 양수 랭킹·정산을 보존한다")
fun shouldPreserveLegacyRankingAndSettlementAfterHidingDonationThroughHttp(isSecret: Boolean) {
val createdAt = CreatorChannelDonationQueryPolicy()
.currentKstMonthRange(LocalDateTime.now(ZoneOffset.UTC)).startInclusiveUtc
@@ -173,7 +173,10 @@ class CreatorChannelDonationEndToEndTest @Autowired constructor(
assertFalse(tabAfter["hasNext"].asBoolean())
assertTrue(requestThroughHttp("$path/home", HttpMethod.GET, fixture.creator)["data"]["channelDonations"].isEmpty)
assertEquals(rankingsBefore, tabAfter["rankings"])
assertEquals(legacyBefore, requestThroughHttp(legacyPath, HttpMethod.GET, fixture.creator))
val legacyAfter = requestThroughHttp(legacyPath, HttpMethod.GET, fixture.creator)
assertTrue(legacyAfter["success"].asBoolean())
assertEquals(0, legacyAfter["data"]["totalCount"].asInt())
assertTrue(legacyAfter["data"]["items"].isEmpty)
val totalAfter = settlementRepository.getChannelDonationByCreatorTotal(createdAt, createdAt)
val settlementAfter = settlementRepository.getChannelDonationByCreator(createdAt, createdAt, 0, 20)
assertEquals(totalBefore, totalAfter)
@@ -0,0 +1,171 @@
package kr.co.vividnext.sodalive.v2.creator.admin.commentmanagement.donation
import kr.co.vividnext.sodalive.can.payment.PaymentGateway
import kr.co.vividnext.sodalive.can.use.CanUsage
import kr.co.vividnext.sodalive.can.use.UseCan
import kr.co.vividnext.sodalive.can.use.UseCanCalculate
import kr.co.vividnext.sodalive.can.use.UseCanCalculateStatus
import kr.co.vividnext.sodalive.creator.admin.calculate.channelDonation.CreatorAdminChannelDonationCalculateQueryRepository
import kr.co.vividnext.sodalive.explorer.profile.channelDonation.ChannelDonationMessage
import kr.co.vividnext.sodalive.member.Member
import kr.co.vividnext.sodalive.member.MemberAdapter
import kr.co.vividnext.sodalive.v2.creator.channel.donation.application.HideCreatorChannelDonationService
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Assertions.assertFalse
import org.junit.jupiter.api.Assertions.assertTrue
import org.junit.jupiter.api.DisplayName
import org.junit.jupiter.api.Test
import org.junit.jupiter.params.ParameterizedTest
import org.junit.jupiter.params.provider.ValueSource
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.jdbc.core.JdbcTemplate
import org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors.user
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders.delete
import org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath
import org.springframework.test.web.servlet.result.MockMvcResultMatchers.status
class CreatorAdminDonationHideIntegrationTest : CreatorAdminDonationTestSupport() {
@Autowired private lateinit var jdbcTemplate: JdbcTemplate
@Autowired private lateinit var settlementRepository: CreatorAdminChannelDonationCalculateQueryRepository
@Autowired private lateinit var existingHideService: HideCreatorChannelDonationService
@ParameterizedTest
@ValueSource(booleans = [false, true])
@DisplayName("관리자 DELETE는 공개·비밀 후원의 숨김만 바꾸고 원문·모든 시각·원장·잔액·정산을 보존한다")
fun shouldHideOnlySelectedDonationAndPreservePersistedFinancialRecords(isSecret: Boolean) {
val donationId = saveDonation(ChannelDonationMessage(120, isSecret, "original message"))
val visibleId = saveDonation(ChannelDonationMessage(250, additionalMessage = "keep visible"))
val otherId = saveDonation(ChannelDonationMessage(999, true, "other channel"), owner = otherCreator)
saveFinancialRecords(isSecret)
val before = persistedRecords()
assertEquals(listOf(3, 1, 1, 4), before.map { it.size })
val settlementBefore = settlementRepository.getChannelDonationSettlementTotal(
storedAt.minusDays(1),
storedAt.plusDays(1),
requireNotNull(creator.id)
)
assertEquals(1L, settlementBefore.count)
assertEquals(120, settlementBefore.totalCan)
expectSuccessfulDelete(donationId)
assertTrue(reloadDonation(donationId).isHidden)
assertFalse(reloadDonation(visibleId).isHidden)
assertFalse(reloadDonation(otherId).isHidden)
assertEquals(before, persistedRecords())
val settlementAfter = settlementRepository.getChannelDonationSettlementTotal(
storedAt.minusDays(1),
storedAt.plusDays(1),
requireNotNull(creator.id)
)
assertEquals(settlementBefore, settlementAfter)
assertEquals(settlementBefore.toResponseTotal(), settlementAfter.toResponseTotal())
val data = readList()
assertEquals(listOf(visibleId), data["items"].map { it["donationId"].asLong() })
assertEquals(1L, data["totalCount"].asLong())
assertEquals(1, data["counts"]["all"].asInt())
assertEquals(1, data["counts"]["public"].asInt())
assertEquals(0, data["counts"]["secret"].asInt())
}
@Test
@DisplayName("이미 숨긴 후원의 관리자 DELETE도 HTTP 200과 data null을 반환하고 저장값을 보존한다")
fun shouldSucceedIdempotentlyWhenExistingHideServiceAlreadyHidDonation() {
val donationId = saveDonation(ChannelDonationMessage(120, true, "original"))
existingHideService.hide(requireNotNull(creator.id), donationId, creator)
saveFinancialRecords(isSecret = true)
val before = persistedRecords()
repeat(2) { expectSuccessfulDelete(donationId) }
assertTrue(reloadDonation(donationId).isHidden)
assertEquals(before, persistedRecords())
assertEquals(0L, readList()["totalCount"].asLong())
}
@ParameterizedTest
@ValueSource(booleans = [false, true])
@DisplayName("다른 크리에이터 후원 DELETE는 403이며 메시지·재무 기록을 변경하지 않는다")
fun shouldRejectCrossOwnerDeleteWithForbiddenAndPreserveStoredRecords(isHidden: Boolean) {
val donationId = saveDonation(
ChannelDonationMessage(120, true, "other owner private").also { it.isHidden = isHidden },
owner = otherCreator
)
saveFinancialRecords(isSecret = true, recipient = otherCreator)
val before = persistedRecords()
mockMvc.perform(delete("$basePath/$donationId").with(user(MemberAdapter(creator))))
.andExpect(status().isForbidden)
.andExpect(jsonPath("$.success").value(false))
assertEquals(isHidden, reloadDonation(donationId).isHidden)
assertEquals(before, persistedRecords())
}
@Test
@DisplayName("없는 후원 DELETE는 404를 반환하고 기존 후원을 바꾸지 않는다")
fun shouldRejectMissingDonationWithoutChangingExistingDonation() {
val donationId = saveDonation(ChannelDonationMessage(120, additionalMessage = "keep"))
val before = persistedRecords()
mockMvc.perform(delete("$basePath/${Long.MAX_VALUE}").with(user(MemberAdapter(creator))))
.andExpect(status().isNotFound)
.andExpect(jsonPath("$.success").value(false))
assertFalse(reloadDonation(donationId).isHidden)
assertEquals(before, persistedRecords())
}
private fun expectSuccessfulDelete(donationId: Long) {
val result = mockMvc.perform(delete("$basePath/$donationId").with(user(MemberAdapter(creator))))
.andExpect(status().isOk)
.andExpect(jsonPath("$.success").value(true))
.andReturn()
val body = objectMapper.readTree(result.response.contentAsByteArray)
assertTrue(body.has("data"))
assertTrue(body["data"].isNull)
assertTrue(body.has("message"))
assertTrue(body["message"].isNull)
}
private fun saveFinancialRecords(isSecret: Boolean, recipient: Member = creator) {
val usage = UseCan(CanUsage.CHANNEL_DONATION, can = 100, rewardCan = 20, isSecret = isSecret)
usage.member = donor
entityManager.persist(usage)
val calculation = UseCanCalculate(120, PaymentGateway.PG, UseCanCalculateStatus.RECEIVED)
calculation.useCan = usage
calculation.recipientCreatorId = recipient.id
entityManager.persist(calculation)
entityManager.flush()
entityManager.createQuery("update UseCan u set u.createdAt = :createdAt where u.id = :id")
.setParameter("createdAt", storedAt)
.setParameter("id", usage.id)
.executeUpdate()
entityManager.clear()
}
private fun persistedRecords(): List<List<Map<String, Any?>>> {
entityManager.flush()
entityManager.clear()
val messages = jdbcTemplate.queryForList(
"select * from channel_donation_message where creator_id in (?, ?) order by id",
creator.id,
otherCreator.id
).map { row -> row.filterKeys { !it.equals("is_hidden", ignoreCase = true) } }
val usages = jdbcTemplate.queryForList("select * from use_can where member_id = ? order by id", donor.id)
val calculations = jdbcTemplate.queryForList(
"select c.* from use_can_calculate c join use_can u on u.id = c.use_can_id where u.member_id = ? order by c.id",
donor.id
)
val members = jdbcTemplate.queryForList(
"select * from member where id in (?, ?, ?, ?) order by id",
creator.id,
otherCreator.id,
donor.id,
outsider.id
)
return listOf(messages, usages, calculations, members)
}
}
@@ -0,0 +1,139 @@
package kr.co.vividnext.sodalive.v2.creator.admin.commentmanagement.donation
import kr.co.vividnext.sodalive.explorer.profile.channelDonation.ChannelDonationMessage
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Assertions.assertFalse
import org.junit.jupiter.api.Assertions.assertTrue
import org.junit.jupiter.api.DisplayName
import org.junit.jupiter.api.Test
import org.junit.jupiter.params.ParameterizedTest
import org.junit.jupiter.params.provider.CsvSource
import org.junit.jupiter.params.provider.ValueSource
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get
import java.time.LocalDateTime
import java.time.ZoneOffset
class CreatorAdminDonationIntegrationTest : CreatorAdminDonationTestSupport() {
@Test
@DisplayName("소유자는 전체 기간의 비밀 후원 원문과 작성자·금액·DB 저장 시각을 조회한다")
fun shouldReturnOwnedSecretDonationFromAnyMonthWithOriginalWriterAndContent() {
donor.nickname = "deleted_donation-donor"
donor.profileImage = "donor.png"
val donationId = saveDonation(
ChannelDonationMessage(can = 120, isSecret = true, additionalMessage = "private original"),
LocalDateTime.of(2020, 1, 31, 23, 59, 59)
)
val stored = reloadDonation(donationId)
val data = readList()
assertEquals(1L, data["totalCount"].asLong())
assertEquals(0, data["page"].asInt())
assertEquals(10, data["size"].asInt())
assertFalse(data["hasNext"].asBoolean())
assertEquals(1, data["items"].size())
val item = data["items"].single()
assertTrue(item["donationId"].isIntegralNumber)
assertEquals(donationId, item["donationId"].asLong())
assertEquals(donor.id, item["writer"]["memberId"].asLong())
assertEquals("donation-donor", item["writer"]["nickname"].asText())
assertEquals("https://cdn.test/donor.png", item["writer"]["profileImageUrl"].asText())
assertEquals("private original", item["content"].asText())
assertEquals(120, item["can"].asInt())
assertTrue(item["isSecret"].asBoolean())
assertEquals(
requireNotNull(stored.createdAt).atOffset(ZoneOffset.UTC).toInstant().toString(),
item["createdAtUtc"].asText()
)
}
@Test
@DisplayName("본문·프로필 이미지가 없는 후원은 null 본문과 기존 기본 프로필 URL을 반환한다")
fun shouldPreserveNullMessageAndUseDefaultProfileForMissingImage() {
val donationId = saveDonation(ChannelDonationMessage(can = 75, additionalMessage = null))
val item = readList()["items"].single()
assertEquals(donationId, item["donationId"].asLong())
assertTrue(item.has("content"))
assertTrue(item["content"].isNull)
assertEquals("https://cdn.test/profile/default-profile.png", item["writer"]["profileImageUrl"].asText())
}
@ParameterizedTest
@CsvSource("all, 13", "public, 7", "secret, 6")
@DisplayName("공개 범위 필터는 소유 비숨김 전체 개수와 선택 결과 개수를 페이지와 독립적으로 반환한다")
fun shouldFilterOwnedVisibleDonationsAndKeepFullScopeCounts(visibility: String, total: Int) {
val ids = (1..13).map { index ->
saveDonation(ChannelDonationMessage(can = index, isSecret = index % 2 == 0, additionalMessage = "row$index"))
}
saveDonation(ChannelDonationMessage(can = 900).apply { isHidden = true })
saveDonation(ChannelDonationMessage(can = 901, isSecret = true).apply { isHidden = true })
saveDonation(ChannelDonationMessage(can = 902, isSecret = true), owner = otherCreator)
val selected = when (visibility) {
"public" -> ids.filterIndexed { index, _ -> index % 2 == 0 }
"secret" -> ids.filterIndexed { index, _ -> index % 2 == 1 }
else -> ids
}.reversed()
val data = readList(get(basePath).param("visibility", visibility).param("page", "1").param("size", "2"))
assertEquals(total, data["totalCount"].asInt())
assertEquals(13, data["counts"]["all"].asInt())
assertEquals(7, data["counts"]["public"].asInt())
assertEquals(6, data["counts"]["secret"].asInt())
assertEquals(1, data["page"].asInt())
assertEquals(2, data["size"].asInt())
assertTrue(data["hasNext"].asBoolean())
assertEquals(selected.drop(2).take(2), data["items"].map { it["donationId"].asLong() })
}
@ParameterizedTest
@ValueSource(strings = ["default", "latest", "oldest"])
@DisplayName("기본 10건 페이지는 작성 시각과 ID를 같은 방향으로 정렬하고 범위 밖에서도 개수를 유지한다")
fun shouldPaginateTenAtATimeUsingStableCreatedAtAndIdOrder(order: String) {
val historical = LocalDateTime.of(2020, 5, 1, 0, 0)
val ids = (1..23).map { index ->
saveDonation(
ChannelDonationMessage(can = index, isSecret = index % 2 == 0),
historical.plusDays((index % 3).toLong())
)
}
val latest = listOf(23, 20, 17, 14, 11, 8, 5, 2, 22, 19, 16, 13, 10, 7, 4, 1, 21, 18, 15, 12, 9, 6, 3)
val expected = if (order == "oldest") latest.reversed() else latest
(0..3).forEach { page ->
val request = get(basePath).param("page", page.toString())
if (order != "default") request.param("order", order)
val data = readList(request)
assertEquals(23, data["totalCount"].asInt())
assertEquals(23, data["counts"]["all"].asInt())
assertEquals(12, data["counts"]["public"].asInt())
assertEquals(11, data["counts"]["secret"].asInt())
assertEquals(page, data["page"].asInt())
assertEquals(10, data["size"].asInt())
assertEquals(page < 2, data["hasNext"].asBoolean())
val pageRows = expected.drop(page * 10).take(10)
assertEquals(pageRows, data["items"].map { it["can"].asInt() })
assertEquals(pageRows.map { ids[it - 1] }, data["items"].map { it["donationId"].asLong() })
}
}
@ParameterizedTest
@ValueSource(ints = [0, 5])
@DisplayName("숨김과 다른 채널 후원만 있으면 빈 목록과 모든 필터의 0 개수를 반환한다")
fun shouldReturnEmptyOwnedScopeWithoutClampingPage(page: Int) {
saveDonation(ChannelDonationMessage(can = 10).apply { isHidden = true })
saveDonation(ChannelDonationMessage(can = 20, isSecret = true), owner = otherCreator)
val data = readList(get(basePath).param("page", page.toString()))
assertEquals(0, data["items"].size())
assertEquals(0L, data["totalCount"].asLong())
listOf("all", "public", "secret").forEach { assertEquals(0, data["counts"][it].asInt()) }
assertEquals(page, data["page"].asInt())
assertEquals(10, data["size"].asInt())
assertFalse(data["hasNext"].asBoolean())
}
}
@@ -0,0 +1,100 @@
package kr.co.vividnext.sodalive.v2.creator.admin.commentmanagement.donation
import kr.co.vividnext.sodalive.explorer.profile.channelDonation.ChannelDonationMessage
import kr.co.vividnext.sodalive.explorer.profile.channelDonation.ChannelDonationMessageRepository
import kr.co.vividnext.sodalive.i18n.Lang
import kr.co.vividnext.sodalive.member.Member
import kr.co.vividnext.sodalive.v2.creator.channel.donation.application.HideCreatorChannelDonationService
import kr.co.vividnext.sodalive.v2.creator.channel.donation.port.out.CreatorChannelDonationQueryPort
import kr.co.vividnext.sodalive.v2.creator.channel.home.port.out.CreatorChannelHomeQueryPort
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.DisplayName
import org.junit.jupiter.params.ParameterizedTest
import org.junit.jupiter.params.provider.ValueSource
import org.springframework.beans.factory.annotation.Autowired
class CreatorAdminDonationLegacyQueryIntegrationTest : CreatorAdminDonationTestSupport() {
@Autowired private lateinit var legacyRepository: ChannelDonationMessageRepository
@Autowired private lateinit var donationQuery: CreatorChannelDonationQueryPort
@Autowired private lateinit var homeQuery: CreatorChannelHomeQueryPort
@Autowired private lateinit var hideService: HideCreatorChannelDonationService
@ParameterizedTest
@ValueSource(strings = ["owner", "donor", "outsider", "otherCreator"])
@DisplayName("기존 숨김 서비스가 숨긴 공개·비밀 후원은 레거시 목록에서 제외된다")
fun shouldExcludeHiddenDonationsFromLegacyListForEveryViewer(viewerType: String) {
val visibleIds = createHiddenFixture()
val viewer = viewer(viewerType)
val expected = if (viewerType == "owner" || viewerType == "donor") visibleIds.reversed() else visibleIds.take(1)
val items = legacyRepository.getChannelDonationMessageList(
creatorId = requireNotNull(creator.id),
memberId = requireNotNull(viewer.id),
isCreator = viewerType == "owner",
offset = 0,
limit = 10,
startDateTime = storedAt.minusDays(1),
endDateTime = storedAt.plusDays(1),
lang = Lang.KO
)
assertEquals(expected, items.map { it.first.id })
}
@ParameterizedTest
@ValueSource(strings = ["owner", "donor", "outsider", "otherCreator"])
@DisplayName("기존 숨김 서비스가 숨긴 공개·비밀 후원은 레거시 전체 개수에서 제외된다")
fun shouldExcludeHiddenDonationsFromLegacyCountForEveryViewer(viewerType: String) {
createHiddenFixture()
val viewer = viewer(viewerType)
val count = legacyRepository.getChannelDonationMessageTotalCount(
creatorId = requireNotNull(creator.id),
memberId = requireNotNull(viewer.id),
isCreator = viewerType == "owner",
startDateTime = storedAt.minusDays(1),
endDateTime = storedAt.plusDays(1)
)
assertEquals(if (viewerType == "owner" || viewerType == "donor") 2 else 1, count)
}
@ParameterizedTest
@ValueSource(strings = ["owner", "donor", "outsider", "otherCreator"])
@DisplayName("동일한 숨김 데이터는 V2 채널 count·목록·홈에서 계속 제외된다")
fun shouldKeepHiddenDonationsExcludedFromV2ChannelAndHomeQueries(viewerType: String) {
val expected = createHiddenFixture().reversed()
val creatorId = requireNotNull(creator.id)
val viewerId = requireNotNull(viewer(viewerType).id)
val count = donationQuery.countChannelDonations(creatorId, viewerId, storedAt)
val items = donationQuery.findChannelDonations(creatorId, viewerId, storedAt, 0, 10, Lang.KO)
val home = homeQuery.findChannelDonations(creatorId, viewerId, storedAt, 8, Lang.KO)
assertEquals(2, count)
assertEquals(expected, items.map { it.donationId })
assertEquals(expected, home.map { it.donationId })
}
private fun createHiddenFixture(): List<Long> {
val visiblePublic = saveDonation(ChannelDonationMessage(10, additionalMessage = "visible public"))
val visibleSecret = saveDonation(ChannelDonationMessage(20, true, "visible secret"))
val hiddenPublic = saveDonation(ChannelDonationMessage(30, additionalMessage = "hidden public"))
val hiddenSecret = saveDonation(ChannelDonationMessage(40, true, "hidden secret"))
listOf(hiddenPublic, hiddenSecret).forEach { hideService.hide(requireNotNull(creator.id), it, creator) }
entityManager.flush()
entityManager.clear()
return listOf(visiblePublic, visibleSecret)
}
private fun viewer(type: String): Member = when (type) {
"owner" -> creator
"donor" -> donor
"otherCreator" -> otherCreator
"outsider" -> outsider
else -> error("Unsupported viewer: $type")
}
}
@@ -0,0 +1,97 @@
package kr.co.vividnext.sodalive.v2.creator.admin.commentmanagement.donation
import com.fasterxml.jackson.databind.JsonNode
import com.fasterxml.jackson.databind.ObjectMapper
import kr.co.vividnext.sodalive.explorer.profile.channelDonation.ChannelDonationMessage
import kr.co.vividnext.sodalive.member.Member
import kr.co.vividnext.sodalive.member.MemberAdapter
import kr.co.vividnext.sodalive.member.MemberRole
import kr.co.vividnext.sodalive.support.EmbeddedRedisInitializer
import org.junit.jupiter.api.BeforeEach
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc
import org.springframework.boot.test.context.SpringBootTest
import org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors.user
import org.springframework.test.context.ContextConfiguration
import org.springframework.test.web.servlet.MockMvc
import org.springframework.test.web.servlet.request.MockHttpServletRequestBuilder
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get
import org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath
import org.springframework.test.web.servlet.result.MockMvcResultMatchers.status
import org.springframework.transaction.annotation.Transactional
import java.time.LocalDateTime
import javax.persistence.EntityManager
@SpringBootTest(properties = ["spring.cache.type=none", "cloud.aws.cloud-front.host=https://cdn.test"])
@AutoConfigureMockMvc
@ContextConfiguration(initializers = [EmbeddedRedisInitializer::class])
@Transactional
abstract class CreatorAdminDonationTestSupport {
@Autowired protected lateinit var entityManager: EntityManager
@Autowired protected lateinit var mockMvc: MockMvc
@Autowired protected lateinit var objectMapper: ObjectMapper
protected lateinit var creator: Member
protected lateinit var otherCreator: Member
protected lateinit var donor: Member
protected lateinit var outsider: Member
protected val basePath = "/api/v2/creator-admin/comment-management/donations"
protected val storedAt: LocalDateTime = LocalDateTime.of(2026, 11, 5, 23, 59, 59)
@BeforeEach
fun createMembers() {
creator = saveMember("donation-owner", MemberRole.CREATOR)
otherCreator = saveMember("donation-other-owner", MemberRole.CREATOR)
donor = saveMember("donation-donor", MemberRole.USER)
outsider = saveMember("donation-outsider", MemberRole.USER)
}
protected fun saveMember(nickname: String, role: MemberRole): Member {
val member = Member(email = "$nickname@test.com", password = "password", nickname = nickname, role = role)
member.pgChargeCan = 700
member.pgRewardCan = 70
member.googleChargeCan = 800
member.googleRewardCan = 80
member.appleChargeCan = 900
member.appleRewardCan = 90
entityManager.persist(member)
return member
}
protected fun saveDonation(
donation: ChannelDonationMessage,
createdAt: LocalDateTime = storedAt,
owner: Member = creator
): Long {
donation.creator = owner
donation.member = donor
entityManager.persist(donation)
entityManager.flush()
entityManager.createQuery(
"update ChannelDonationMessage d set d.createdAt = :createdAt, d.updatedAt = :updatedAt where d.id = :id"
)
.setParameter("createdAt", createdAt)
.setParameter("updatedAt", createdAt.plusSeconds(1))
.setParameter("id", donation.id)
.executeUpdate()
entityManager.clear()
return requireNotNull(donation.id)
}
protected fun readList(request: MockHttpServletRequestBuilder = get(basePath)): JsonNode {
val result = mockMvc.perform(request.with(user(MemberAdapter(creator))))
.andExpect(status().isOk)
.andExpect(jsonPath("$.success").value(true))
.andReturn()
return objectMapper.readTree(result.response.contentAsByteArray)["data"]
}
protected fun reloadDonation(donationId: Long): ChannelDonationMessage {
entityManager.flush()
entityManager.clear()
return requireNotNull(entityManager.find(ChannelDonationMessage::class.java, donationId))
}
}