[IDLE-577] 채팅 시스템 및 크롤링 공고 조회 최적화

idle-application/src/main/kotlin/com/swm/idle/application/chat/domain/ChatMessageService.kt

@@ -2,7 +2,6 @@ package com.swm.idle.application.chat.domain
 
 import com.swm.idle.domain.chat.entity.jpa.ChatMessage
 import com.swm.idle.domain.chat.repository.ChatMessageRepository
-import com.swm.idle.support.transfer.chat.ReadChatMessagesReqeust
 import com.swm.idle.support.transfer.chat.SendChatMessageRequest
 import jakarta.transaction.Transactional
 import org.springframework.stereotype.Service
@@ -13,21 +12,17 @@ class ChatMessageService (
     private val chatMessageRepository: ChatMessageRepository
 ){
     @Transactional
-    fun save(request: SendChatMessageRequest, userId: UUID): ChatMessage {
+    fun save(request: SendChatMessageRequest, userId: UUID, sequence: Long): ChatMessage {
         val message = ChatMessage(
             chatRoomId = UUID.fromString(request.chatroomId),
             content = request.content,
             senderId = userId,
             receiverId = UUID.fromString(request.receiverId),
+            sequence = sequence
         )
         return chatMessageRepository.save(message)
     }
 
-    @Transactional
-    fun read(request: ReadChatMessagesReqeust, readUserId: UUID) {
-        chatMessageRepository.readByChatroomId(UUID.fromString(request.chatroomId), readUserId)
-    }
-
     @Transactional
     fun getRecentMessages(chatroomId: UUID, messageId: UUID): List<ChatMessage> {
         return chatMessageRepository.getRecentMessages(chatroomId, messageId)

idle-application/src/main/kotlin/com/swm/idle/application/chat/domain/ChatRoomService.kt

@@ -3,38 +3,38 @@ package com.swm.idle.application.chat.domain
 import com.swm.idle.domain.chat.entity.jpa.ChatRoom
 import com.swm.idle.domain.chat.repository.ChatRoomRepository
 import com.swm.idle.domain.chat.vo.ChatRoomSummaryInfo
-import com.swm.idle.domain.chat.vo.ChatRoomSummaryInfoProjection
 import org.springframework.stereotype.Service
 import java.util.*
 
 @Service
-class ChatRoomService (val chatroomRepository: ChatRoomRepository){
+class ChatRoomService(
+    val chatroomRepository: ChatRoomRepository,
+){
 
     fun create(carerId: UUID, centerId: UUID): UUID {
         val existing = chatroomRepository.findByCarerIdAndCenterId(carerId, centerId)
         return existing?.id ?: chatroomRepository.save(ChatRoom(carerId = carerId, centerId = centerId)).id
     }
 
+    fun getById(chatRoomId: UUID): ChatRoom {
+        return chatroomRepository.findById(chatRoomId)
+            .orElseThrow()
+    }
 
-    fun findChatroomSummaries(userId: UUID, isCarer: Boolean): List<ChatRoomSummaryInfo> {
-        val projections: List<ChatRoomSummaryInfoProjection>
-        if(isCarer) {
-            projections = chatroomRepository.carerFindChatRooms(userId)
-        }else {
-            projections = chatroomRepository.centerFindChatRooms(userId)
-        }
+    fun findChatRoomsWithLastMessages(roomIds: Set<String>, isCarer: Boolean): List<ChatRoomSummaryInfo> {
+        val uuidSet = roomIds.map(UUID::fromString).toSet()
+        val projections = chatroomRepository.findChatRoomsWithLastMessages(uuidSet)
 
         return projections.map { projection ->
-            mappingChatRoomSummaryInfo(projection)
+            val opponentId = if (isCarer) projection.getCenterId() else projection.getCarerId()
+            ChatRoomSummaryInfo(
+                projection.getChatRoomId(),
+                opponentId,
+                projection.getLastMessage(),
+                projection.getLastMessageTime(),
+                projection.getLastSequence()?:1L
+            )
         }
     }
 
-    private fun mappingChatRoomSummaryInfo(projection: ChatRoomSummaryInfoProjection) =
-        ChatRoomSummaryInfo(
-            chatRoomId = projection.getChatRoomId(),
-            lastMessage = projection.getLastMessage(),
-            lastMessageTime = projection.getLastMessageTime(),
-            count = projection.getUnreadCount(),
-            opponentId = projection.getOpponentId()
-        )
 }

idle-application/src/main/kotlin/com/swm/idle/application/chat/facade/ChatFacadeService.kt

@@ -7,9 +7,13 @@ import com.swm.idle.application.notification.domain.DeviceTokenService
 import com.swm.idle.application.user.carer.domain.CarerService
 import com.swm.idle.application.user.center.service.domain.CenterManagerService
 import com.swm.idle.application.user.center.service.domain.CenterService
-import com.swm.idle.domain.chat.event.ChatRedisTemplate
+import com.swm.idle.domain.chat.entity.jpa.ChatMessage
+import com.swm.idle.domain.chat.event.ChatRedisPublisher
+import com.swm.idle.domain.chat.repository.ChatRedisRepository
 import com.swm.idle.domain.chat.vo.ChatRoomSummaryInfo
 import com.swm.idle.domain.chat.vo.ReadMessage
+import com.swm.idle.domain.user.carer.entity.jpa.Carer
+import com.swm.idle.domain.user.center.entity.jpa.Center
 import com.swm.idle.domain.user.center.entity.jpa.CenterManager
 import com.swm.idle.domain.user.center.exception.CenterException
 import com.swm.idle.domain.user.center.vo.BusinessRegistrationNumber
@@ -21,28 +25,48 @@ import org.springframework.transaction.annotation.Transactional
 import java.util.*
 
 @Service
-@Transactional(readOnly = true)
 class ChatFacadeService(
     private val centerManagerService: CenterManagerService,
-    private val chatRedisTemplate: ChatRedisTemplate,
+    private val chatRedisPublisher: ChatRedisPublisher,
     private val messageService: ChatMessageService,
     private val notificationService: ChatNotificationService,
     private val deviceTokenService: DeviceTokenService,
     private val chatMessageService: ChatMessageService,
     private val chatroomService: ChatRoomService,
     private val centerService: CenterService,
     private val carerService: CarerService,
+    private val chatRedisRepository: ChatRedisRepository,
 ) {
 
     @Transactional
-    fun carerSend(request: SendChatMessageRequest, carerId: UUID) {
-        val message = messageService.save(request, carerId)
-        chatRedisTemplate.publish(message)
+    fun send(request: SendChatMessageRequest, inputId: UUID, isCarer: Boolean) {
+        val userId = if(isCarer) inputId else  getCenterId(inputId)
+        val sequence = chatRedisRepository.getChatRoomSequence(request.chatroomId)
+        val message = messageService.save(request, userId, sequence)
 
-        for(manager in getManagersByCenterId(UUID.fromString(request.receiverId))) {
-            if (chatRedisTemplate.isChatting(manager.id)) continue
+        chatRedisRepository.addUnreadChatRoom(request.receiverId, request.chatroomId)
+        chatRedisRepository.updateReadSequence(request.chatroomId, message.sequence.toString(), userId)
 
-            val token = deviceTokenService.findByUserId(manager.id)
+        chatRedisPublisher.publish(message)
+
+        sendNotification(message, request, isCarer)
+    }
+
+    private fun sendNotification(
+        message: ChatMessage,
+        request: SendChatMessageRequest,
+        isCarer: Boolean
+    ) {
+        if(isCarer) {
+            for (manager in getManagersByCenterId(UUID.fromString(request.receiverId))) {
+                if (chatRedisRepository.isChatting(manager.id)) continue
+
+                val token = deviceTokenService.findByUserId(manager.id) ?: continue
+                notificationService.send(message, request.senderName, token)
+            }
+        }else{
+            if (chatRedisRepository.isChatting(message.receiverId)) return
+            val token = deviceTokenService.findByUserId(message.receiverId) ?: return
             notificationService.send(message, request.senderName, token)
         }
     }
@@ -54,40 +78,25 @@ class ChatFacadeService(
     }
 
     @Transactional
-    fun centerSend(request: SendChatMessageRequest, managerId: UUID) {
-        val centerId = getCenterId(managerId)
-        val message = messageService.save(request, centerId)
-        chatRedisTemplate.publish(message)
-
-        if (chatRedisTemplate.isChatting(message.receiverId)) return
-
-        val token = deviceTokenService.findByUserId(message.receiverId)
-        notificationService.send(message, request.senderName, token)
-    }
-
-    @Transactional
-    fun carerRead(request: ReadChatMessagesReqeust, carerId: UUID) {
-        messageService.read(request, carerId)
+    fun read(request: ReadChatMessageRequest, inputId: UUID, isCarer: Boolean) {
+        val userId = if(isCarer) inputId else  getCenterId(inputId)
+        chatRedisRepository.removeUnreadChatRoom(userId ,request.chatroomId)
+        chatRedisRepository.updateReadSequence(request.chatroomId, request.sequence, userId)
 
         val readMessage = ReadMessage(
             chatRoomId = UUID.fromString(request.chatroomId),
             receiverId = UUID.fromString(request.opponentId),
-            readUserId = carerId
+            readUserId = userId,
+            sequence = request.sequence.toLong()
         )
-        chatRedisTemplate.publish(readMessage)
+        chatRedisPublisher.publish(readMessage)
     }
 
-    @Transactional
-    fun centerRead(request: ReadChatMessagesReqeust, managerId: UUID) {
-        val centerId = getCenterId(managerId)
-        messageService.read(request, centerId)
-
-        val readMessage = ReadMessage(
-            chatRoomId = UUID.fromString(request.chatroomId),
-            receiverId = UUID.fromString(request.opponentId),
-            readUserId = centerId
-        )
-        chatRedisTemplate.publish(readMessage)
+    private fun getCenterId(managerId:UUID): UUID {
+        val manager = centerManagerService.getById(managerId)
+        val businessNumber = BusinessRegistrationNumber(manager.centerBusinessRegistrationNumber)
+        val center = centerService.findByBusinessRegistrationNumber(businessNumber)?: throw CenterException.NotFoundException()
+        return center.id
     }
 
     @Transactional
@@ -112,36 +121,54 @@ class ChatFacadeService(
         return center.id
     }
 
-    fun getRecentMessages(chatRoomId: UUID, messageId: UUID?): List<ChatMessageResponse> {
-        val effectiveMessageId = messageId ?: UuidCreator.create()
-
-        return chatMessageService.getRecentMessages(chatRoomId, effectiveMessageId)
-            .map { ChatMessageResponse(it) }
+    @Transactional(readOnly = true)
+    fun getRecentMessages(
+        chatRoomId: UUID,
+        messageId: UUID?,
+        isCarer: Boolean
+    ): ChatMessageResponse {
+        val lastMessageId = messageId ?: UuidCreator.create()
+        val messages = chatMessageService.getRecentMessages(chatRoomId, lastMessageId)
+        val messageInfo = messages.map { ChatMessageInfo(it) }
+
+        val chatRoom = chatroomService.getById(chatRoomId)
+        val opponentId = if (isCarer) chatRoom.centerId else chatRoom.carerId
+        val opponentReadSequence = chatRedisRepository.getReadSequence(opponentId, chatRoomId)
+
+        return ChatMessageResponse(messageInfo, opponentReadSequence)
     }
 
+    @Transactional(readOnly = true)
     fun getChatroomSummary(isCarer: Boolean): List<ChatRoomSummaryInfo> {
-        val userId: UUID = if (isCarer) getUserAuthentication().userId
-        else getCenterIdByAuthentication()
-
-        val summary = chatroomService.findChatroomSummaries(userId, isCarer)
-
-        return if (isCarer) {
-            summary.map {
-                val center = centerService.getById(it.opponentId)
-                it.copy(opponentName = center.centerName, opponentProfileImageUrl = center.profileImageUrl)
-            }
+        val userId = if (isCarer) getUserAuthentication().userId else getCenterIdByAuthentication()
+        val unreadChatRoomIds = chatRedisRepository.getUnreadChatRooms(userId)
+        val readSequences = chatRedisRepository.getReadSequences(userId, unreadChatRoomIds)
+        val summaries = chatroomService.findChatRoomsWithLastMessages(unreadChatRoomIds, isCarer)
+
+        val opponentIds = summaries.map { it.opponentId }.toSet()
+        val opponentInfoMap = if (isCarer) {
+            centerService.getByIds(opponentIds).associateBy { it.id }
         } else {
-            summary.map {
-                val carer = carerService.getById(it.opponentId)
-                it.copy(opponentName = carer.name, opponentProfileImageUrl = carer.profileImageUrl)
-            }
+            carerService.getByIds(opponentIds).associateBy { it.id }
         }
-    }
 
-    private fun getCenterId(managerId:UUID): UUID {
-        val manager = centerManagerService.getById(managerId)
-        val businessNumber = BusinessRegistrationNumber(manager.centerBusinessRegistrationNumber)
-        val center = centerService.findByBusinessRegistrationNumber(businessNumber)?: throw CenterException.NotFoundException()
-        return center.id
+        return summaries.map { summary ->
+            val readSeq = readSequences[summary.chatRoomId.toString()] ?: 0L
+            summary.count = (summary.count - readSeq).coerceAtLeast(1)
+
+            val opponent = opponentInfoMap[summary.opponentId]
+            summary.apply {
+                when (opponent) {
+                    is Center -> {
+                        opponentName = opponent.centerName
+                        opponentProfileImageUrl = opponent.profileImageUrl
+                    }
+                    is Carer -> {
+                        opponentName = opponent.name
+                        opponentProfileImageUrl = opponent.profileImageUrl
+                    }
+                }
+            }
+        }
     }
 }

idle-application/src/main/kotlin/com/swm/idle/application/common/converter/PointConverter.kt

@@ -1,5 +1,6 @@
 package com.swm.idle.application.common.converter
 
+import com.swm.idle.domain.user.carer.entity.jpa.Carer
 import org.locationtech.jts.geom.Coordinate
 import org.locationtech.jts.geom.GeometryFactory
 import org.locationtech.jts.geom.Point
@@ -14,14 +15,14 @@ object PointConverter {
         SPATIAL_REFERENCE_IDENTIFIER_NUMBER
     )
 
-    fun convertToPoint(
-        latitude: Double,
-        longitude: Double,
-    ): Point {
-        val correctedLongitude = if (longitude > latitude) longitude else latitude
-        val correctedLatitude = if (longitude > latitude) latitude else longitude
+    fun convertToPoint(carer: Carer): Point {
+        val latitude = carer.latitude.toDouble()
+        val longitude = carer.longitude.toDouble()
 
-        return geometryFactory.createPoint(Coordinate(correctedLongitude, correctedLatitude))
+        return geometryFactory.createPoint(Coordinate(longitude, latitude))
     }
 
-}
+    fun convertToPoint(latitude: Double, longitude: Double ): Point {
+        return geometryFactory.createPoint(Coordinate(longitude, latitude))
+    }
+}

idle-application/src/main/kotlin/com/swm/idle/application/jobposting/domain/CrawlingJobPostingService.kt

@@ -4,7 +4,7 @@ import com.swm.idle.domain.common.dto.CrawlingJobPostingPreviewDto
 import com.swm.idle.domain.common.exception.PersistenceException
 import com.swm.idle.domain.jobposting.entity.jpa.CrawledJobPosting
 import com.swm.idle.domain.jobposting.repository.jpa.CrawlingJobPostingJpaRepository
-import com.swm.idle.domain.jobposting.repository.querydsl.CrawlingJobPostingSpatialQueryRepository
+import com.swm.idle.domain.jobposting.repository.redis.RedisJobPostingRepository
 import org.locationtech.jts.geom.Point
 import org.springframework.data.repository.findByIdOrNull
 import org.springframework.stereotype.Service
@@ -15,33 +15,26 @@ import java.util.*
 @Transactional(readOnly = true)
 class CrawlingJobPostingService(
     private val crawlingJobPostingJpaRepository: CrawlingJobPostingJpaRepository,
-    private val crawlingJobPostingSpatialQueryRepository: CrawlingJobPostingSpatialQueryRepository,
+    private val redisJobPostingRepository: RedisJobPostingRepository,
 ) {
 
-    @Transactional
-    fun saveAll(crawledJobPostings: List<CrawledJobPosting>) {
-        crawlingJobPostingJpaRepository.saveAll(crawledJobPostings)
-    }
-
     fun getById(crawlingJobPostingId: UUID): CrawledJobPosting {
         return crawlingJobPostingJpaRepository.findByIdOrNull(crawlingJobPostingId)
             ?: throw PersistenceException.ResourceNotFound("크롤링한 구인 공고(id=$crawlingJobPostingId)를 찾을 수 없습니다")
     }
 
-    fun findAllByCarerLocationInRange(
-        carerId: UUID,
-        location: Point,
+    fun findAllInRange(
         next: UUID?,
-        limit: Long,
+        location: Point,
+        distance: Long,
+        limit: Long
     ): List<CrawlingJobPostingPreviewDto> {
-        return crawlingJobPostingSpatialQueryRepository.findAllInRange(
-            carerId = carerId,
-            location = location,
-            next = next,
-            limit = limit,
-        )
+        val postingIds = redisJobPostingRepository.findByLocationAndDistance(location, distance, limit, next)
+        val postings = crawlingJobPostingJpaRepository.findAllById(postingIds)
+        return postings.map { CrawlingJobPostingPreviewDto(it, distance.toInt()) }
     }
 
+
     fun calculateDistance(
         crawledJobPosting: CrawledJobPosting,
         carerLocation: Point,