[TASK] 모임 생성과 수정 images 필드 동일하게 수정

LimdaeIl · web-flow · commit 5c59768a8666 · 2025-12-23T17:22:03.000+09:00
diff --git a/src/main/java/team/wego/wegobackend/group/domain/exception/GroupErrorCode.java b/src/main/java/team/wego/wegobackend/group/domain/exception/GroupErrorCode.java
@@ -8,6 +8,18 @@
 @Getter
 @RequiredArgsConstructor
 public enum GroupErrorCode implements ErrorCode {
+    INVALID_GROUP_IMAGE_ITEM(HttpStatus.BAD_REQUEST,
+            "모임: images 항목이 올바르지 않습니다. 모임 ID: %s 회원 ID: %s"
+    ),
+    INVALID_GROUP_IMAGE_KEY(HttpStatus.BAD_REQUEST,
+            "모임: imageKey는 필수이며 공백일 수 없습니다. 모임 ID: %s 회원 ID: %s"
+    ),
+    DUPLICATED_IMAGE_SORT_ORDER_IN_REQUEST(HttpStatus.BAD_REQUEST,
+            "모임: images 내 sortOrder가 중복되었습니다. 모임 ID: %s 회원 ID: %s"
+    ),
+    INVALID_GROUP_IMAGE_SORT_ORDER_RANGE(HttpStatus.BAD_REQUEST,
+            "모임: images 내 sortOrder 범위가 올바르지 않습니다. (허용: 0~2) 모임 ID: %s 회원 ID: %s"
+    ),
     NO_PERMISSION_TO_VIEW_BANNED_TARGETS(HttpStatus.FORBIDDEN,
             "모임: BANNED(차단) 대상 목록 조회 권한이 없습니다. 모임 ID: %s 회원 ID: %s"
     ),
diff --git a/src/main/java/team/wego/wegobackend/group/v2/application/dto/request/CreateGroupImageV2Request.java b/src/main/java/team/wego/wegobackend/group/v2/application/dto/request/CreateGroupImageV2Request.java
@@ -1,10 +1,12 @@
 package team.wego.wegobackend.group.v2.application.dto.request;
 
-import jakarta.validation.constraints.Min;
+import jakarta.validation.constraints.Max;
 
 public record CreateGroupImageV2Request(
         String imageKey,
 
-        @Min(value = 0, message = "모임 이미지: 모임 이미지 순서는 0 이상 숫자만 가능합니다.")
+        @Max(value = 3, message = "모임 이미지: 모임 이미지 순서는 2 이하만 가능합니다.")
         Integer sortOrder
-) {}
+) {
+
+}
diff --git a/src/main/java/team/wego/wegobackend/group/v2/application/dto/request/UpdateGroupV2Request.java b/src/main/java/team/wego/wegobackend/group/v2/application/dto/request/UpdateGroupV2Request.java
@@ -1,5 +1,8 @@
 package team.wego.wegobackend.group.v2.application.dto.request;
 
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.Max;
+import jakarta.validation.constraints.Min;
 import jakarta.validation.constraints.Size;
 import java.time.LocalDateTime;
 import java.util.List;
@@ -29,8 +32,8 @@ public record UpdateGroupV2Request(
         @Size(max = 10)
         List<String> tags,
 
-        @Size(max = 3)
-        List<String> images
+        @Valid
+        List<CreateGroupImageV2Request> images
 ) {
 
 }
diff --git a/src/main/java/team/wego/wegobackend/group/v2/application/service/GroupV2UpdateService.java b/src/main/java/team/wego/wegobackend/group/v2/application/service/GroupV2UpdateService.java
@@ -16,17 +16,15 @@
 import team.wego.wegobackend.group.domain.exception.GroupException;
 import team.wego.wegobackend.group.v2.application.dto.common.Address;
 import team.wego.wegobackend.group.v2.application.dto.common.GroupImageItem;
-import team.wego.wegobackend.group.v2.application.dto.common.GroupImageVariantItem;
 import team.wego.wegobackend.group.v2.application.dto.common.PreUploadedGroupImage;
+import team.wego.wegobackend.group.v2.application.dto.request.CreateGroupImageV2Request;
 import team.wego.wegobackend.group.v2.application.dto.request.UpdateGroupV2Request;
 import team.wego.wegobackend.group.v2.application.dto.response.UpdateGroupV2Response;
 import team.wego.wegobackend.group.v2.domain.entity.GroupImageV2;
-import team.wego.wegobackend.group.v2.domain.entity.GroupImageV2VariantType;
 import team.wego.wegobackend.group.v2.domain.entity.GroupTagV2;
 import team.wego.wegobackend.group.v2.domain.entity.GroupUserV2Status;
 import team.wego.wegobackend.group.v2.domain.entity.GroupV2;
 import team.wego.wegobackend.group.v2.domain.entity.GroupV2Address;
-import team.wego.wegobackend.group.v2.domain.entity.ImageV2Format;
 import team.wego.wegobackend.group.v2.domain.repository.GroupImageV2Repository;
 import team.wego.wegobackend.group.v2.domain.repository.GroupUserV2Repository;
 import team.wego.wegobackend.group.v2.domain.repository.GroupV2Repository;
@@ -46,6 +44,7 @@ public class GroupV2UpdateService {
     private final TagService tagService;
 
     private static final int TEMP_SORT_ORDER = Integer.MAX_VALUE;
+    private static final int MAX_IMAGES = 3;
 
     private final EntityManager em;
 
@@ -82,14 +81,15 @@ public UpdateGroupV2Response update(Long userId, Long groupId, UpdateGroupV2Requ
         }
 
         // 4 이미지 변경(null이면 변경 없음)
+
         if (request.images() != null) {
             applyImagesWithSafeReorder(group, userId, request.images());
         }
 
         // dirty checking으로 충분. 그래도 명시적으로 save 해도 무방.
         groupV2Repository.save(group);
 
-       // 응답 구성(조회로 안전하게)
+        // 응답 구성(조회로 안전하게)
         List<String> tagNames = group.getGroupTags().stream()
                 .map(gt -> gt.getTag().getName())
                 .toList();
@@ -124,33 +124,6 @@ public UpdateGroupV2Response update(Long userId, Long groupId, UpdateGroupV2Requ
         );
     }
 
-    private GroupImageItem defaultLogoItem() {
-        return new GroupImageItem(
-                null,
-                "DEFAULT",
-                0,
-                List.of(
-                        new GroupImageVariantItem(
-                                null,
-                                GroupImageV2VariantType.CARD_440_240,
-                                GroupImageV2VariantType.CARD_440_240.width(),
-                                GroupImageV2VariantType.CARD_440_240.height(),
-                                ImageV2Format.WEBP,
-                                null
-                        ),
-                        new GroupImageVariantItem(
-                                null,
-                                GroupImageV2VariantType.THUMBNAIL_100_100,
-                                GroupImageV2VariantType.THUMBNAIL_100_100.width(),
-                                GroupImageV2VariantType.THUMBNAIL_100_100.height(),
-                                ImageV2Format.WEBP,
-                                null
-                        )
-                )
-        );
-    }
-
-
     private void applyScalarUpdates(GroupV2 group, Long groupId, UpdateGroupV2Request request) {
         if (request.title() != null) { // 제목
             group.changeTitle(request.title());
@@ -221,62 +194,177 @@ private void applyTags(GroupV2 group, List<String> tagNames) {
     }
 
     /**
-     * 이미지 업데이트: 요청 imageKeys를 "최종 상태(순서)"로 해석한다. - 요청 순서대로 sortOrder=0.. 부여 (0번이 대표) - 요청에 없는 기존
-     * 이미지는 삭제(orphanRemoval) - 요청에 있고 기존에 없으면 preupload(REDIS) consume 후 새로 생성(insert) - (group_id,
-     * sort_order) 유니크를 유지하기 위해 2-phase 임시 sortOrder 사용
+     * applyImagesWithSafeReorder()가 “DTO → 최종 desiredKeys”를 만들어주는 역할 이미지 업데이트: 요청 imageKeys를 "최종
+     * 상태(순서)"로 해석한다. - 요청 순서대로 sortOrder=0.. 부여 (0번이 대표) - 요청에 없는 기존 이미지는 삭제(orphanRemoval) - 요청에
+     * 있고 기존에 없으면 preupload(REDIS) consume 후 새로 생성(insert) - (group_id, sort_order) 유니크를 유지하기 위해
+     * 2-phase 임시 sortOrder 사용
      * <p>
      * 정책: - 최대 3장 - 중복 key 금지 - [] 허용: 전체 삭제
      */
-    private void applyImagesWithSafeReorder(GroupV2 group, Long userId, List<String> raw) {
-        List<String> desiredKeys = raw.stream()
-                .filter(k -> k != null && !k.isBlank())
+    private void applyImagesWithSafeReorder(
+            GroupV2 group,
+            Long userId,
+            List<CreateGroupImageV2Request> raw
+    ) {
+        // 0) raw는 null이 아닌 상태로 들어온다 (update()에서 null 체크)
+        // [] => 전체 삭제는 "명시적"으로 raw.isEmpty()일 때만
+        if (raw.isEmpty()) {
+            new ArrayList<>(group.getImages()).forEach(group::removeImage);
+            em.flush();
+            return;
+        }
+
+        // 1) 아이템 유효성(엄격): null item, null/blank imageKey는 400
+        for (CreateGroupImageV2Request it : raw) {
+            if (it == null) {
+                throw new GroupException(GroupErrorCode.INVALID_GROUP_IMAGE_ITEM, group.getId(),
+                        userId);
+            }
+            if (it.imageKey() == null || it.imageKey().isBlank()) {
+                throw new GroupException(GroupErrorCode.INVALID_GROUP_IMAGE_KEY, group.getId(),
+                        userId);
+            }
+            // sortOrder는 nullable 허용 (없으면 아래에서 자동 배정 가능)
+            if (it.sortOrder() != null) {
+                if (it.sortOrder() < 0) {
+                    throw new GroupException(GroupErrorCode.INVALID_GROUP_IMAGE_SORT_ORDER_RANGE,
+                            group.getId(), userId);
+                }
+                // 최대 3장 정책이면 0~2로 제한하는 게 예측 가능
+                if (it.sortOrder() >= MAX_IMAGES) {
+                    throw new GroupException(GroupErrorCode.INVALID_GROUP_IMAGE_SORT_ORDER_RANGE,
+                            group.getId(), userId);
+                }
+            }
+        }
+
+        // 2) trim 적용 (정합성 유지)
+        List<CreateGroupImageV2Request> cleaned = raw.stream()
+                .map(it -> new CreateGroupImageV2Request(it.imageKey().trim(), it.sortOrder()))
+                .toList();
+
+        // 3) 최대 3장
+        if (cleaned.size() > MAX_IMAGES) {
+            throw new GroupException(GroupErrorCode.IMAGE_UPLOAD_EXCEED, cleaned.size());
+        }
+
+        // 4) imageKey 중복 금지
+        List<String> keys = cleaned.stream().map(CreateGroupImageV2Request::imageKey).toList();
+        if (new LinkedHashSet<>(keys).size() != keys.size()) {
+            throw new GroupException(GroupErrorCode.DUPLICATED_IMAGE_KEY_IN_REQUEST);
+        }
+
+        // 5) 최종 순서 결정
+        boolean allNullSortOrder = cleaned.stream().allMatch(it -> it.sortOrder() == null);
+
+        List<String> desiredKeys;
+        if (allNullSortOrder) {
+            // sortOrder가 모두 없으면 요청 순서가 곧 최종 순서 (0번이 대표)
+            desiredKeys = cleaned.stream()
+                    .map(CreateGroupImageV2Request::imageKey)
+                    .toList();
+        } else {
+            // sortOrder 중복 검사
+            Set<Integer> used = new HashSet<>();
+            for (CreateGroupImageV2Request it : cleaned) {
+                if (it.sortOrder() != null) {
+                    if (!used.add(it.sortOrder())) {
+                        throw new GroupException(
+                                GroupErrorCode.DUPLICATED_IMAGE_SORT_ORDER_IN_REQUEST,
+                                group.getId(), userId);
+                    }
+                }
+            }
+
+            // null sortOrder 자동 배정 (0..2 중 빈 자리)
+            int next = 0;
+            List<ItemWithIndex> normalized = new ArrayList<>();
+            for (int i = 0; i < cleaned.size(); i++) {
+                CreateGroupImageV2Request it = cleaned.get(i);
+                Integer so = it.sortOrder();
+
+                if (so == null) {
+                    while (used.contains(next)) {
+                        next++;
+                    }
+                    // next도 0..2 보장(최대 3장이라 여기서 넘칠 일은 거의 없지만 방어)
+                    if (next >= MAX_IMAGES) {
+                        throw new GroupException(
+                                GroupErrorCode.INVALID_GROUP_IMAGE_SORT_ORDER_RANGE, group.getId(),
+                                userId);
+                    }
+                    so = next;
+                    used.add(so);
+                }
+
+                normalized.add(new ItemWithIndex(i, it.imageKey(), so));
+            }
+
+            // sortOrder 오름차순, tie면 원래 요청 순서
+            desiredKeys = normalized.stream()
+                    .sorted(Comparator
+                            .comparingInt(ItemWithIndex::sortOrder)
+                            .thenComparingInt(ItemWithIndex::index))
+                    .map(ItemWithIndex::imageKey)
+                    .toList();
+        }
+
+        // 6) 최종 상태 리스트(desiredKeys)를 기존 “안전 재정렬 로직”으로 반영
+        applyFinalImageKeysWithSafeReorder(group, userId, desiredKeys);
+    }
+
+    // applyFinalImageKeysWithSafeReorder()는 “최종 desiredKeys 적용” 역할
+    private void applyFinalImageKeysWithSafeReorder(GroupV2 group, Long userId,
+            List<String> finalKeys) {
+        // 1) 최종 키 정규화(방어적으로 trim)
+        List<String> desiredKeys = finalKeys.stream()
                 .map(String::trim)
                 .toList();
 
-        if (desiredKeys.size() > 3) {
+        // 2) 공통 검증 (중복/개수)
+        if (desiredKeys.size() > MAX_IMAGES) {
             throw new GroupException(GroupErrorCode.IMAGE_UPLOAD_EXCEED, desiredKeys.size());
         }
         if (new LinkedHashSet<>(desiredKeys).size() != desiredKeys.size()) {
             throw new GroupException(GroupErrorCode.DUPLICATED_IMAGE_KEY_IN_REQUEST);
         }
 
+        // 3) 최종 키가 빈 리스트면 전체 삭제
         if (desiredKeys.isEmpty()) {
             new ArrayList<>(group.getImages()).forEach(group::removeImage);
-            em.flush(); // 완전 삭제 즉시 반영
+            em.flush();
             return;
         }
 
-        // 요청에 없는 기존 이미지 삭제
+        // 4) 요청에 없는 기존 이미지 삭제
         Set<String> desiredKeySet = new HashSet<>(desiredKeys);
         List<GroupImageV2> toRemove = group.getImages().stream()
                 .filter(img -> !desiredKeySet.contains(img.getImageKey()))
                 .toList();
         toRemove.forEach(group::removeImage);
 
-        // 남은 이미지들을 임시 음수로 이동: 유니크 충돌 방지
+        // 5) 남은 이미지 임시 음수 이동 (유니크 충돌 방지)
         List<GroupImageV2> remaining = group.getImages();
         for (int i = 0; i < remaining.size(); i++) {
             remaining.get(i).changeSortOrder(-(i + 1));
         }
 
-        em.flush(); // 여기서 “임시 음수 update + 삭제”를 DB에 먼저 반영
+        em.flush();
 
-        // 삭제 후 기준으로 존재하는 key map 구성
+        // 6) 삭제 후 기준으로 존재하는 key map
         Map<String, GroupImageV2> afterRemoveByKey = group.getImages().stream()
                 .collect(Collectors.toMap(GroupImageV2::getImageKey, img -> img));
 
-        // 새로 생성해야 하는 키(요청에는 있는데 현재 없는 것)
+        // 7) 새로 생성해야 하는 키
         List<String> toCreateKeys = desiredKeys.stream()
                 .filter(k -> !afterRemoveByKey.containsKey(k))
                 .toList();
 
-        // 생성 (temp sortOrder는 서로 다르게)
         int temp = TEMP_SORT_ORDER;
         for (String key : toCreateKeys) {
             PreUploadedGroupImage pre = preUploadedGroupImageRedisRepository.consume(key)
-                    .orElseThrow(
-                            () -> new GroupException(GroupErrorCode.PRE_UPLOADED_IMAGE_NOT_FOUND,
-                                    key));
+                    .orElseThrow(() -> new GroupException(
+                            GroupErrorCode.PRE_UPLOADED_IMAGE_NOT_FOUND, key));
 
             if (!userId.equals(pre.uploaderId())) {
                 throw new GroupException(GroupErrorCode.PRE_UPLOADED_IMAGE_OWNER_MISMATCH, key);
@@ -285,21 +373,30 @@ private void applyImagesWithSafeReorder(GroupV2 group, Long userId, List<String>
             GroupImageV2.create(group, temp--, pre.imageKey(), pre.url440x240(), pre.url100x100());
         }
 
-        // 최종 매핑 + 검증
+        // 8) 최종 매핑 + 검증
         Map<String, GroupImageV2> afterByKey = group.getImages().stream()
                 .collect(Collectors.toMap(GroupImageV2::getImageKey, img -> img, (a, b) -> a));
 
         for (String key : desiredKeys) {
             if (!afterByKey.containsKey(key)) {
-                throw new GroupException(GroupErrorCode.GROUP_IMAGE_NOT_FOUND_IN_GROUP_AFTER_UPDATE,
-                        key);
+                throw new GroupException(
+                        GroupErrorCode.GROUP_IMAGE_NOT_FOUND_IN_GROUP_AFTER_UPDATE, key);
             }
         }
 
-        // 최종 sortOrder 0.. 부여
+        // 9) 최종 sortOrder 부여
         for (int i = 0; i < desiredKeys.size(); i++) {
             afterByKey.get(desiredKeys.get(i)).changeSortOrder(i);
         }
     }
+
+    private record ItemWithIndex(
+            int index,
+            String imageKey,
+            int sortOrder
+    ) {
+
+    }
+
 }
 
diff --git a/src/test/http/group/v2/v2-group-create.http b/src/test/http/group/v2/v2-group-create.http
@@ -96,17 +96,17 @@ Authorization: Bearer {{accessToken}}
 Content-Disposition: form-data; name="images"; filename="test-webp1.webp"
 Content-Type: image/webp
 
-< ../image/resources/test-webp1.webp
+< ../../image/resources/test-webp1.webp
 --boundary
 Content-Disposition: form-data; name="images"; filename="test-webp2.webp"
 Content-Type: image/webp
 
-< ../image/resources/test-webp2.webp
+< ../../image/resources/test-webp2.webp
 --boundary
 Content-Disposition: form-data; name="images"; filename="img1.png"
 Content-Type: image/png
 
-< ../image/resources/img1.png
+< ../../image/resources/img1.png
 --boundary--
 
 > {%
diff --git a/src/test/http/group/v2/v2-group-kick-targets.http b/src/test/http/group/v2/v2-group-kick-targets.http
@@ -145,11 +145,11 @@ Authorization: Bearer {{kt_member2AccessToken}}
 {}
 
 ### 5-1. HOST가 kick 대상 조회 (kick-targets) - 성공 기대 (HOST 제외 ATTEND 멤버들)
-POST http://localhost:8080/api/v2/groups/{{kt_groupId}}/attendance/kick-targets
+GET http://localhost:8080/api/v2/groups/{{kt_groupId}}/attendance/kick-targets
 Authorization: Bearer {{kt_hostAccessToken}}
 
 ### 5-2. 예외: MEMBER가 kick-targets 조회 (HOST only)
-POST http://localhost:8080/api/v2/groups/{{kt_groupId}}/attendance/kick-targets
+GET http://localhost:8080/api/v2/groups/{{kt_groupId}}/attendance/kick-targets
 Authorization: Bearer {{kt_member1AccessToken}}
 
 ### 6-1. (선택) 참여자 없는 새 모임 생성 -> kick-targets 빈 배열 확인
diff --git a/src/test/http/group/v2/v2-group-update.http b/src/test/http/group/v2/v2-group-update.http
