[WTH-415] 파일 삭제 구현

src/main/kotlin/com/weeth/domain/account/application/usecase/command/ManageReceiptUseCase.kt

@@ -12,22 +12,24 @@ import com.weeth.domain.account.domain.vo.Money
 import com.weeth.domain.cardinal.domain.repository.CardinalReader
 import com.weeth.domain.club.domain.service.ClubPermissionPolicy
 import com.weeth.domain.file.application.mapper.FileMapper
+import com.weeth.domain.file.domain.entity.File
 import com.weeth.domain.file.domain.enums.FileOwnerType
-import com.weeth.domain.file.domain.repository.FileReader
 import com.weeth.domain.file.domain.repository.FileRepository
 import org.springframework.data.repository.findByIdOrNull
 import org.springframework.stereotype.Service
 import org.springframework.transaction.annotation.Transactional
+import java.time.Clock
+import java.time.LocalDateTime
 
 @Service
 class ManageReceiptUseCase(
     private val receiptRepository: ReceiptRepository,
     private val accountRepository: AccountRepository,
-    private val fileReader: FileReader,
     private val fileRepository: FileRepository,
     private val cardinalReader: CardinalReader,
     private val clubPermissionPolicy: ClubPermissionPolicy,
     private val fileMapper: FileMapper,
+    private val clock: Clock,
 ) {
     @Transactional
     fun save(
@@ -70,7 +72,7 @@ class ManageReceiptUseCase(
         account.adjustSpend(Money.of(receipt.amount), Money.of(request.amount))
 
         if (request.files != null) {
-            fileRepository.deleteAll(fileReader.findAll(FileOwnerType.RECEIPT, receiptId, null))
+            markReceiptFilesDeleted(receiptId)
             fileRepository.saveAll(fileMapper.toFileList(request.files, FileOwnerType.RECEIPT, receiptId))
         }
 
@@ -90,7 +92,20 @@ class ManageReceiptUseCase(
 
         receipt.account.cancelSpend(Money.of(receipt.amount))
 
-        fileRepository.deleteAll(fileReader.findAll(FileOwnerType.RECEIPT, receiptId, null))
+        markReceiptFilesDeleted(receiptId)
         receiptRepository.delete(receipt)
     }
+
+    /**
+     * 영수증 파일 교체/명시 삭제는 복구 대상이 아니므로 즉시 정리 대상으로 표시
+     */
+    private fun markReceiptFilesDeleted(receiptId: Long) {
+        val now = LocalDateTime.now(clock)
+        fileRepository.markActiveDeletedByOwnerTypeAndOwnerId(
+            ownerType = FileOwnerType.RECEIPT,
+            ownerId = receiptId,
+            deletedAt = now,
+            hardDeleteAfter = File.immediateHardDeleteAfter(now),
+        )
+    }
 }

src/main/kotlin/com/weeth/domain/board/application/usecase/command/ManagePostUseCase.kt

@@ -17,11 +17,13 @@ import com.weeth.domain.club.domain.repository.ClubMemberCardinalReader
 import com.weeth.domain.club.domain.service.ClubMemberPolicy
 import com.weeth.domain.file.application.dto.request.FileSaveRequest
 import com.weeth.domain.file.application.mapper.FileMapper
+import com.weeth.domain.file.domain.entity.File
 import com.weeth.domain.file.domain.enums.FileOwnerType
-import com.weeth.domain.file.domain.repository.FileReader
 import com.weeth.domain.file.domain.repository.FileRepository
 import org.springframework.stereotype.Service
 import org.springframework.transaction.annotation.Transactional
+import java.time.Clock
+import java.time.LocalDateTime
 
 @Service
 class ManagePostUseCase(
@@ -30,9 +32,9 @@ class ManagePostUseCase(
     private val clubMemberPolicy: ClubMemberPolicy,
     private val clubMemberCardinalReader: ClubMemberCardinalReader,
     private val fileRepository: FileRepository,
-    private val fileReader: FileReader,
     private val fileMapper: FileMapper,
     private val postMapper: PostMapper,
+    private val clock: Clock,
 ) {
     @Transactional
     fun save(
@@ -153,12 +155,16 @@ class ManagePostUseCase(
         }
     }
 
+    /**
+     * 게시글 파일 교체/명시 삭제는 복구 대상이 아니므로 즉시 정리 대상으로 표시
+     */
     private fun deletePostFiles(postId: Long) {
-        val files = fileReader.findAll(FileOwnerType.POST, postId)
-
-        if (files.isNotEmpty()) {
-            fileRepository.deleteAll(files)
-            fileRepository.flush()
-        }
+        val now = LocalDateTime.now(clock)
+        fileRepository.markActiveDeletedByOwnerTypeAndOwnerId(
+            ownerType = FileOwnerType.POST,
+            ownerId = postId,
+            deletedAt = now,
+            hardDeleteAfter = File.immediateHardDeleteAfter(now),
+        )
     }
 }

src/main/kotlin/com/weeth/domain/board/domain/repository/PostLikeRepository.kt

@@ -37,6 +37,24 @@ interface PostLikeRepository :
         @Param("clubId") clubId: Long,
     ): List<Long>
 
+    @Query(
+        """
+        SELECT p.id
+        FROM PostLike pl
+        JOIN pl.post p
+        JOIN p.board b
+        WHERE pl.userId = :userId
+          AND b.club.id IN :clubIds
+          AND pl.isActive = true
+          AND pl.deletedAt IS NULL
+        ORDER BY p.id ASC
+        """,
+    )
+    fun findActivePostIdsByUserIdAndClubIdIn(
+        @Param("userId") userId: Long,
+        @Param("clubIds") clubIds: List<Long>,
+    ): List<Long>
+
     @Query(
         """
         SELECT pl

src/main/kotlin/com/weeth/domain/board/domain/repository/PostRepository.kt

@@ -217,4 +217,18 @@ interface PostRepository :
     fun countActivePostsByBoardIds(
         @Param("boardIds") boardIds: List<Long>,
     ): List<BoardPostCount>
+
+    @Query(
+        """
+        SELECT p.id
+        FROM Post p
+        WHERE p.clubMember.id IN :clubMemberIds
+          AND p.isDeleted = false
+          AND p.board.isDeleted = false
+        ORDER BY p.id ASC
+        """,
+    )
+    fun findActiveIdsByClubMemberIdIn(
+        @Param("clubMemberIds") clubMemberIds: List<Long>,
+    ): List<Long>
 }

src/main/kotlin/com/weeth/domain/club/application/usecase/command/ManageClubMemberUsecase.kt

@@ -22,8 +22,6 @@ import com.weeth.domain.club.domain.service.ClubJoinPolicy
 import com.weeth.domain.club.domain.service.ClubMemberPolicy
 import com.weeth.domain.file.domain.entity.File
 import com.weeth.domain.file.domain.enums.FileOwnerType
-import com.weeth.domain.file.domain.enums.FileStatus
-import com.weeth.domain.file.domain.port.FileAccessUrlPort
 import com.weeth.domain.file.domain.repository.FileRepository
 import com.weeth.domain.user.application.exception.UserInActiveException
 import com.weeth.domain.user.domain.repository.UserReader
@@ -47,7 +45,6 @@ class ManageClubMemberUsecase(
     private val clubJoinPolicy: ClubJoinPolicy,
     private val clubActivityDeletionPolicy: ClubActivityDeletionPolicy,
     private val fileRepository: FileRepository,
-    private val fileAccessUrlPort: FileAccessUrlPort,
     private val clock: Clock,
 ) {
     /**
@@ -92,19 +89,11 @@ class ManageClubMemberUsecase(
         userId: Long,
         request: UpdateMemberProfileRequest,
     ) {
-        val members = clubMemberRepository.findActiveByUserId(userId)
+        val members = clubMemberRepository.findAllActiveByUserIdWithLock(userId)
         if (members.isEmpty()) throw ClubMemberNotFoundException()
 
         request.profileImage?.let { profileImage ->
-            val existingFiles =
-                fileRepository.findAllByOwnerTypeAndOwnerIdAndStatus(
-                    FileOwnerType.CLUB_MEMBER_PROFILE,
-                    userId,
-                    FileStatus.UPLOADED,
-                )
-            if (existingFiles.isNotEmpty()) {
-                fileRepository.deleteAll(existingFiles)
-            }
+            markFilesDeleted(userId)
 
             val file =
                 File.createUploaded(
@@ -125,18 +114,10 @@ class ManageClubMemberUsecase(
 
     @Transactional
     fun deleteProfileImage(userId: Long) {
-        val members = clubMemberRepository.findActiveByUserId(userId)
+        val members = clubMemberRepository.findAllActiveByUserIdWithLock(userId)
         if (members.isEmpty()) throw ClubMemberNotFoundException()
 
-        val existingFiles =
-            fileRepository.findAllByOwnerTypeAndOwnerIdAndStatus(
-                FileOwnerType.CLUB_MEMBER_PROFILE,
-                userId,
-                FileStatus.UPLOADED,
-            )
-        if (existingFiles.isNotEmpty()) {
-            fileRepository.deleteAll(existingFiles)
-        }
+        markFilesDeleted(userId)
 
         members.forEach { it.removeProfileImage() }
     }
@@ -186,4 +167,17 @@ class ManageClubMemberUsecase(
         clubActivityDeletionPolicy.markMemberActivitiesDeleted(member, now)
         member.leave(now)
     }
+
+    /**
+     * 프로필 이미지 교체/명시 삭제는 복구 대상이 아니므로 즉시 정리 대상으로 표시
+     */
+    private fun markFilesDeleted(userId: Long) {
+        val now = LocalDateTime.now(clock)
+        fileRepository.markActiveDeletedByOwnerTypeAndOwnerId(
+            ownerType = FileOwnerType.CLUB_MEMBER_PROFILE,
+            ownerId = userId,
+            deletedAt = now,
+            hardDeleteAfter = File.immediateHardDeleteAfter(now),
+        )
+    }
 }

src/main/kotlin/com/weeth/domain/club/application/usecase/command/ManageClubUseCase.kt

@@ -28,12 +28,13 @@ import com.weeth.domain.club.domain.vo.ClubContact
 import com.weeth.domain.file.application.dto.request.FileSaveRequest
 import com.weeth.domain.file.domain.entity.File
 import com.weeth.domain.file.domain.enums.FileOwnerType
-import com.weeth.domain.file.domain.enums.FileStatus
 import com.weeth.domain.file.domain.repository.FileRepository
 import com.weeth.domain.user.application.exception.UserInActiveException
 import com.weeth.domain.user.domain.repository.UserReader
 import org.springframework.stereotype.Service
 import org.springframework.transaction.annotation.Transactional
+import java.time.Clock
+import java.time.LocalDateTime
 
 /**
  * 동아리 관리 유스케이스
@@ -51,6 +52,7 @@ class ManageClubUseCase(
     private val clubPermissionPolicy: ClubPermissionPolicy,
     private val fileRepository: FileRepository,
     private val clubMapper: ClubMapper,
+    private val clock: Clock,
 ) {
     /**
      * 새로운 동아리를 생성
@@ -235,15 +237,20 @@ class ManageClubUseCase(
         fileRepository.save(file)
     }
 
+    /**
+     * 동아리 이미지 교체/명시 삭제는 복구 대상이 아니므로 즉시 정리 대상으로 표시
+     */
     private fun deleteExistingFiles(
         ownerType: FileOwnerType,
         ownerId: Long,
     ) {
-        val files = fileRepository.findAllByOwnerTypeAndOwnerIdAndStatus(ownerType, ownerId, FileStatus.UPLOADED)
-
-        if (files.isNotEmpty()) {
-            fileRepository.deleteAll(files)
-        }
+        val now = LocalDateTime.now(clock)
+        fileRepository.markActiveDeletedByOwnerTypeAndOwnerId(
+            ownerType = ownerType,
+            ownerId = ownerId,
+            deletedAt = now,
+            hardDeleteAfter = File.immediateHardDeleteAfter(now),
+        )
     }
 
     private fun validatePrimaryContactEmail(

src/main/kotlin/com/weeth/domain/club/domain/service/ClubActivityDeletionPolicy.kt

@@ -3,6 +3,10 @@ package com.weeth.domain.club.domain.service
 import com.weeth.domain.board.domain.repository.PostLikeRepository
 import com.weeth.domain.board.domain.repository.PostRepository
 import com.weeth.domain.club.domain.entity.ClubMember
+import com.weeth.domain.comment.domain.repository.CommentRepository
+import com.weeth.domain.file.domain.entity.File
+import com.weeth.domain.file.domain.enums.FileOwnerType
+import com.weeth.domain.file.domain.repository.FileRepository
 import org.springframework.stereotype.Service
 import java.time.LocalDateTime
 
@@ -19,31 +23,83 @@ import java.time.LocalDateTime
 class ClubActivityDeletionPolicy(
     private val postLikeRepository: PostLikeRepository,
     private val postRepository: PostRepository,
+    private val commentRepository: CommentRepository,
+    private val fileRepository: FileRepository,
 ) {
     fun markMemberActivitiesDeleted(
         member: ClubMember,
         now: LocalDateTime,
     ) {
-        val postIds =
-            postLikeRepository
-                .findActivePostIdsByUserIdAndClubId(
-                    userId = member.user.id,
-                    clubId = member.club.id,
-                ).distinct()
-                .sorted()
-
-        if (postIds.isEmpty()) return
-
-        val postsById = postRepository.findAllByIdsWithLock(postIds).associateBy { it.id }
-        if (postsById.isEmpty()) return
-
-        postLikeRepository
-            .findAllActiveByUserIdAndPostIds(
-                userId = member.user.id,
-                postIds = postsById.keys.toList(),
-            ).forEach { like ->
-                if (!like.markDeleted(now)) return@forEach
-                postsById.getValue(like.post.id).decreaseLikeCount()
+        markMembersActivitiesDeleted(listOf(member), now)
+    }
+
+    fun markMembersActivitiesDeleted(
+        members: List<ClubMember>,
+        now: LocalDateTime,
+    ) {
+        if (members.isEmpty()) return
+
+        markMembersFilesDeleted(members, now)
+        markMembersPostLikesDeleted(members, now)
+    }
+
+    private fun markMembersFilesDeleted(
+        members: List<ClubMember>,
+        now: LocalDateTime,
+    ) {
+        val memberIds = members.map { it.id }.distinct().sorted()
+        val postIds = postRepository.findActiveIdsByClubMemberIdIn(memberIds)
+        val commentIds = commentRepository.findActiveIdsByClubMemberIdIn(memberIds)
+
+        markFilesDeleted(FileOwnerType.POST, postIds, now)
+        markFilesDeleted(FileOwnerType.COMMENT, commentIds, now)
+    }
+
+    private fun markFilesDeleted(
+        ownerType: FileOwnerType,
+        ownerIds: List<Long>,
+        now: LocalDateTime,
+    ) {
+        if (ownerIds.isEmpty()) return
+
+        fileRepository.markActiveDeletedByOwnerTypeAndOwnerIdIn(
+            ownerType = ownerType,
+            ownerIds = ownerIds,
+            deletedAt = now,
+            hardDeleteAfter = File.retainedHardDeleteAfter(now),
+        )
+    }
+
+    private fun markMembersPostLikesDeleted(
+        members: List<ClubMember>,
+        now: LocalDateTime,
+    ) {
+        members
+            .groupBy { it.user.id }
+            .forEach { (userId, userMembers) ->
+                val clubIds = userMembers.map { it.club.id }.distinct().sorted()
+                val postIds =
+                    postLikeRepository
+                        .findActivePostIdsByUserIdAndClubIdIn(
+                            userId = userId,
+                            clubIds = clubIds,
+                        ).distinct()
+                        .sorted()
+
+                if (postIds.isEmpty()) return@forEach
+
+                val postsById = postRepository.findAllByIdsWithLock(postIds).associateBy { it.id }
+
+                val likes =
+                    postLikeRepository.findAllActiveByUserIdAndPostIds(
+                        userId = userId,
+                        postIds = postIds,
+                    )
+
+                for (like in likes) {
+                    if (!like.markDeleted(now)) continue
+                    postsById[like.post.id]?.decreaseLikeCount()
+                }
             }
     }
 }