401 lines
15 KiB
Kotlin
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
|
|
}
|
|
}
|