Merge pull request #70 from YAPP-Github/feature/MAFOO-173

[MAFOO-173] feat: 이미지 파일 업로드 API의 앨범 관련 요소(photoCount, albumId) 업데이트 로직을 추가했어요
YAPP-Github · Oct 26, 2024 · c80ad4c · c80ad4c
2 parents a4d047c + 3ddada2
commit c80ad4c
Show file tree

Hide file tree

Showing 6 changed files with 111 additions and 164 deletions.
diff --git a/photo-service/src/main/java/kr/mafoo/photo/controller/PhotoController.java b/photo-service/src/main/java/kr/mafoo/photo/controller/PhotoController.java
@@ -53,7 +53,7 @@ public Flux<PhotoResponse> uploadFileUrlPhoto(
             PhotoFileUrlUploadRequest request
     ){
         return photoService
-                .createNewPhotoFileUrl(request.fileUrls(), memberId)
+                .createNewPhotoFileUrls(request.fileUrls(), request.albumId(), memberId)
                 .map(PhotoResponse::fromEntity);
     }
 

diff --git a/...ervice/src/main/java/kr/mafoo/photo/controller/dto/request/PhotoFileUrlUploadRequest.java b/...ervice/src/main/java/kr/mafoo/photo/controller/dto/request/PhotoFileUrlUploadRequest.java
@@ -2,13 +2,18 @@
 
 import io.swagger.v3.oas.annotations.media.ArraySchema;
 import io.swagger.v3.oas.annotations.media.Schema;
+import kr.mafoo.photo.annotation.ULID;
 
 @Schema(description = "파일(url) 사진 n건 업로드 요청")
 public record PhotoFileUrlUploadRequest(
         @ArraySchema(
                 schema = @Schema(description = "파일 URL 목록"),
                 arraySchema = @Schema(example = "[\"file_url_1\", \"file_url_2\", \"file_url_3\"]")
         )
-        String[] fileUrls
+        String[] fileUrls,
+
+        @ULID
+        @Schema(description = "앨범 ID", example = "test_album_id")
+        String albumId
 ) {
 }
diff --git a/photo-service/src/main/java/kr/mafoo/photo/domain/AlbumEntity.java b/photo-service/src/main/java/kr/mafoo/photo/domain/AlbumEntity.java
@@ -77,13 +77,13 @@ public AlbumEntity updateType(AlbumType newType) {
         return this;
     }
 
-    public AlbumEntity increasePhotoCount() {
-        this.photoCount += 1;
+    public AlbumEntity increasePhotoCount(int count) {
+        this.photoCount += count;
         return this;
     }
 
-    public AlbumEntity decreasePhotoCount() {
-        this.photoCount -= 1;
+    public AlbumEntity decreasePhotoCount(int count) {
+        this.photoCount -= count;
         return this;
     }
 

diff --git a/photo-service/src/main/java/kr/mafoo/photo/domain/PhotoEntity.java b/photo-service/src/main/java/kr/mafoo/photo/domain/PhotoEntity.java
@@ -82,13 +82,14 @@ public PhotoEntity updateDisplayIndex(Integer displayIndex) {
         return this;
     }
 
-    public static PhotoEntity newPhoto(String photoId, String photoUrl, BrandType brandType, String ownerMemberId) {
+    public static PhotoEntity newPhoto(String photoId, String photoUrl, BrandType brandType, String albumId, Integer displayIndex, String ownerMemberId) {
         PhotoEntity photo = new PhotoEntity();
         photo.photoId = photoId;
         photo.photoUrl = photoUrl;
         photo.brand = brandType;
         photo.ownerMemberId = ownerMemberId;
-        photo.displayIndex = 0;
+        photo.albumId = albumId;
+        photo.displayIndex = displayIndex;
         photo.isNew = true;
         photo.createdAt = LocalDateTime.now();
         photo.updatedAt = LocalDateTime.now();

diff --git a/photo-service/src/main/java/kr/mafoo/photo/service/AlbumService.java b/photo-service/src/main/java/kr/mafoo/photo/service/AlbumService.java
@@ -67,85 +67,39 @@ public Mono<AlbumEntity> findByAlbumId(String albumId, String requestMemberId) {
 
     @Transactional
     public Mono<Void> deleteAlbumById(String albumId, String requestMemberId) {
-        return albumRepository
-                .findById(albumId)
-                .switchIfEmpty(Mono.error(new AlbumNotFoundException()))
-                .flatMap(albumEntity -> {
-                    if(!albumEntity.getOwnerMemberId().equals(requestMemberId)) {
-                        // 내 앨범이 아니면 그냥 없는 앨범 처리
-                        return Mono.error(new AlbumNotFoundException());
-                    } else {
-                        return albumRepository
+        return findByAlbumId(albumId, requestMemberId)
+                .flatMap(albumEntity ->
+                        albumRepository
                                 .deleteById(albumId)
                                 .then(albumRepository.popDisplayIndexBetween(
-                                        requestMemberId, albumEntity.getDisplayIndex(), Integer.MAX_VALUE));
-                    }
-                });
+                                        requestMemberId, albumEntity.getDisplayIndex(), Integer.MAX_VALUE))
+                );
     }
 
     @Transactional
     public Mono<AlbumEntity> updateAlbumName(String albumId, String albumName, String requestMemberId) {
-        return albumRepository
-                .findById(albumId)
-                .switchIfEmpty(Mono.error(new AlbumNotFoundException()))
-                .flatMap(albumEntity -> {
-                    if(!albumEntity.getOwnerMemberId().equals(requestMemberId)) {
-                        // 내 앨범이 아니면 그냥 없는 앨범 처리
-                        return Mono.error(new AlbumNotFoundException());
-                    } else {
-                        return albumRepository.save(albumEntity.updateName(albumName));
-                    }
-                });
+        return findByAlbumId(albumId, requestMemberId)
+                .flatMap(albumEntity -> albumRepository.save(albumEntity.updateName(albumName)));
     }
 
     @Transactional
     public Mono<AlbumEntity> updateAlbumType(String albumId, AlbumType albumType, String requestMemberId) {
-        return albumRepository
-                .findById(albumId)
-                .switchIfEmpty(Mono.error(new AlbumNotFoundException()))
-                .flatMap(albumEntity -> {
-                    if(!albumEntity.getOwnerMemberId().equals(requestMemberId)) {
-                        // 내 앨범이 아니면 그냥 없는 앨범 처리
-                        return Mono.error(new AlbumNotFoundException());
-                    } else {
-                        return albumRepository.save(albumEntity.updateType(albumType));
-                    }
-                });
+        return findByAlbumId(albumId, requestMemberId)
+                .flatMap(albumEntity -> albumRepository.save(albumEntity.updateType(albumType)));
     }
 
     @Transactional
-    public Mono<Void> increaseAlbumPhotoCount(String albumId, String requestMemberId) {
-        return albumRepository
-                .findById(albumId)
-                .switchIfEmpty(Mono.error(new AlbumNotFoundException()))
-                .flatMap(albumEntity -> {
-                    if (!albumEntity.getOwnerMemberId().equals(requestMemberId)) {
-                        // 내 앨범이 아니면 그냥 없는 앨범 처리
-                        return Mono.error(new AlbumNotFoundException());
-                    } else {
-                        return albumRepository.save(albumEntity.increasePhotoCount()).then();
-                    }
-                });
+    public Mono<AlbumEntity> increaseAlbumPhotoCount(String albumId, int count, String requestMemberId) {
+        return findByAlbumId(albumId, requestMemberId)
+                .flatMap(albumEntity -> albumRepository.save(albumEntity.increasePhotoCount(count)));
     }
 
     @Transactional
-    public Mono<Void> decreaseAlbumPhotoCount(String albumId, String requestMemberId) {
-
-        if (albumId == null) {
-            return Mono.empty();
-        }
-
-        return albumRepository
-                .findById(albumId)
-                .switchIfEmpty(Mono.error(new AlbumNotFoundException()))
-                .flatMap(albumEntity -> {
-                    if (!albumEntity.getOwnerMemberId().equals(requestMemberId)) {
-                        // 내 앨범이 아니면 그냥 없는 앨범 처리
-                        return Mono.error(new AlbumNotFoundException());
-                    } else {
-                        return albumRepository.save(albumEntity.decreasePhotoCount()).then();
-                    }
-                });
+    public Mono<AlbumEntity> decreaseAlbumPhotoCount(String albumId, int count, String requestMemberId) {
+        return Mono.justOrEmpty(albumId)
+                .switchIfEmpty(Mono.empty())
+                .flatMap(id -> findByAlbumId(id, requestMemberId))
+                .flatMap(albumEntity -> albumRepository.save(albumEntity.decreasePhotoCount(count)));
     }
 
 }