Files
sodalive-backend-spring-boot/src/main/kotlin/kr/co/vividnext/sodalive/content/LanguageDetectEvent.kt
T

401 lines
15 KiB
Kotlin

package kr.co.vividnext.sodalive.content
import kr.co.vividnext.sodalive.chat.character.comment.CharacterCommentRepository
import kr.co.vividnext.sodalive.chat.character.repository.ChatCharacterRepository
import kr.co.vividnext.sodalive.chat.original.OriginalWorkRepository
import kr.co.vividnext.sodalive.content.category.CategoryRepository
import kr.co.vividnext.sodalive.content.comment.AudioContentCommentRepository
import kr.co.vividnext.sodalive.content.series.ContentSeriesRepository
import kr.co.vividnext.sodalive.explorer.profile.CreatorCheersRepository
import kr.co.vividnext.sodalive.explorer.profile.creatorCommunity.CreatorCommunityRepository
import kr.co.vividnext.sodalive.i18n.translation.LanguageTranslationTargetType
import kr.co.vividnext.sodalive.i18n.translation.ResourceTranslationJobScheduler
import kr.co.vividnext.sodalive.i18n.translation.TranslationLanguages.getTranslatableLanguageCodes
import kr.co.vividnext.sodalive.v2.creator.channel.community.translation.application.CreatorCommunityTranslationService
import org.slf4j.LoggerFactory
import org.springframework.data.repository.findByIdOrNull
import org.springframework.scheduling.annotation.Async
import org.springframework.stereotype.Component
import org.springframework.transaction.annotation.Propagation
import org.springframework.transaction.annotation.Transactional
import org.springframework.transaction.event.TransactionPhase
import org.springframework.transaction.event.TransactionalEventListener
import org.springframework.transaction.support.TransactionSynchronization
import org.springframework.transaction.support.TransactionSynchronizationManager
import javax.persistence.EntityManager
import javax.persistence.LockModeType
/**
* 텍스트 기반 데이터(콘텐츠, 댓글 등)에 대해 언어 감지를 요청하기 위한 이벤트.
*/
enum class LanguageDetectTargetType {
CONTENT,
COMMENT,
CHARACTER,
CHARACTER_COMMENT,
CREATOR_CHEERS,
SERIES,
ORIGINAL_WORK,
CREATOR_CONTENT_CATEGORY,
CREATOR_COMMUNITY
}
class LanguageDetectEvent(
val id: Long,
val query: String,
val targetType: LanguageDetectTargetType = LanguageDetectTargetType.CONTENT,
val sourceRevision: Long? = null,
val targetLanguage: String? = null
)
@Component
class LanguageDetectListener(
private val audioContentRepository: AudioContentRepository,
private val audioContentCommentRepository: AudioContentCommentRepository,
private val chatCharacterRepository: ChatCharacterRepository,
private val characterCommentRepository: CharacterCommentRepository,
private val creatorCheersRepository: CreatorCheersRepository,
private val seriesRepository: ContentSeriesRepository,
private val originalWorkRepository: OriginalWorkRepository,
private val categoryRepository: CategoryRepository,
private val creatorCommunityRepository: CreatorCommunityRepository,
private val languageDetectionCacheService: LanguageDetectionCacheService,
private val creatorCommunityTranslationService: CreatorCommunityTranslationService,
private val entityManager: EntityManager,
private val resourceTranslationJobScheduler: ResourceTranslationJobScheduler
) {
private val log = LoggerFactory.getLogger(LanguageDetectListener::class.java)
@Async
@TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
@Transactional(propagation = Propagation.REQUIRES_NEW)
fun detectLanguage(event: LanguageDetectEvent) {
if (event.query.isBlank()) {
log.debug("[LanguageDetect] query is blank. Skip language detection. targetId={}", event.id)
return
}
when (event.targetType) {
LanguageDetectTargetType.CONTENT -> handleContentLanguageDetect(event)
LanguageDetectTargetType.COMMENT -> handleCommentLanguageDetect(event)
LanguageDetectTargetType.CHARACTER -> handleCharacterLanguageDetect(event)
LanguageDetectTargetType.CHARACTER_COMMENT -> handleCharacterCommentLanguageDetect(event)
LanguageDetectTargetType.CREATOR_CHEERS -> handleCreatorCheersLanguageDetect(event)
LanguageDetectTargetType.SERIES -> handleSeriesLanguageDetect(event)
LanguageDetectTargetType.ORIGINAL_WORK -> handleOriginalWorkLanguageDetect(event)
LanguageDetectTargetType.CREATOR_CONTENT_CATEGORY -> handleCreatorContentCategoryLanguageDetect(event)
LanguageDetectTargetType.CREATOR_COMMUNITY -> handleCreatorCommunityLanguageDetect(event)
}
}
private fun handleCharacterLanguageDetect(event: LanguageDetectEvent) {
val characterId = event.id
val character = chatCharacterRepository.findById(characterId).orElse(null)
if (character == null) {
log.warn("[LanguageDetect] ChatCharacter not found. characterId={}", characterId)
return
}
// 이미 언어 코드가 설정된 경우 호출하지 않음
if (!character.languageCode.isNullOrBlank()) {
log.debug(
"[LanguageDetect] languageCode already set. Skip language detection. characterId={}, languageCode={}",
characterId,
character.languageCode
)
return
}
val langCode = detectLanguageCode(event) ?: return
character.languageCode = langCode
chatCharacterRepository.save(character)
resourceTranslationJobScheduler.scheduleResourceTranslations(
resourceType = LanguageTranslationTargetType.CHARACTER,
resourceId = characterId
)
log.info(
"[LanguageDetect] languageCode updated. characterId={}, langCode={}",
characterId,
langCode
)
}
private fun handleContentLanguageDetect(event: LanguageDetectEvent) {
val contentId = event.id
val audioContent = audioContentRepository.findById(contentId).orElse(null)
if (audioContent == null) {
log.warn("[LanguageDetect] AudioContent not found. contentId={}", contentId)
return
}
// 이미 언어 코드가 설정된 경우 호출하지 않음
if (!audioContent.languageCode.isNullOrBlank()) {
log.debug(
"[LanguageDetect] languageCode already set. Skip language detection. contentId={}, languageCode={}",
contentId,
audioContent.languageCode
)
return
}
val langCode = detectLanguageCode(event) ?: return
audioContent.languageCode = langCode
// REQUIRES_NEW 트랜잭션 내에서 변경 내용을 저장한다.
audioContentRepository.save(audioContent)
resourceTranslationJobScheduler.scheduleResourceTranslations(
resourceType = LanguageTranslationTargetType.CONTENT,
resourceId = contentId
)
log.info(
"[LanguageDetect] languageCode updated. contentId={}, langCode={}",
contentId,
langCode
)
}
private fun handleCommentLanguageDetect(event: LanguageDetectEvent) {
val commentId = event.id
val comment = audioContentCommentRepository.findById(commentId).orElse(null)
if (comment == null) {
log.warn("[LanguageDetect] AudioContentComment not found. commentId={}", commentId)
return
}
// 이미 언어 코드가 설정된 경우 호출하지 않음
if (!comment.languageCode.isNullOrBlank()) {
log.debug(
"[LanguageDetect] languageCode already set. Skip language detection. commentId={}, languageCode={}",
commentId,
comment.languageCode
)
return
}
val langCode = detectLanguageCode(event) ?: return
comment.languageCode = langCode
audioContentCommentRepository.save(comment)
log.info(
"[LanguageDetect] languageCode updated. commentId={}, langCode={}",
commentId,
langCode
)
}
private fun handleCharacterCommentLanguageDetect(event: LanguageDetectEvent) {
val commentId = event.id
val comment = characterCommentRepository.findById(commentId).orElse(null)
if (comment == null) {
log.warn("[LanguageDetect] CharacterComment not found. commentId={}", commentId)
return
}
// 이미 언어 코드가 설정된 경우 호출하지 않음
if (!comment.languageCode.isNullOrBlank()) {
log.debug(
"[LanguageDetect] languageCode already set. Skip language detection. " +
"characterCommentId={}, languageCode={}",
commentId,
comment.languageCode
)
return
}
val langCode = detectLanguageCode(event) ?: return
comment.languageCode = langCode
characterCommentRepository.save(comment)
log.info(
"[LanguageDetect] languageCode updated. characterCommentId={}, langCode={}",
commentId,
langCode
)
}
private fun handleCreatorCheersLanguageDetect(event: LanguageDetectEvent) {
val cheersId = event.id
val cheers = creatorCheersRepository.findById(cheersId).orElse(null)
if (cheers == null) {
log.warn("[LanguageDetect] CreatorCheers not found. cheersId={}", cheersId)
return
}
// 이미 언어 코드가 설정된 경우 호출하지 않음
if (!cheers.languageCode.isNullOrBlank()) {
log.debug(
"[LanguageDetect] languageCode already set. Skip language detection. cheersId={}, languageCode={}",
cheersId,
cheers.languageCode
)
return
}
val langCode = detectLanguageCode(event) ?: return
cheers.languageCode = langCode
creatorCheersRepository.save(cheers)
log.info(
"[LanguageDetect] languageCode updated. cheersId={}, langCode={}",
cheersId,
langCode
)
}
private fun handleSeriesLanguageDetect(event: LanguageDetectEvent) {
val seriesId = event.id
val series = seriesRepository.findByIdOrNull(seriesId)
if (series == null) {
log.warn("[LanguageDetect] Series not found. seriesId={}", seriesId)
return
}
// 이미 언어 코드가 설정된 경우 호출하지 않음
if (!series.languageCode.isNullOrBlank()) {
log.debug(
"[LanguageDetect] languageCode already set. Skip language detection. seriesId={}, languageCode={}",
seriesId,
series.languageCode
)
return
}
val langCode = detectLanguageCode(event) ?: return
series.languageCode = langCode
seriesRepository.save(series)
resourceTranslationJobScheduler.scheduleResourceTranslations(
resourceType = LanguageTranslationTargetType.SERIES,
resourceId = seriesId
)
log.info(
"[LanguageDetect] languageCode updated. seriesId={}, langCode={}",
seriesId,
langCode
)
}
private fun handleOriginalWorkLanguageDetect(event: LanguageDetectEvent) {
val originalWorkId = event.id
val originalWork = originalWorkRepository.findByIdOrNull(originalWorkId)
if (originalWork == null) {
log.warn("[LanguageDetect] OriginalWork not found. originalWorkId={}", originalWorkId)
return
}
// 이미 언어 코드가 설정된 경우 호출하지 않음
if (!originalWork.languageCode.isNullOrBlank()) {
log.debug(
"[LanguageDetect] languageCode already set. Skip language detection. originalWorkId={}, languageCode={}",
originalWorkId,
originalWork.languageCode
)
return
}
val langCode = detectLanguageCode(event) ?: return
originalWork.languageCode = langCode
originalWorkRepository.save(originalWork)
resourceTranslationJobScheduler.scheduleResourceTranslations(
resourceType = LanguageTranslationTargetType.ORIGINAL_WORK,
resourceId = originalWorkId
)
log.info(
"[LanguageDetect] languageCode updated. originalWorkId={}, langCode={}",
originalWorkId,
langCode
)
}
private fun handleCreatorContentCategoryLanguageDetect(event: LanguageDetectEvent) {
val categoryId = event.id
val category = categoryRepository.findByIdOrNull(categoryId) ?: return
if (!category.languageCode.isNullOrBlank()) return
val langCode = detectLanguageCode(event) ?: return
category.languageCode = langCode
categoryRepository.save(category)
resourceTranslationJobScheduler.scheduleResourceTranslations(
resourceType = LanguageTranslationTargetType.CREATOR_CONTENT_CATEGORY,
resourceId = categoryId
)
}
private fun handleCreatorCommunityLanguageDetect(event: LanguageDetectEvent) {
val sourceRevision = event.sourceRevision ?: return
val creatorCommunity = creatorCommunityRepository.findByIdAndIsActiveTrue(event.id) ?: return
if (
creatorCommunity.contentRevision != sourceRevision ||
creatorCommunity.content != event.query
) {
return
}
if (!creatorCommunity.languageCode.isNullOrBlank()) {
requestTranslationsAfterCommit(event)
return
}
val languageCode = detectLanguageCode(event) ?: return
if (languageCode !in getTranslatableLanguageCodes(null)) return
val currentCreatorCommunity = creatorCommunityRepository.findByIdAndIsActiveTrueForUpdate(event.id) ?: return
entityManager.refresh(currentCreatorCommunity, LockModeType.PESSIMISTIC_WRITE)
if (
currentCreatorCommunity.contentRevision != sourceRevision ||
currentCreatorCommunity.content != event.query
) {
return
}
if (!currentCreatorCommunity.languageCode.isNullOrBlank()) {
requestTranslationsAfterCommit(event)
return
}
currentCreatorCommunity.languageCode = languageCode
creatorCommunityRepository.save(currentCreatorCommunity)
requestTranslationsAfterCommit(event)
}
private fun requestTranslationsAfterCommit(event: LanguageDetectEvent) {
TransactionSynchronizationManager.registerSynchronization(
object : TransactionSynchronization {
override fun afterCommit() {
creatorCommunityTranslationService.requestTranslations(event.id, event.targetLanguage)
}
}
)
}
private fun detectLanguageCode(event: LanguageDetectEvent): String? {
return languageDetectionCacheService.detectWithCache(event.query)?.detectedLanguage
}
}