Refactor/#143 modify changerequest api

src/main/java/DGU_AI_LAB/admin_be/domain/requests/controller/RequestController.java

@@ -1,7 +1,7 @@
 package DGU_AI_LAB.admin_be.domain.requests.controller;
 
 import DGU_AI_LAB.admin_be.domain.requests.controller.docs.RequestApi;
-import DGU_AI_LAB.admin_be.domain.requests.dto.request.ModifyRequestDTO;
+import DGU_AI_LAB.admin_be.domain.requests.dto.request.SingleChangeRequestDTO;
 import DGU_AI_LAB.admin_be.domain.requests.dto.request.SaveRequestRequestDTO;
 import DGU_AI_LAB.admin_be.domain.requests.dto.response.SaveRequestResponseDTO;
 import DGU_AI_LAB.admin_be.domain.requests.service.RequestCommandService;
@@ -36,14 +36,14 @@ public ResponseEntity<SuccessResponse<?>> createRequest(@AuthenticationPrincipal
     }
 
     /**
-     * 사용 신청 변경 (저장공간 크기, 만료기한, 사용자가 속한 그룹, 리소스 그룹, 도커 이미지)
+     * 사용 신청 변경 (단일 변경 요청)
      */
     @PostMapping("/{requestId}/change")
     public ResponseEntity<SuccessResponse<?>> createChangeRequest(@AuthenticationPrincipal(expression = "userId") Long userId,
                                                                    @PathVariable Long requestId,
-                                                                   @RequestBody @Valid ModifyRequestDTO dto
+                                                                   @RequestBody @Valid SingleChangeRequestDTO dto
     ) {
-        requestCommandService.createModificationRequest(userId, requestId, dto);
+        requestCommandService.createSingleChangeRequest(userId, requestId, dto);
         return SuccessResponse.ok(null);
     }
 
@@ -57,6 +57,15 @@ public ResponseEntity<SuccessResponse<?>> getMyRequests(@AuthenticationPrincipal
         return SuccessResponse.ok(body);
     }
 
+    /**
+     * 나의 승인 완료된 사용 신청 조회
+     */
+    @GetMapping("/my/approved")
+    public ResponseEntity<SuccessResponse<?>> getMyApprovedRequests(@AuthenticationPrincipal CustomUserDetails user) {
+        List<SaveRequestResponseDTO> body = requestQueryService.getApprovedRequestsByUserId(user.getUserId());
+        return SuccessResponse.ok(body);
+    }
+
     /**
      * 나의 사용 신청에 대한 모든 ubuntu_username 조회
      */

src/main/java/DGU_AI_LAB/admin_be/domain/requests/controller/docs/RequestApi.java

@@ -53,6 +53,21 @@ ResponseEntity<SuccessResponse<?>> getMyRequests(
             @Parameter(hidden = true, description = "인증된 사용자")
             CustomUserDetails user
     );
+
+    @Operation(
+            summary = "내 승인 완료된 신청 목록 조회",
+            description = "로그인된 사용자의 승인 완료(FULFILLED) 상태인 신청 내역만 조회합니다."
+    )
+    @ApiResponse(
+            responseCode = "200",
+            description = "조회 성공",
+            content = @Content(array = @ArraySchema(schema = @Schema(implementation = SaveRequestResponseDTO.class)))
+    )
+    ResponseEntity<SuccessResponse<?>> getMyApprovedRequests(
+            @Parameter(hidden = true, description = "인증된 사용자")
+            CustomUserDetails user
+    );
+
     @Operation(
             summary = "승인 완료된 모든 Ubuntu 사용자 이름 조회",
             description = "[그룹 생성 시 사용] 현재 시스템에서 사용 승인(FULFILLED)이 완료된 모든 요청의 Ubuntu 사용자 이름 목록을 조회합니다."

src/main/java/DGU_AI_LAB/admin_be/domain/requests/dto/request/SingleChangeRequestDTO.java

@@ -0,0 +1,184 @@
+package DGU_AI_LAB.admin_be.domain.requests.dto.request;
+
+import DGU_AI_LAB.admin_be.domain.requests.entity.ChangeRequest;
+import DGU_AI_LAB.admin_be.domain.requests.entity.ChangeType;
+import DGU_AI_LAB.admin_be.domain.requests.entity.Request;
+import DGU_AI_LAB.admin_be.domain.users.entity.User;
+import DGU_AI_LAB.admin_be.error.ErrorCode;
+import DGU_AI_LAB.admin_be.error.exception.BusinessException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+import lombok.extern.slf4j.Slf4j;
+
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+import DGU_AI_LAB.admin_be.domain.requests.dto.response.PortMappingDTO;
+import DGU_AI_LAB.admin_be.domain.requests.dto.request.PortRequestDTO;
+import DGU_AI_LAB.admin_be.domain.portRequests.service.PortRequestService;
+
+@Slf4j
+@Schema(description = "단일 변경 요청 DTO")
+public record SingleChangeRequestDTO(
+
+        @Schema(description = "변경 타입", example = "VOLUME_SIZE")
+        @NotNull(message = "변경 타입은 필수입니다.")
+        ChangeType changeType,
+
+        @Schema(description = "새로운 값", example = "100")
+        @NotBlank(message = "새로운 값은 필수입니다.")
+        String newValue,
+
+        @Schema(description = "변경 요청 사유", example = "프로젝트 요구사항 변경으로 인한 용량 증설")
+        @NotBlank(message = "변경 사유는 필수입니다.")
+        String reason
+) {
+
+    /**
+     * 기존 Request에서 oldValue를 추출하고 ChangeRequest 엔티티 생성
+     */
+    public static ChangeRequest toEntity(SingleChangeRequestDTO dto, Request originalRequest, User requestedBy, ObjectMapper objectMapper, PortRequestService portRequestService) {
+        try {
+            String oldValue = extractOldValue(originalRequest, dto.changeType(), objectMapper, portRequestService);
+
+            return ChangeRequest.builder()
+                    .request(originalRequest)
+                    .changeType(dto.changeType())
+                    .oldValue(oldValue)
+                    .newValue(dto.newValue())
+                    .reason(dto.reason())
+                    .requestedBy(requestedBy)
+                    .build();
+        } catch (Exception e) {
+            log.error("Failed to create ChangeRequest entity: {}", e.getMessage());
+            throw new BusinessException(ErrorCode.INTERNAL_SERVER_ERROR);
+        }
+    }
+
+    /**
+     * 변경 타입에 따라 기존 값을 추출
+     */
+    private static String extractOldValue(Request originalRequest, ChangeType changeType, ObjectMapper objectMapper, PortRequestService portRequestService) {
+        try {
+            return switch (changeType) {
+                case VOLUME_SIZE -> objectMapper.writeValueAsString(originalRequest.getVolumeSizeGiB());
+                case EXPIRES_AT -> objectMapper.writeValueAsString(originalRequest.getExpiresAt());
+                case GROUP -> {
+                    Set<Long> oldGroupIds = originalRequest.getRequestGroups().stream()
+                            .map(requestGroup -> requestGroup.getGroup().getUbuntuGid())
+                            .collect(Collectors.toSet());
+                    yield objectMapper.writeValueAsString(oldGroupIds);
+                }
+                case RESOURCE_GROUP -> objectMapper.writeValueAsString(originalRequest.getResourceGroup().getRsgroupId());
+                case CONTAINER_IMAGE -> objectMapper.writeValueAsString(originalRequest.getContainerImage().getImageId());
+                case PORT -> {
+                    // Get existing port requests for this request
+                    List<PortMappingDTO> existingPorts = originalRequest.getRequestId() != null
+                        ? portRequestService.getPortRequestsByRequestId(originalRequest.getRequestId())
+                            .stream()
+                            .map(PortMappingDTO::fromEntity)
+                            .collect(Collectors.toList())
+                        : List.of();
+                    yield objectMapper.writeValueAsString(existingPorts);
+                }
+            };
+        } catch (Exception e) {
+            log.error("Failed to extract old value for change type {}: {}", changeType, e.getMessage());
+            throw new BusinessException(ErrorCode.INTERNAL_SERVER_ERROR);
+        }
+    }
+
+    /**
+     * DTO 내부에서 자체적으로 유효성을 검증하고 데이터베이스 존재 여부까지 확인하는 팩토리 메서드
+     */
+    public static ChangeRequest createValidatedChangeRequest(SingleChangeRequestDTO dto, Request originalRequest, User requestedBy, ObjectMapper objectMapper, PortRequestService portRequestService) {
+        dto.validateAndCheckExistence(originalRequest);
+        return toEntity(dto, originalRequest, requestedBy, objectMapper, portRequestService);
+    }
+
+    /**
+     * 유효성 검증 및 데이터베이스 존재 여부 확인
+     */
+    private void validateAndCheckExistence(Request originalRequest) {
+        validateBasicFormat();
+        validateValueFormat();
+        // 필요한 경우 데이터베이스 존재 여부 검증 로직 추가 가능
+    }
+
+    /**
+     * 기본 형식 유효성 검증
+     */
+    private void validateBasicFormat() {
+        if (changeType == null) {
+            throw new BusinessException("변경 타입은 필수입니다.", ErrorCode.INVALID_INPUT_VALUE);
+        }
+
+        if (newValue == null || newValue.trim().isEmpty()) {
+            throw new BusinessException("새로운 값은 필수입니다.", ErrorCode.INVALID_INPUT_VALUE);
+        }
+
+        if (reason == null || reason.trim().isEmpty()) {
+            throw new BusinessException("변경 사유는 필수입니다.", ErrorCode.INVALID_INPUT_VALUE);
+        }
+    }
+
+    /**
+     * 변경 타입에 따른 값 형식 검증
+     */
+    private void validateValueFormat() {
+        try {
+            switch (changeType) {
+                case VOLUME_SIZE -> {
+                    Long volumeSize = Long.parseLong(newValue.trim());
+                    if (volumeSize <= 0) {
+                        throw new BusinessException("볼륨 크기는 양수여야 합니다.", ErrorCode.INVALID_INPUT_VALUE);
+                    }
+                }
+                case EXPIRES_AT -> {
+                    LocalDateTime.parse(newValue.trim());
+                }
+                case GROUP -> {
+                    ObjectMapper mapper = new ObjectMapper();
+                    Set<Long> groupIds = mapper.readValue(newValue, mapper.getTypeFactory().constructCollectionType(Set.class, Long.class));
+                    if (groupIds.isEmpty()) {
+                        throw new BusinessException("그룹 ID 목록은 비어있을 수 없습니다.", ErrorCode.INVALID_INPUT_VALUE);
+                    }
+                }
+                case RESOURCE_GROUP -> {
+                    Integer resourceGroupId = Integer.parseInt(newValue.trim());
+                    if (resourceGroupId <= 0) {
+                        throw new BusinessException("리소스 그룹 ID는 양수여야 합니다.", ErrorCode.INVALID_INPUT_VALUE);
+                    }
+                }
+                case CONTAINER_IMAGE -> {
+                    Long imageId = Long.parseLong(newValue.trim());
+                    if (imageId <= 0) {
+                        throw new BusinessException("컨테이너 이미지 ID는 양수여야 합니다.", ErrorCode.INVALID_INPUT_VALUE);
+                    }
+                }
+                case PORT -> {
+                    ObjectMapper mapper = new ObjectMapper();
+                    List<PortRequestDTO> portRequests = mapper.readValue(newValue,
+                        mapper.getTypeFactory().constructCollectionType(List.class, PortRequestDTO.class));
+
+                    // Validate each port request
+                    for (PortRequestDTO portRequest : portRequests) {
+                        if (portRequest.internalPort() == null || portRequest.internalPort() < 1 || portRequest.internalPort() > 65535) {
+                            throw new BusinessException("내부 포트는 1-65535 범위여야 합니다.", ErrorCode.INVALID_INPUT_VALUE);
+                        }
+                        if (portRequest.usagePurpose() == null || portRequest.usagePurpose().trim().isEmpty()) {
+                            throw new BusinessException("포트 사용 목적은 필수입니다.", ErrorCode.INVALID_INPUT_VALUE);
+                        }
+                    }
+                }
+            }
+        } catch (BusinessException e) {
+            throw e;
+        } catch (Exception e) {
+            throw new BusinessException("새로운 값의 형식이 올바르지 않습니다: " + e.getMessage(), ErrorCode.INVALID_INPUT_VALUE);
+        }
+    }
+}

src/main/java/DGU_AI_LAB/admin_be/domain/requests/entity/ChangeType.java

@@ -3,7 +3,8 @@
 public enum ChangeType {
     VOLUME_SIZE, // 볼륨 사이즈 변경
     EXPIRES_AT, // 서버 사용 만료 기한 변경
-    GROUP, // 사용자가 속한 그룹 변경
     RESOURCE_GROUP, // 리소스 그룹 변경
-    CONTAINER_IMAGE // 도커 이미지 변경
+    CONTAINER_IMAGE, // 도커 이미지 변경
+    GROUP, // 사용자가 속한 그룹 변경
+    PORT,
 }

src/main/java/DGU_AI_LAB/admin_be/domain/requests/service/RequestCommandService.java

@@ -6,6 +6,7 @@
 import DGU_AI_LAB.admin_be.domain.groups.entity.Group;
 import DGU_AI_LAB.admin_be.domain.groups.repository.GroupRepository;
 import DGU_AI_LAB.admin_be.domain.requests.dto.request.ModifyRequestDTO;
+import DGU_AI_LAB.admin_be.domain.requests.dto.request.SingleChangeRequestDTO;
 import DGU_AI_LAB.admin_be.domain.requests.dto.request.SaveRequestRequestDTO;
 import DGU_AI_LAB.admin_be.domain.requests.dto.response.SaveRequestResponseDTO;
 import DGU_AI_LAB.admin_be.domain.requests.entity.ChangeRequest;
@@ -115,6 +116,32 @@ public void createModificationRequest(Long userId, Long requestId, ModifyRequest
         }
     }
 
+    /**
+     * 단일 변경 요청 생성 - DTO가 모든 검증을 담당하므로 서비스는 단순히 처리만 함
+     */
+    @Transactional
+    public void createSingleChangeRequest(Long userId, Long requestId, SingleChangeRequestDTO dto) {
+        Request originalRequest = requestRepository.findById(requestId)
+                .orElseThrow(() -> new BusinessException(ErrorCode.RESOURCE_NOT_FOUND));
+
+        // 요청자가 원본 요청의 소유자인지 확인
+        if (!originalRequest.getUser().getUserId().equals(userId)) {
+            throw new BusinessException(ErrorCode.FORBIDDEN_REQUEST);
+        }
+
+        // FULFILLED 상태에서만 변경 요청 가능
+        if (originalRequest.getStatus() != Status.FULFILLED) {
+            throw new BusinessException(ErrorCode.INVALID_REQUEST_STATUS);
+        }
+
+        User requestedBy = userRepository.findById(userId)
+                .orElseThrow(() -> new BusinessException(ErrorCode.USER_NOT_FOUND));
+
+        // DTO 팩토리 메서드를 사용하여 검증된 ChangeRequest 생성 및 저장
+        ChangeRequest changeRequest = SingleChangeRequestDTO.createValidatedChangeRequest(
+                dto, originalRequest, requestedBy, objectMapper, portRequestService);
+        changeRequestRepository.save(changeRequest);
+    }
 
     // 중복 코드 방지를 위한 헬퍼 메서드
     private <T> void createAndSaveChangeRequest(Request originalRequest, User requestedBy,

src/main/java/DGU_AI_LAB/admin_be/domain/requests/service/RequestQueryService.java

@@ -69,4 +69,14 @@ public List<String> getAllFulfilledUsernames() {
         return requestRepository.findUbuntuUsernamesByStatus(Status.FULFILLED);
     }
 
+    /** 내 신청 목록 중 승인 완료(FULFILLED) 상태만 조회 */
+    public List<SaveRequestResponseDTO> getApprovedRequestsByUserId(Long userId) {
+        if (!userRepository.existsById(userId)) {
+            throw new BusinessException(ErrorCode.USER_NOT_FOUND);
+        }
+        return requestRepository.findAllByUser_UserIdAndStatus(userId, Status.FULFILLED).stream()
+                .map(this::createResponseDTOWithPortMappings)
+                .toList();
+    }
+
 }