[김태희] sprint6

build.gradle

@@ -24,23 +24,35 @@ repositories {
 }
 
 dependencies {
+    // Spring Boot Core
     implementation 'org.springframework.boot:spring-boot-starter-web'
+    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
+    runtimeOnly 'org.postgresql:postgresql' // PostgreSQL JDBC 드라이버
+
+    // Lombok
     compileOnly 'org.projectlombok:lombok'
     annotationProcessor 'org.projectlombok:lombok'
+    testCompileOnly 'org.projectlombok:lombok:1.18.36'
+    testAnnotationProcessor 'org.projectlombok:lombok:1.18.36'
 
+    // OpenAPI / Swagger UI
     implementation 'org.springdoc:springdoc-openapi-starter-webmvc-ui:2.7.0'
 
+    // JWT (토큰 인증)
     implementation 'io.jsonwebtoken:jjwt-api:0.11.5'
     runtimeOnly 'io.jsonwebtoken:jjwt-impl:0.11.5'
     runtimeOnly 'io.jsonwebtoken:jjwt-jackson:0.11.5'
 
-    // BCrypt 암호화를 위한 의존성
+    // 비밀번호 암호화용
     implementation 'org.mindrot:jbcrypt:0.4'
 
+    // 테스트 관련
+    testImplementation 'org.springframework.boot:spring-boot-starter-web'
+    testImplementation 'org.springframework.boot:spring-boot-starter-test'
     testImplementation 'org.mockito:mockito-core:5.11.0'
     testImplementation 'org.mockito:mockito-junit-jupiter:5.11.0'
-    testImplementation 'org.springframework.boot:spring-boot-starter-test'
     testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
+    testImplementation 'com.h2database:h2' // 테스트용 인메모리 DB
 }
 
 tasks.named('test') {

src/main/java/com/sprint/mission/discodeit/controller/AuthController.java

@@ -1,7 +1,7 @@
 package com.sprint.mission.discodeit.controller;
 
 import com.sprint.mission.discodeit.dto.user.LoginRequest;
-import com.sprint.mission.discodeit.entity.User;
+import com.sprint.mission.discodeit.dto.user.UserDto;
 import com.sprint.mission.discodeit.service.AuthService;
 import lombok.RequiredArgsConstructor;
 import org.springframework.http.ResponseEntity;
@@ -18,9 +18,9 @@ public class AuthController {
   private final AuthService authService;
 
   @RequestMapping(value = "/login", method = RequestMethod.POST)
-  public ResponseEntity<User> login(@RequestBody LoginRequest request) {
+  public ResponseEntity<UserDto> login(@RequestBody LoginRequest request) {
 
-    User user = authService.login(request);
+    UserDto user = authService.login(request);
     return ResponseEntity.ok(user);
   }
 }

src/main/java/com/sprint/mission/discodeit/controller/BinaryContentController.java

@@ -1,46 +1,53 @@
 package com.sprint.mission.discodeit.controller;
 
 
-import com.sprint.mission.discodeit.entity.BinaryContent;
+import com.sprint.mission.discodeit.dto.binaryContent.BinaryContentDto;
 import com.sprint.mission.discodeit.service.BinaryContentService;
+import com.sprint.mission.discodeit.storage.BinaryContentStorage;
 import java.util.List;
 import java.util.UUID;
 import lombok.RequiredArgsConstructor;
 import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.PathVariable;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestMethod;
 import org.springframework.web.bind.annotation.RequestParam;
 import org.springframework.web.bind.annotation.RestController;
-import org.springframework.web.multipart.MultipartFile;
 
 @RestController
 @RequestMapping("/api/binaryContents")
 @RequiredArgsConstructor
 public class BinaryContentController {
 
   private final BinaryContentService binaryContentService;
+  private final BinaryContentStorage binaryContentStorage;
 
-  @RequestMapping(value = "/upload", method = RequestMethod.PUT)
-  public ResponseEntity<?> upload(@RequestParam("file") MultipartFile multipartFile) {
-    UUID binaryId = binaryContentService.createBinaryContent(multipartFile);
 
-    return ResponseEntity.ok(binaryId);
+  @RequestMapping(value = "", method = RequestMethod.GET)
+  public ResponseEntity<List<BinaryContentDto>> getBinaryContents(
+      @RequestParam("binaryContentIds") List<UUID> binaryIds) {
+    return ResponseEntity.ok(binaryContentService.findAllByIdIn(binaryIds));
   }
 
-  @RequestMapping(value = "{binaryContentId}", method = RequestMethod.GET)
-  public ResponseEntity<BinaryContent> getBinaryContent(
+  @RequestMapping(value = "/{binaryContentId}", method = RequestMethod.GET)
+  public ResponseEntity<BinaryContentDto> getBinaryContent(
       @PathVariable("binaryContentId") UUID binaryContentId) {
     return ResponseEntity.ok(binaryContentService.findBinaryContent(binaryContentId));
   }
 
-  @RequestMapping(value = "", method = RequestMethod.GET)
-  public ResponseEntity<List<BinaryContent>> getBinaryContents(
-      @RequestParam("binaryContentIds") List<UUID> binaryIds) {
-    List<BinaryContent> binaryContents = binaryIds.stream()
-        .map(binaryContentService::findBinaryContent)
-        .toList();
-
-    return ResponseEntity.ok(binaryContents);
+//  @RequestMapping(value = "/upload", method = RequestMethod.PUT)
+//  public ResponseEntity<BinaryContentDto> upload(
+//      @RequestParam("file") MultipartFile multipartFile) {
+//    BinaryContentDto binaryContent = binaryContentService.createBinaryContent(multipartFile);
+//
+//    return ResponseEntity.ok(binaryContent);
+//  }
+
+  @GetMapping(value = "/{binaryContentId}/download")
+  public ResponseEntity<?> downloadBinaryContent(
+      @PathVariable("binaryContentId") UUID binaryContentId
+  ) {
+    return binaryContentStorage.download(binaryContentService.findBinaryContent(binaryContentId));
   }
 }

src/main/java/com/sprint/mission/discodeit/controller/ChannelController.java

@@ -1,14 +1,14 @@
 package com.sprint.mission.discodeit.controller;
 
-import com.sprint.mission.discodeit.dto.channel.ChannelInfoDto;
+import com.sprint.mission.discodeit.dto.channel.ChannelDto;
 import com.sprint.mission.discodeit.dto.channel.CreatePrivateChannelRequest;
 import com.sprint.mission.discodeit.dto.channel.CreatePublicChannelRequest;
 import com.sprint.mission.discodeit.dto.channel.UpdateChannelRequest;
-import com.sprint.mission.discodeit.entity.Channel;
 import com.sprint.mission.discodeit.service.ChannelService;
 import java.util.List;
 import java.util.UUID;
 import lombok.RequiredArgsConstructor;
+import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.PathVariable;
 import org.springframework.web.bind.annotation.RequestBody;
@@ -25,42 +25,35 @@ public class ChannelController {
   private final ChannelService channelService;
 
   @RequestMapping(value = "/private", method = RequestMethod.POST)
-  public ResponseEntity<Channel> createPrivateChannel(
-      @RequestBody CreatePrivateChannelRequest channelDto
+  public ResponseEntity<ChannelDto> createPrivateChannel(
+      @RequestBody CreatePrivateChannelRequest request
   ) {
-    Channel channel = channelService.createPrivateChannel(channelDto);
-
-    return ResponseEntity.status(201).body(channel);
+    return ResponseEntity.status(HttpStatus.CREATED)
+        .body(channelService.createPrivateChannel(request));
   }
 
   @RequestMapping(value = "/public", method = RequestMethod.POST)
-  public ResponseEntity<Channel> createPublicChannel(
-      @RequestBody CreatePublicChannelRequest channelDto) {
-    Channel channel = channelService.createPublicChannel(channelDto);
-
-    return ResponseEntity.status(201).body(channel);
+  public ResponseEntity<ChannelDto> createPublicChannel(
+      @RequestBody CreatePublicChannelRequest request) {
+    return ResponseEntity.status(HttpStatus.CREATED)
+        .body(channelService.createPublicChannel(request));
   }
 
   @RequestMapping(value = "/{channelId}", method = RequestMethod.PATCH)
-  public ResponseEntity<Channel> updateChannel(@PathVariable("channelId") UUID channelId,
-      @RequestBody UpdateChannelRequest channelDto) {
-    Channel channel = channelService.updateChannel(channelId, channelDto);
-
-    return ResponseEntity.ok(channel);
+  public ResponseEntity<ChannelDto> updateChannel(@PathVariable("channelId") UUID channelId,
+      @RequestBody UpdateChannelRequest request) {
+    return ResponseEntity.ok(channelService.updateChannel(channelId, request));
   }
 
   @RequestMapping(value = "/{channelId}", method = RequestMethod.DELETE)
   public ResponseEntity<?> deleteChannel(@PathVariable("channelId") UUID channelId) {
     channelService.deleteChannel(channelId);
-
-    return ResponseEntity.status(204).body("Channel이 성공적으로 삭제됨");
+    return ResponseEntity.status(HttpStatus.NO_CONTENT).body("Channel이 성공적으로 삭제됨");
   }
 
   @RequestMapping(value = "", method = RequestMethod.GET)
-  public ResponseEntity<List<ChannelInfoDto>> getAllChannels(
+  public ResponseEntity<List<ChannelDto>> getAllChannels(
       @RequestParam(name = "userId") UUID userId) {
-    List<ChannelInfoDto> channels = channelService.findAllByUserId(userId);
-
-    return ResponseEntity.ok(channels);
+    return ResponseEntity.ok(channelService.findAllByUserId(userId));
   }
 }

src/main/java/com/sprint/mission/discodeit/controller/MessageController.java

@@ -2,13 +2,17 @@
 
 
 import com.sprint.mission.discodeit.dto.Message.CreateMessageRequest;
+import com.sprint.mission.discodeit.dto.Message.MessageDto;
 import com.sprint.mission.discodeit.dto.Message.UpdateMessageRequest;
-import com.sprint.mission.discodeit.entity.Message;
+import com.sprint.mission.discodeit.dto.response.PageResponse;
 import com.sprint.mission.discodeit.service.BinaryContentService;
 import com.sprint.mission.discodeit.service.MessageService;
+import java.time.Instant;
 import java.util.List;
 import java.util.UUID;
 import lombok.RequiredArgsConstructor;
+import org.springframework.data.domain.Pageable;
+import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.PathVariable;
 import org.springframework.web.bind.annotation.RequestBody;
@@ -27,43 +31,46 @@ public class MessageController {
   private final MessageService messageService;
   private final BinaryContentService binaryContentService;
 
+  @RequestMapping(value = "", method = RequestMethod.GET)
+  public ResponseEntity<PageResponse<MessageDto>> findAllByChannelId(
+      @RequestParam("channelId") UUID channelId,
+      @RequestParam(value = "cursor", required = false) Instant cursor,
+      Pageable pageable
+  ) {
+    PageResponse<MessageDto> messageDtoPageResponse = messageService.findMessagesByCursor(channelId,
+        cursor, pageable);
+    return ResponseEntity.ok(messageDtoPageResponse);
+  }
+
   @RequestMapping(value = "", method = RequestMethod.POST)
-  public ResponseEntity<Message> createMessage(
+  public ResponseEntity<MessageDto> createMessage(
       @RequestPart("messageCreateRequest") CreateMessageRequest request,
       @RequestPart(value = "attachments", required = false) List<MultipartFile> attachments
   ) {
-    Message message = messageService.createMessage(request);
-    if (!attachments.isEmpty()) {
+    MessageDto messageDto = messageService.createMessage(request);
+    if (attachments != null && !attachments.isEmpty()) {
       attachments.stream()
           .map(binaryContentService::createBinaryContent)
-          .forEach(binaryId -> messageService.addAttachment(message.getId(), binaryId));
+          .forEach(binaryId -> messageService.addAttachment(messageDto.id(), binaryId));
     }
 
-    return ResponseEntity.status(201).body(message);
+    return ResponseEntity.status(HttpStatus.CREATED).body(messageDto);
   }
 
   @RequestMapping(value = "/{messageId}", method = RequestMethod.PATCH)
-  public ResponseEntity<Message> updateMessage(
+  public ResponseEntity<MessageDto> updateMessage(
       @PathVariable("messageId") UUID messageId,
       @RequestBody UpdateMessageRequest request) {
-    Message message = messageService.updateMessage(messageId, request);
-
-    return ResponseEntity.ok(message);
+    return ResponseEntity.ok(messageService.updateMessage(messageId, request));
   }
 
   @RequestMapping(value = "/{messageId}", method = RequestMethod.DELETE)
   public ResponseEntity<?> deleteMessage(
       @PathVariable("messageId") UUID messageId) {
     messageService.deleteMessage(messageId);
 
-    return ResponseEntity.status(204).body("Message가 성공적으로 삭제됨");
+    return ResponseEntity.status(HttpStatus.NO_CONTENT).body("Message가 성공적으로 삭제됨");
   }
 
-  @RequestMapping(value = "", method = RequestMethod.GET)
-  public ResponseEntity<List<Message>> getChannelMessage(
-      @RequestParam("channelId") UUID channelId) {
-    List<Message> messages = messageService.findallByChannelId(channelId);
 
-    return ResponseEntity.ok(messages);
-  }
 }

src/main/java/com/sprint/mission/discodeit/controller/ReadStatusController.java

@@ -1,12 +1,13 @@
 package com.sprint.mission.discodeit.controller;
 
 import com.sprint.mission.discodeit.dto.readStatus.CreateReadStatusRequest;
+import com.sprint.mission.discodeit.dto.readStatus.ReadStatusDto;
 import com.sprint.mission.discodeit.dto.readStatus.UpdateReadStatusRequest;
-import com.sprint.mission.discodeit.entity.ReadStatus;
 import com.sprint.mission.discodeit.service.ReadStatusService;
 import java.util.List;
 import java.util.UUID;
 import lombok.RequiredArgsConstructor;
+import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.PathVariable;
 import org.springframework.web.bind.annotation.RequestBody;
@@ -23,46 +24,37 @@ public class ReadStatusController {
   private final ReadStatusService readStatusService;
 
   @RequestMapping(value = "", method = RequestMethod.POST)
-  public ResponseEntity<ReadStatus> createReadStatus(
+  public ResponseEntity<ReadStatusDto> createReadStatus(
       @RequestBody CreateReadStatusRequest request
   ) {
-    System.out.println(11);
-
-    ReadStatus readStatus = readStatusService.createReadStatus(request);
+    return ResponseEntity.status(HttpStatus.CREATED)
+        .body(readStatusService.createReadStatus(request));
+  }
 
-    return ResponseEntity.status(201).body(readStatus);
+  @RequestMapping(value = "", method = RequestMethod.GET)
+  public ResponseEntity<List<ReadStatusDto>> findAllByUserId(
+      @RequestParam("userId") UUID userId
+  ) {
+    return ResponseEntity.ok(readStatusService.findAllByUserId(userId));
   }
 
   @RequestMapping(value = "/{readStatusId}", method = RequestMethod.PATCH)
-  public ResponseEntity<ReadStatus> updateReadStatus(
+  public ResponseEntity<ReadStatusDto> updateReadStatus(
       @PathVariable("readStatusId") UUID readStatusId,
       @RequestBody UpdateReadStatusRequest request
   ) {
-    ReadStatus readStatus = readStatusService.updateReadStatus(readStatusId, request);
-
-    return ResponseEntity.ok(readStatus);
+    return ResponseEntity.ok(readStatusService.updateReadStatus(readStatusId, request));
   }
 
   @RequestMapping(value = "/{channelId}", method = RequestMethod.GET)
-  public ResponseEntity<ReadStatus> getReadStatus(
+  public ResponseEntity<ReadStatusDto> getReadStatus(
       @RequestParam("userId") UUID userId,
       @PathVariable("channelId") UUID channelId
   ) {
-    ReadStatus readStatus = readStatusService.findReadStatusByUserIdAndChannelId(userId, channelId);
 
-    return ResponseEntity.ok(readStatus);
+    return ResponseEntity.ok(
+        readStatusService.findReadStatusByUserIdAndChannelId(userId, channelId));
   }
 
-  @RequestMapping(value = "", method = RequestMethod.GET)
-  public ResponseEntity<List<ReadStatus>> findAllByUserId(
-      @RequestParam("userId") UUID userId
-  ) {
-
-    List<ReadStatus> readStatuses = readStatusService.findAll().stream()
-        .filter(readStatus -> readStatus.getUserId().equals(userId))
-        .toList();
-
-    return ResponseEntity.ok(readStatuses);
-  }
 
 }