feat: video api

src/main/java/com/slatto/domain/video/client/YoutubeApiClient.java

@@ -0,0 +1,139 @@
+package com.slatto.domain.video.client;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import com.slatto.global.exception.BaseException;
+import com.slatto.global.response.code.CommonErrorCode;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.http.client.SimpleClientHttpRequestFactory;
+import org.springframework.stereotype.Component;
+import org.springframework.web.client.RestClient;
+import org.springframework.web.client.RestClientException;
+
+import java.time.Duration;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+@Component
+public class YoutubeApiClient {
+
+    private static final String YOUTUBE_API_BASE_URL = "https://www.googleapis.com";
+    private static final List<String> THUMBNAIL_PRIORITIES =
+            List.of("maxres", "standard", "high", "medium", "default");
+
+    private final RestClient restClient;
+    private final String apiKey;
+
+    @Autowired
+    public YoutubeApiClient(
+            RestClient.Builder restClientBuilder,
+            @Value("${youtube.api.key}") String apiKey,
+            @Value("${youtube.api.connect-timeout}") Duration connectTimeout,
+            @Value("${youtube.api.read-timeout}") Duration readTimeout
+    ) {
+        SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
+        requestFactory.setConnectTimeout(connectTimeout);
+        requestFactory.setReadTimeout(readTimeout);
+
+        this.restClient = restClientBuilder
+                .baseUrl(YOUTUBE_API_BASE_URL)
+                .requestFactory(requestFactory)
+                .build();
+        this.apiKey = apiKey;
+    }
+
+    YoutubeApiClient(RestClient restClient, String apiKey) {
+        this.restClient = restClient;
+        this.apiKey = apiKey;
+    }
+
+    public Optional<YoutubeVideoInfo> getVideo(String youtubeVideoId) {
+        YoutubeVideosResponse response;
+        try {
+            response = restClient.get()
+                    .uri(uriBuilder -> uriBuilder
+                            .path("/youtube/v3/videos")
+                            .queryParam("part", "snippet,contentDetails,status")
+                            .queryParam("id", youtubeVideoId)
+                            .queryParam("key", apiKey)
+                            .build())
+                    .retrieve()
+                    .body(YoutubeVideosResponse.class);
+        } catch (RestClientException exception) {
+            throw new BaseException(CommonErrorCode.INTERNAL_SERVER_ERROR);
+        }
+
+        if (response == null || response.items() == null || response.items().isEmpty()) {
+            return Optional.empty();
+        }
+
+        YoutubeVideoItem item = response.items().getFirst();
+        String thumbnailUrl = selectThumbnailUrl(item.snippet().thumbnails());
+        int durationSeconds = Math.toIntExact(Duration.parse(item.contentDetails().duration()).getSeconds());
+
+        return Optional.of(new YoutubeVideoInfo(
+                item.snippet().title(),
+                thumbnailUrl,
+                durationSeconds,
+                item.status().embeddable(),
+                item.status().privacyStatus()
+        ));
+    }
+
+    private String selectThumbnailUrl(Map<String, YoutubeThumbnail> thumbnails) {
+        if (thumbnails == null) {
+            return null;
+        }
+
+        return THUMBNAIL_PRIORITIES.stream()
+                .map(thumbnails::get)
+                .filter(thumbnail -> thumbnail != null && thumbnail.url() != null)
+                .map(YoutubeThumbnail::url)
+                .findFirst()
+                .orElse(null);
+    }
+
+    public record YoutubeVideoInfo(
+            String title,
+            String thumbnailUrl,
+            int durationSeconds,
+            boolean embeddable,
+            String privacyStatus
+    ) {
+    }
+
+    @JsonIgnoreProperties(ignoreUnknown = true)
+    record YoutubeVideosResponse(List<YoutubeVideoItem> items) {
+    }
+
+    @JsonIgnoreProperties(ignoreUnknown = true)
+    record YoutubeVideoItem(
+            YoutubeSnippet snippet,
+            YoutubeContentDetails contentDetails,
+            YoutubeStatus status
+    ) {
+    }
+
+    @JsonIgnoreProperties(ignoreUnknown = true)
+    record YoutubeSnippet(
+            String title,
+            Map<String, YoutubeThumbnail> thumbnails
+    ) {
+    }
+
+    @JsonIgnoreProperties(ignoreUnknown = true)
+    record YoutubeThumbnail(String url) {
+    }
+
+    @JsonIgnoreProperties(ignoreUnknown = true)
+    record YoutubeContentDetails(String duration) {
+    }
+
+    @JsonIgnoreProperties(ignoreUnknown = true)
+    record YoutubeStatus(
+            boolean embeddable,
+            String privacyStatus
+    ) {
+    }
+}

src/main/java/com/slatto/domain/video/controller/VideoController.java

@@ -0,0 +1,99 @@
+package com.slatto.domain.video.controller;
+
+import com.slatto.domain.video.dto.request.VideoRequest.VideoCreateReqDTO;
+import com.slatto.domain.video.dto.request.VideoRequest.VideoUpdateReqDTO;
+import com.slatto.domain.video.dto.response.VideoResponse.VideoCreateResDTO;
+import com.slatto.domain.video.dto.response.VideoResponse.VideoDeleteResDTO;
+import com.slatto.domain.video.dto.response.VideoResponse.VideoListResDTO;
+import com.slatto.domain.video.dto.response.VideoResponse.VideoUpdateResDTO;
+import com.slatto.domain.video.service.VideoService;
+import com.slatto.global.response.ApiResponse;
+import com.slatto.global.response.code.CommonSuccessCode;
+import io.swagger.v3.oas.annotations.Operation;
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.Max;
+import jakarta.validation.constraints.Min;
+import jakarta.validation.constraints.Positive;
+import lombok.RequiredArgsConstructor;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PatchMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.http.HttpStatus;
+import org.springframework.web.bind.annotation.ResponseStatus;
+
+@Validated
+@RestController
+@RequiredArgsConstructor
+@RequestMapping("/api/v1/projects/{projectId}/videos")
+public class VideoController {
+
+    private final VideoService videoService;
+
+    @PatchMapping("/{videoId}")
+    @Operation(summary = "영상 수정",
+            description = "프로젝트에 등록된 영상의 제목과 메모를 수정합니다.<br>" +
+                    "수정하지 않을 부분은 null로 넣으면 됩니다.")
+    public ApiResponse<VideoUpdateResDTO> updateVideo(
+            @PathVariable @Positive Long projectId,
+            @PathVariable @Positive Long videoId,
+            @Valid @RequestBody VideoUpdateReqDTO request
+    ) {
+        // TODO: 인증/인가 구현 후 JWT에서 memberId 추출하도록 변경
+        Long memberId = 1L;
+        return ApiResponse.success(
+                CommonSuccessCode.OK,
+                videoService.updateVideo(memberId, projectId, videoId, request)
+        );
+    }
+
+    @DeleteMapping("/{videoId}")
+    @Operation(summary = "영상 삭제", description = "프로젝트에 등록된 영상을 삭제합니다.")
+    public ApiResponse<VideoDeleteResDTO> deleteVideo(
+            @PathVariable @Positive Long projectId,
+            @PathVariable @Positive Long videoId
+    ) {
+        // TODO: 인증/인가 구현 후 JWT에서 memberId 추출하도록 변경
+        Long memberId = 1L;
+        return ApiResponse.success(
+                CommonSuccessCode.OK,
+                videoService.deleteVideo(memberId, projectId, videoId)
+        );
+    }
+
+    @PostMapping
+    @ResponseStatus(HttpStatus.CREATED)
+    @Operation(summary = "영상 등록", description = "프로젝트에 새로운 YouTube 영상을 등록합니다.")
+    public ApiResponse<VideoCreateResDTO> createVideo(
+            @PathVariable @Positive Long projectId,
+            @Valid @RequestBody VideoCreateReqDTO request
+    ) {
+        // TODO: 인증/인가 구현 후 JWT에서 memberId 추출하도록 변경
+        Long memberId = 1L;
+        return ApiResponse.success(
+                CommonSuccessCode.CREATED,
+                videoService.createVideo(memberId, projectId, request)
+        );
+    }
+
+    @GetMapping
+    @Operation(summary = "영상 목록 조회", description = "프로젝트 멤버가 프로젝트에 등록된 영상을 커서 방식으로 조회합니다.")
+    public ApiResponse<VideoListResDTO> getVideos(
+            @PathVariable @Positive Long projectId,
+            @RequestParam(required = false) @Positive Long cursor,
+            @RequestParam(required = false) @Min(1) @Max(100) Integer size
+    ) {
+        // TODO: 인증/인가 구현 후 JWT에서 memberId 추출하도록 변경
+        Long memberId = 1L;
+        return ApiResponse.success(
+                CommonSuccessCode.OK,
+                videoService.getVideos(memberId, projectId, cursor, size)
+        );
+    }
+}

src/main/java/com/slatto/domain/video/controller/YoutubeController.java

@@ -0,0 +1,35 @@
+package com.slatto.domain.video.controller;
+
+import com.slatto.domain.video.dto.request.VideoRequest.YoutubeValidateReqDTO;
+import com.slatto.domain.video.dto.response.VideoResponse.YoutubeValidateResDTO;
+import com.slatto.domain.video.service.VideoService;
+import com.slatto.global.response.ApiResponse;
+import com.slatto.global.response.code.CommonSuccessCode;
+import io.swagger.v3.oas.annotations.Operation;
+import jakarta.validation.Valid;
+import lombok.RequiredArgsConstructor;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@RequiredArgsConstructor
+@RequestMapping("/api/v1/videos/youtube")
+public class YoutubeController {
+
+    private final VideoService videoService;
+
+    @PostMapping("/validate")
+    @Operation(summary = "YouTube URL 검증", description = "YouTube 영상 정보와 프로젝트 내 중복 등록 여부를 검증합니다.")
+    public ApiResponse<YoutubeValidateResDTO> validateYoutubeUrl(
+            @Valid @RequestBody YoutubeValidateReqDTO request
+    ) {
+        // TODO: 인증/인가 구현 후 JWT에서 memberId 추출하도록 변경
+        Long memberId = 1L;
+        return ApiResponse.success(
+                CommonSuccessCode.OK,
+                videoService.validateYoutubeUrl(memberId, request)
+        );
+    }
+}

src/main/java/com/slatto/domain/video/dto/request/VideoRequest.java

@@ -0,0 +1,54 @@
+package com.slatto.domain.video.dto.request;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.Positive;
+import jakarta.validation.constraints.Pattern;
+import jakarta.validation.constraints.Size;
+
+public class VideoRequest {
+
+    @Schema(description = "영상 수정 요청")
+    public record VideoUpdateReqDTO(
+            @Pattern(regexp = "(?s).*\\S.*", message = "영상 제목은 공백일 수 없습니다.")
+            @Size(max = 255, message = "영상 제목은 최대 255자까지 입력할 수 있습니다.")
+            @Schema(example = "수정된 영상 제목", nullable = true)
+            String title,
+
+            @Schema(example = "수정된 영상 메모", nullable = true)
+            String memo
+    ) {
+    }
+
+    @Schema(description = "YouTube URL 검증 요청")
+    public record YoutubeValidateReqDTO(
+            @NotBlank(message = "YouTube URL은 필수입니다.")
+            @Size(max = 500, message = "YouTube URL은 최대 500자까지 입력할 수 있습니다.")
+            @Schema(example = "https://www.youtube.com/watch?v=abc123")
+            String youtubeUrl,
+
+            @NotNull(message = "프로젝트 ID는 필수입니다.")
+            @Positive(message = "프로젝트 ID는 양수여야 합니다.")
+            @Schema(example = "10")
+            Long projectId
+    ) {
+    }
+
+    @Schema(description = "영상 등록 요청")
+    public record VideoCreateReqDTO(
+            @NotBlank(message = "YouTube URL은 필수입니다.")
+            @Size(max = 500, message = "YouTube URL은 최대 500자까지 입력할 수 있습니다.")
+            @Schema(example = "https://www.youtube.com/watch?v=abc123")
+            String youtubeUrl,
+
+            @NotBlank(message = "영상 제목은 필수입니다.")
+            @Size(max = 255, message = "영상 제목은 최대 255자까지 입력할 수 있습니다.")
+            @Schema(example = "프로젝트 명")
+            String title,
+
+            @Schema(example = "영상에 관련된 메모", nullable = true)
+            String memo
+    ) {
+    }
+}