카테고리 순서 변경

backend/src/main/java/codezap/category/controller/CategoryController.java

@@ -4,9 +4,7 @@
 
 import org.springframework.http.ResponseEntity;
 import org.springframework.validation.annotation.Validated;
-import org.springframework.web.bind.annotation.DeleteMapping;
 import org.springframework.web.bind.annotation.GetMapping;
-import org.springframework.web.bind.annotation.PathVariable;
 import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.PutMapping;
 import org.springframework.web.bind.annotation.RequestBody;
@@ -16,7 +14,7 @@
 
 import codezap.auth.configuration.AuthenticationPrinciple;
 import codezap.category.dto.request.CreateCategoryRequest;
-import codezap.category.dto.request.UpdateCategoryRequest;
+import codezap.category.dto.request.UpdateAllCategoriesRequest;
 import codezap.category.dto.response.CreateCategoryResponse;
 import codezap.category.dto.response.FindAllCategoriesResponse;
 import codezap.category.service.CategoryService;
@@ -45,19 +43,12 @@ public ResponseEntity<FindAllCategoriesResponse> getCategories(@RequestParam Lon
         return ResponseEntity.ok(categoryService.findAllByMemberId(memberId));
     }
 
-    @PutMapping("/{id}")
+    @PutMapping
     public ResponseEntity<Void> updateCategory(
             @AuthenticationPrinciple Member member,
-            @PathVariable Long id,
-            @Validated(ValidationSequence.class) @RequestBody UpdateCategoryRequest updateCategoryRequest
+            @Validated(ValidationSequence.class) @RequestBody UpdateAllCategoriesRequest request
     ) {
-        categoryService.update(member, id, updateCategoryRequest);
+        categoryService.updateCategories(member, request);
         return ResponseEntity.ok().build();
     }
-
-    @DeleteMapping("/{id}")
-    public ResponseEntity<Void> deleteCategory(@AuthenticationPrinciple Member member, @PathVariable Long id) {
-        categoryService.deleteById(member, id);
-        return ResponseEntity.noContent().build();
-    }
 }

backend/src/main/java/codezap/category/controller/SpringDocCategoryController.java

@@ -4,7 +4,7 @@
 import org.springframework.http.ResponseEntity;
 
 import codezap.category.dto.request.CreateCategoryRequest;
-import codezap.category.dto.request.UpdateCategoryRequest;
+import codezap.category.dto.request.UpdateAllCategoriesRequest;
 import codezap.category.dto.response.CreateCategoryResponse;
 import codezap.category.dto.response.FindAllCategoriesResponse;
 import codezap.global.swagger.error.ApiErrorResponse;
@@ -49,34 +49,19 @@ ResponseEntity<CreateCategoryResponse> createCategory(
     @SecurityRequirement(name = "쿠키 인증 토큰")
     @Operation(summary = "카테고리 수정", description = "해당하는 식별자의 카테고리를 수정합니다.")
     @ApiResponse(responseCode = "200", description = "카테고리 수정 성공")
-    @ApiErrorResponse(status = HttpStatus.BAD_REQUEST, instance = "/categories/1", errorCases = {
+    @ApiErrorResponse(status = HttpStatus.BAD_REQUEST, instance = "/categories", errorCases = {
+            @ErrorCase(description = "기본 카테고리를 수정한 경우", exampleMessage = "기본 카테고리는 수정 및 삭제할 수 없습니다."),
             @ErrorCase(description = "카테고리 이름이 15자를 초과한 경우", exampleMessage = "카테고리 이름은 최대 15자까지 입력 가능합니다."),
+            @ErrorCase(description = "카테고리의 순서가 잘못된 경우", exampleMessage = "템플릿 순서가 중복됩니다.")
     })
-    @ApiErrorResponse(status = HttpStatus.NOT_FOUND, instance = "/categories/1", errorCases = {
+    @ApiErrorResponse(status = HttpStatus.NOT_FOUND, instance = "/categories", errorCases = {
             @ErrorCase(description = "해당하는 id 값인 카테고리가 없는 경우", exampleMessage = "식별자 1에 해당하는 카테고리가 존재하지 않습니다."),
     })
     @ApiErrorResponse(status = HttpStatus.CONFLICT, instance = "/categories", errorCases = {
             @ErrorCase(description = "동일한 이름의 카테고리가 존재하는 경우", exampleMessage = "이름이 Spring 인 카테고리가 이미 존재합니다."),
     })
-    @ApiErrorResponse(status = HttpStatus.FORBIDDEN, instance = "/categories/1", errorCases = {
+    @ApiErrorResponse(status = HttpStatus.FORBIDDEN, instance = "/categories", errorCases = {
             @ErrorCase(description = "카테고리를 수정할 권한이 없는 경우", exampleMessage = "해당 카테고리를 수정 또는 삭제할 권한이 없는 유저입니다.")
     })
-    ResponseEntity<Void> updateCategory(Member member, Long id, UpdateCategoryRequest updateCategoryRequest);
-
-    @SecurityRequirement(name = "쿠키 인증 토큰")
-    @Operation(summary = "카테고리 삭제", description = "해당하는 식별자의 카테고리를 삭제합니다.")
-    @ApiResponse(responseCode = "204", description = "카테고리 삭제 성공")
-    @ApiErrorResponse(status = HttpStatus.BAD_REQUEST, instance = "/categories/1", errorCases = {
-            @ErrorCase(description = "삭제하려는 카테고리에 템플릿이 존재하는 경우",
-                    exampleMessage = "템플릿이 존재하는 카테고리는 삭제할 수 없습니다."),
-    })
-    @ApiErrorResponse(status = HttpStatus.NOT_FOUND, instance = "/categories/1", errorCases = {
-            @ErrorCase(description = "존재하지 않는 카테고리인 경우",
-                    exampleMessage = "식별자 1에 해당하는 카테고리가 존재하지 않습니다."),
-    })
-    @ApiErrorResponse(status = HttpStatus.FORBIDDEN, instance = "/categories/1", errorCases = {
-            @ErrorCase(description = "카테고리를 수정할 권한이 없는 경우",
-                    exampleMessage = "해당 카테고리를 수정 또는 삭제할 권한이 없는 유저입니다.")
-    })
-    ResponseEntity<Void> deleteCategory(Member member, Long id);
+    ResponseEntity<Void> updateCategory(Member member, UpdateAllCategoriesRequest request);
 }

backend/src/main/java/codezap/category/domain/Category.java

@@ -36,6 +36,7 @@
 public class Category extends BaseTimeEntity {
 
     private static final String DEFAULT_CATEGORY_NAME = "카테고리 없음";
+    private static final long DEFAULT_CATEGORY_ORDINAL = 1L;
 
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
@@ -50,18 +51,23 @@ public class Category extends BaseTimeEntity {
     @Column(nullable = false)
     private Boolean isDefault;
 
-    public Category(String name, Member member) {
+    @Column(nullable = false)
+    private long ordinal;
+
+    public Category(String name, Member member, long ordinal) {
         this.name = name;
         this.member = member;
         this.isDefault = false;
+        this.ordinal = ordinal;
     }
 
     public static Category createDefaultCategory(Member member) {
-        return new Category(null, member, DEFAULT_CATEGORY_NAME, true);
+        return new Category(null, member, DEFAULT_CATEGORY_NAME, true, DEFAULT_CATEGORY_ORDINAL);
     }
 
-    public void updateName(String name) {
+    public void update(String name, long ordinal) {
         this.name = name;
+        this.ordinal = ordinal;
     }
 
     public void validateAuthorization(Member member) {

backend/src/main/java/codezap/category/dto/request/CreateCategoryRequest.java

@@ -1,6 +1,7 @@
 package codezap.category.dto.request;
 
 import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
 import jakarta.validation.constraints.Size;
 
 import codezap.global.validation.ValidationGroups.NotNullGroup;
@@ -11,6 +12,10 @@ public record CreateCategoryRequest(
         @Schema(description = "카테고리 이름", example = "Spring")
         @NotBlank(message = "카테고리 이름이 null 입니다.", groups = NotNullGroup.class)
         @Size(max = 15, message = "카테고리 이름은 최대 15자까지 입력 가능합니다.", groups = SizeCheckGroup.class)
-        String name
+        String name,
+
+        @Schema(description = "카테고리 순서", example = "1")
+        @NotNull(message = "카테고리 순서가 null 입니다.", groups = NotNullGroup.class)
+        Long ordinal
 ) {
 }

backend/src/main/java/codezap/category/dto/request/UpdateAllCategoriesRequest.java

@@ -0,0 +1,24 @@
+package codezap.category.dto.request;
+
+import java.util.List;
+
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.NotNull;
+
+import codezap.global.validation.ValidationGroups.NotNullGroup;
+import io.swagger.v3.oas.annotations.media.Schema;
+
+public record UpdateAllCategoriesRequest(
+        @Schema(description = "생성할 카테고리 목록")
+        @Valid
+        List<CreateCategoryRequest> createCategories,
+
+        @Schema(description = "수정할 카테고리 목록")
+        @Valid
+        List<UpdateCategoryRequest> updateCategories,
+
+        @Schema(description = "삭제할 카테고리 목록")
+        @NotNull(message = "삭제하는 카테고리 ID 목록이 null 입니다.", groups = NotNullGroup.class)
+        List<Long> deleteCategoryIds
+) {
+}

backend/src/main/java/codezap/category/dto/request/UpdateCategoryRequest.java

@@ -1,16 +1,25 @@
 package codezap.category.dto.request;
 
 import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
 import jakarta.validation.constraints.Size;
 
 import codezap.global.validation.ValidationGroups.NotNullGroup;
 import codezap.global.validation.ValidationGroups.SizeCheckGroup;
 import io.swagger.v3.oas.annotations.media.Schema;
 
 public record UpdateCategoryRequest(
+        @Schema(description = "카테고리 ID", example = "1")
+        @NotNull(message = "카테고리 ID가 null 입니다.", groups = NotNullGroup.class)
+        Long id,
+
         @Schema(description = "카테고리 이름", example = "Spring")
         @NotBlank(message = "카테고리 이름이 null 입니다.", groups = NotNullGroup.class)
         @Size(max = 15, message = "카테고리 이름은 최대 15자까지 입력 가능합니다.", groups = SizeCheckGroup.class)
-        String name
+        String name,
+
+        @Schema(description = "카테고리 순서", example = "1")
+        @NotNull(message = "카테고리 순서가 null 입니다.", groups = NotNullGroup.class)
+        Long ordinal
 ) {
 }

backend/src/main/java/codezap/category/dto/response/FindCategoryResponse.java

@@ -7,9 +7,11 @@ public record FindCategoryResponse(
         @Schema(description = "카테고리 식별자", example = "1")
         Long id,
         @Schema(description = "카테고리 이름", example = "Spring")
-        String name
+        String name,
+        @Schema(description = "카테고리 순서", example = "1")
+        long ordinal
 ) {
     public static FindCategoryResponse from(Category category) {
-        return new FindCategoryResponse(category.getId(), category.getName());
+        return new FindCategoryResponse(category.getId(), category.getName(), category.getOrdinal());
     }
 }

backend/src/main/java/codezap/category/repository/CategoryJpaRepository.java

@@ -12,4 +12,6 @@ public interface CategoryJpaRepository extends JpaRepository<Category, Long> {
     List<Category> findAllByMemberIdOrderById(Long memberId);
 
     boolean existsByNameAndMember(String categoryName, Member member);
+
+    long countByMember(Member member);
 }

backend/src/main/java/codezap/category/repository/CategoryRepository.java

@@ -40,4 +40,12 @@ public boolean existsByNameAndMember(String categoryName, Member member) {
     public void deleteById(Long id) {
         categoryJpaRepository.deleteById(id);
     }
+
+    public long countByMember(Member member) {
+        return categoryJpaRepository.countByMember(member);
+    }
+
+    public List<Category> saveAll(Iterable<Category> entities) {
+        return categoryJpaRepository.saveAll(entities);
+    }
 }

backend/src/main/java/codezap/category/service/CategoryService.java

@@ -1,10 +1,16 @@
 package codezap.category.service;
 
+import java.util.HashSet;
+import java.util.List;
+import java.util.stream.IntStream;
+import java.util.stream.Stream;
+
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
 import codezap.category.domain.Category;
 import codezap.category.dto.request.CreateCategoryRequest;
+import codezap.category.dto.request.UpdateAllCategoriesRequest;
 import codezap.category.dto.request.UpdateCategoryRequest;
 import codezap.category.dto.response.CreateCategoryResponse;
 import codezap.category.dto.response.FindAllCategoriesResponse;
@@ -24,13 +30,17 @@ public class CategoryService {
     private final TemplateRepository templateRepository;
 
     @Transactional
-    public CreateCategoryResponse create(Member member, CreateCategoryRequest createCategoryRequest) {
-        String categoryName = createCategoryRequest.name();
-        validateDuplicatedCategory(categoryName, member);
-        Category category = categoryRepository.save(new Category(categoryName, member));
+    public CreateCategoryResponse create(Member member, CreateCategoryRequest request) {
+        validateDuplicatedCategory(request.name(), member);
+        validateOrdinal(member, request);
+        Category category = categoryRepository.save(createCategory(member, request));
         return CreateCategoryResponse.from(category);
     }
 
+    private Category createCategory(Member member, CreateCategoryRequest request) {
+        return new Category(request.name(), member, request.ordinal());
+    }
+
     public FindAllCategoriesResponse findAllByMemberId(Long memberId) {
         return FindAllCategoriesResponse.from(categoryRepository.findAllByMemberIdOrderById(memberId));
     }
@@ -44,11 +54,43 @@ public Category fetchById(Long id) {
     }
 
     @Transactional
-    public void update(Member member, Long id, UpdateCategoryRequest updateCategoryRequest) {
-        validateDuplicatedCategory(updateCategoryRequest.name(), member);
-        Category category = categoryRepository.fetchById(id);
+    public void updateCategories(Member member, UpdateAllCategoriesRequest request) {
+        validateDuplicateNameRequest(request);
+        validateOrdinals(request);
+        validateIds(request);
+
+        createCategories(member, request);
+        for (UpdateCategoryRequest updateCategory : request.updateCategories()) {
+            update(member, updateCategory);
+        }
+        for (Long deleteCategoryId : request.deleteCategoryIds()) {
+            delete(member, deleteCategoryId);
+        }
+        validateCategoriesCount(member, request);
+    }
+
+    private void createCategories(Member member, UpdateAllCategoriesRequest request) {
+        categoryRepository.saveAll(
+                request.createCategories().stream()
+                        .map(createRequest -> createCategory(member, createRequest))
+                        .toList()
+        );
+    }
+
+    private void update(Member member, UpdateCategoryRequest request) {
+        Category category = categoryRepository.fetchById(request.id());
         category.validateAuthorization(member);
-        category.updateName(updateCategoryRequest.name());
+        validateDefaultCategory(category);
+        category.update(request.name(), request.ordinal());
+    }
+
+    private void delete(Member member, Long categoryId) {
+        Category category = categoryRepository.fetchById(categoryId);
+        category.validateAuthorization(member);
+
+        validateDefaultCategory(category);
+        validateHasTemplate(categoryId);
+        categoryRepository.deleteById(categoryId);
     }
 
     private void validateDuplicatedCategory(String categoryName, Member member) {
@@ -57,17 +99,66 @@ private void validateDuplicatedCategory(String categoryName, Member member) {
         }
     }
 
-    @Transactional
-    public void deleteById(Member member, Long id) {
-        Category category = categoryRepository.fetchById(id);
-        category.validateAuthorization(member);
+    private void validateDefaultCategory(Category category) {
+        if (category.isDefault()) {
+            throw new CodeZapException(ErrorCode.DEFAULT_CATEGORY, "기본 카테고리는 수정 및 삭제할 수 없습니다.");
+        }
+    }
 
+    private void validateHasTemplate(Long id) {
         if (templateRepository.existsByCategoryId(id)) {
             throw new CodeZapException(ErrorCode.CATEGORY_HAS_TEMPLATES, "템플릿이 존재하는 카테고리는 삭제할 수 없습니다.");
         }
-        if (category.isDefault()) {
-            throw new CodeZapException(ErrorCode.DEFAULT_CATEGORY, "기본 카테고리는 삭제할 수 없습니다.");
+    }
+
+    private void validateDuplicateNameRequest(UpdateAllCategoriesRequest request) {
+        List<String> allNames = Stream.concat(
+                request.createCategories().stream().map(CreateCategoryRequest::name),
+                request.updateCategories().stream().map(UpdateCategoryRequest::name)
+        ).toList();
+
+        if (allNames.size() != new HashSet<>(allNames).size()) {
+            throw new CodeZapException(ErrorCode.INVALID_REQUEST, "요청에 중복된 카테고리 이름이 존재합니다.");
+        }
+    }
+
+    private void validateOrdinal(Member member, CreateCategoryRequest request) {
+        long ordinal = request.ordinal();
+        long count = categoryRepository.countByMember(member);
+        if (ordinal != count) {
+            throw new CodeZapException(ErrorCode.INVALID_REQUEST, "카테고리 순서가 잘못되었습니다.");
+        }
+    }
+
+    private void validateOrdinals(UpdateAllCategoriesRequest request) {
+        List<Long> allOrdinals = Stream.concat(
+                request.createCategories().stream().map(CreateCategoryRequest::ordinal),
+                request.updateCategories().stream().map(UpdateCategoryRequest::ordinal)
+        ).sorted().toList();
+
+        boolean isSequential = IntStream.range(0, allOrdinals.size())
+                .allMatch(i -> allOrdinals.get(i) == i + 1);
+
+        if (!isSequential) {
+            throw new CodeZapException(ErrorCode.INVALID_REQUEST, "카테고리 순서가 연속적이지 않습니다.");
+        }
+    }
+
+    private void validateIds(UpdateAllCategoriesRequest request) {
+        List<Long> allIds = Stream.concat(
+                request.updateCategories().stream().map(UpdateCategoryRequest::id),
+                request.deleteCategoryIds().stream()
+        ).toList();
+
+        if (allIds.size() != new HashSet<>(allIds).size()) {
+            throw new CodeZapException(ErrorCode.INVALID_REQUEST, "요청에 중복된 id가 존재합니다.");
+        }
+    }
+
+    private void validateCategoriesCount(Member member, UpdateAllCategoriesRequest request) {
+        if (request.updateCategories().size() + request.createCategories().size()
+                != categoryRepository.countByMember(member) - 1) {
+            throw new CodeZapException(ErrorCode.INVALID_REQUEST, "카테고리의 개수가 일치하지 않습니다.");
         }
-        categoryRepository.deleteById(id);
     }
 }

backend/src/main/resources/db/migration/V11__add_category_ordinal.sql

@@ -0,0 +1 @@
+ALTER TABLE category ADD COLUMN ordinal BIGINT NOT NULL;