Feature/#2 map letter 기능 구현

.gitignore

@@ -36,17 +36,14 @@ out/
 ### VS Code ###
 .vscode/
 
-### yml ###
-applicaion.yml
-./applicaion.yml
-./src/main/resources/applicaion.yml
-*/applicaion.yml
-*.yml
-src/main/resources/applicaion.yml
-
 ### ds_store ###
 .DS_Store
 ._.DS_Store
 **/.DS_Store
 **/._.DS_Store
 
+### env value ###
+.env
+
+application-test.yml
+src/main/resources/application-test.yml

build.gradle

@@ -31,6 +31,8 @@ dependencies {
     annotationProcessor 'org.projectlombok:lombok'
     testImplementation 'org.springframework.boot:spring-boot-starter-test'
     testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
+    implementation 'org.springframework.boot:spring-boot-starter-validation'
+    testImplementation 'com.h2database:h2:2.2.220'
 }
 
 tasks.named('test') {

src/main/java/postman/bottler/global/response/code/ErrorStatus.java

@@ -10,7 +10,23 @@
 public enum ErrorStatus {
     // 공통 에러
     INVALID_LOGIN(HttpStatus.BAD_REQUEST, "COMMON400"),
-    FORBIDDEN(HttpStatus.FORBIDDEN, "COMMON403");
+    FORBIDDEN(HttpStatus.FORBIDDEN, "COMMON403"),
+
+    // 지도 편지 에러
+    MAP_LETTER_NOT_FOUND(HttpStatus.NOT_FOUND, "MAP4000"),
+    LOCATION_NOT_FOUND(HttpStatus.BAD_REQUEST, "MAP4001"),
+    EMPTY_MAP_LETTER_CONTENT(HttpStatus.BAD_REQUEST, "MAP4002"),
+    EMPTY_MAP_LETTER_TITLE(HttpStatus.BAD_REQUEST, "MAP4003"),
+    EMPTY_MAP_LETTER_TARGET(HttpStatus.BAD_REQUEST, "MAP4004"),
+    MAP_LETTER_ALREADY_DELETED(HttpStatus.BAD_REQUEST, "MAP4005"),
+    EMPTY_MAP_LETTER_DESCRIPTION(HttpStatus.BAD_REQUEST, "MAP4006"),
+    EMPTY_REPLY_MAP_LETTER_SOURCE(HttpStatus.BAD_REQUEST, "MAP4007"),
+    SOURCE_MAP_LETTER_NOT_FOUND(HttpStatus.BAD_REQUEST, "MAP4008"),
+    LETTER_ALREADY_ARCHIVED(HttpStatus.BAD_REQUEST, "MAP4009"),
+    LETTER_ALREADY_REPLY(HttpStatus.BAD_REQUEST, "MAP40010"),
+
+    ;
+
 
     private final HttpStatus httpStatus;
     private final String code;

src/main/java/postman/bottler/mapletter/controller/MapLetterController.java

@@ -1,4 +1,162 @@
 package postman.bottler.mapletter.controller;
 
+import jakarta.validation.Valid;
+import lombok.RequiredArgsConstructor;
+import org.springframework.validation.BindingResult;
+import org.springframework.web.bind.annotation.*;
+import postman.bottler.global.response.ApiResponse;
+import postman.bottler.mapletter.dto.request.*;
+import postman.bottler.mapletter.dto.response.*;
+import postman.bottler.mapletter.exception.*;
+import postman.bottler.mapletter.service.MapLetterService;
+
+import java.math.BigDecimal;
+import java.util.List;
+
+@RestController
+@RequestMapping("/map")
+@RequiredArgsConstructor
 public class MapLetterController {
+
+    private final MapLetterService mapLetterService;
+
+    @PostMapping("/public")
+    public ApiResponse<?> createMapLetter(
+            @Valid @RequestBody CreatePublicMapLetterRequestDTO createPublicMapLetterRequestDTO,
+            BindingResult bindingResult, Long userId) {
+        if (bindingResult.hasErrors()) {
+            bindingResult.getFieldErrors().forEach(error -> {
+                if ("title".equals(error.getField())) {
+                    throw new EmptyMapLetterTitleException(error.getDefaultMessage());
+                } else if ("content".equals(error.getField())) {
+                    throw new EmptyMapLetterContentException(error.getDefaultMessage());
+                } else if ("description".equals(error.getField())) {
+                    throw new EmptyMapLetterDescriptionException(error.getDefaultMessage());
+                }
+            });
+
+            throw new IllegalArgumentException(bindingResult.getAllErrors().get(0).getDefaultMessage()); //기타 오류
+        }
+        mapLetterService.createPublicMapLetter(createPublicMapLetterRequestDTO, userId);
+        return ApiResponse.onCreateSuccess("지도 편지 생성이 성공되었습니다.");
+    }
+
+    @PostMapping("/target")
+    public ApiResponse<?> createTargetLetter(
+            @Valid @RequestBody CreateTargetMapLetterRequestDTO createTargetMapLetterRequestDTO,
+            BindingResult bindingResult, Long userId) {
+        if (bindingResult.hasErrors()) {
+            bindingResult.getFieldErrors().forEach(error -> {
+                if ("title".equals(error.getField())) {
+                    throw new EmptyMapLetterTitleException(error.getDefaultMessage());
+                } else if ("content".equals(error.getField())) {
+                    throw new EmptyMapLetterContentException(error.getDefaultMessage());
+                } else if ("target".equals(error.getField())) {
+                    throw new EmptyMapLetterTargetException(error.getDefaultMessage());
+                } else if ("description".equals(error.getField())) {
+                    throw new EmptyMapLetterDescriptionException(error.getDefaultMessage());
+                }
+            });
+
+            throw new IllegalArgumentException(bindingResult.getAllErrors().get(0).getDefaultMessage()); //기타 오류
+        }
+        mapLetterService.createTargetMapLetter(createTargetMapLetterRequestDTO, userId);
+        return ApiResponse.onCreateSuccess("타겟 편지 생성이 성공되었습니다.");
+    }
+
+    @GetMapping("/{letterId}")
+    public ApiResponse<OneLetterResponseDTO> findOneMapLetter(@PathVariable Long letterId, Long userId) {
+        return ApiResponse.onSuccess(mapLetterService.findOneMepLetter(letterId, userId));
+    }
+
+    @DeleteMapping
+    public ApiResponse<?> deleteMapLetter(@RequestBody DeleteMapLettersRequestDTO letters, Long userId) {
+        mapLetterService.deleteMapLetter(letters.letterIds(), userId);
+        return ApiResponse.onDeleteSuccess(letters);
+    }
+
+    @GetMapping("/sent")
+    public ApiResponse<List<FindMapLetterResponseDTO>> findSentMapLetters(Long userId) {
+        return ApiResponse.onSuccess(mapLetterService.findSentMapLetters(userId));
+    }
+
+    @GetMapping("/received")
+    public ApiResponse<List<FindReceivedMapLetterResponseDTO>> findReceivedMapLetters(Long userId) {
+        return ApiResponse.onSuccess(mapLetterService.findReceivedMapLetters(userId));
+    }
+
+    @GetMapping
+    public ApiResponse<List<FindNearbyLettersResponseDTO>> findNearbyMapLetters(@RequestParam String latitude,
+                                                                                @RequestParam String longitude,
+                                                                                Long userId) {
+        BigDecimal lat = BigDecimal.ZERO;
+        BigDecimal lon = BigDecimal.ZERO;
+        try {
+            lat = new BigDecimal(latitude);
+            lon = new BigDecimal(longitude);
+        } catch (Exception e) {
+            throw new LocationNotFoundException("해당 위치를 찾을 수 없습니다.");
+        }
+
+        return ApiResponse.onSuccess(mapLetterService.findNearByMapLetters(lat, lon, userId));
+    }
+
+    @PostMapping("/reply")
+    public ApiResponse<?> createReplyMapLetter(
+            @Valid @RequestBody CreateReplyMapLetterRequestDTO createReplyMapLetterRequestDTO,
+            BindingResult bindingResult, Long userId) {
+        if (bindingResult.hasErrors()) {
+            bindingResult.getFieldErrors().forEach(error -> {
+                if ("content".equals(error.getField())) {
+                    throw new EmptyMapLetterContentException(error.getDefaultMessage());
+                } else if ("sourceLetter".equals(error.getField())) {
+                    throw new EmptyReplyMapLetterSourceException(error.getDefaultMessage());
+                }
+            });
+
+            throw new IllegalArgumentException(bindingResult.getAllErrors().get(0).getDefaultMessage()); //기타 오류
+        }
+        mapLetterService.createReplyMapLetter(createReplyMapLetterRequestDTO, userId);
+        return ApiResponse.onCreateSuccess("답장 편지 생성이 성공되었습니다.");
+    }
+
+    @GetMapping("/{letterId}/reply")
+    public ApiResponse<List<FindAllReplyMapLettersResponseDTO>> findAllReplyMapLetter(@PathVariable Long letterId,
+                                                                                      Long userId) {
+        return ApiResponse.onSuccess(mapLetterService.findAllReplyMapLetter(letterId, userId));
+    }
+
+    @GetMapping("/reply/{letterId}")
+    public ApiResponse<OneReplyLetterResponseDTO> findOneReplyMapLetter(@PathVariable Long letterId, Long userId) {
+        return ApiResponse.onSuccess(mapLetterService.findOneReplyMapLetter(letterId, userId));
+    }
+
+    @PostMapping("/{letterId}")
+    public ApiResponse<?> mapLetterArchive(@PathVariable Long letterId, Long userId) {
+        mapLetterService.mapLetterArchive(letterId, userId);
+        return ApiResponse.onCreateSuccess("편지 저장이 성공되었습니다.");
+    }
+
+    @GetMapping("/archived")
+    public ApiResponse<List<FindAllArchiveLetters>> findArchiveLetters(Long userId) {
+        return ApiResponse.onSuccess(mapLetterService.findArchiveLetters(userId));
+    }
+
+    @DeleteMapping("/archived")
+    public ApiResponse<?> archiveLetter(@RequestBody DeleteArchivedLettersRequestDTO deleteArchivedLettersRequestDTO
+            , Long userId) {
+        mapLetterService.deleteArchivedLetter(deleteArchivedLettersRequestDTO, userId);
+        return ApiResponse.onDeleteSuccess(deleteArchivedLettersRequestDTO);
+    }
+
+    @GetMapping("/reply/check/{letterId}")
+    public ApiResponse<CheckReplyMapLetterResponseDTO> checkReplyMapLetter(@PathVariable Long letterId, Long userId) {
+        return ApiResponse.onSuccess(mapLetterService.checkReplyMapLetter(letterId, userId));
+    }
+
+    @DeleteMapping("/reply")
+    public ApiResponse<?> deleteReplyMapLetter(@RequestBody DeleteMapLettersRequestDTO letters, Long userId) {
+        mapLetterService.deleteReplyMapLetter(letters.letterIds(), userId);
+        return ApiResponse.onDeleteSuccess(letters);
+    }
 }

src/main/java/postman/bottler/mapletter/controller/PaperController.java

@@ -0,0 +1,23 @@
+package postman.bottler.mapletter.controller;
+
+import lombok.RequiredArgsConstructor;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+import postman.bottler.global.response.ApiResponse;
+import postman.bottler.mapletter.dto.PaperDTO;
+import postman.bottler.mapletter.service.PaperService;
+
+import java.util.List;
+
+@RestController
+@RequestMapping("/paper")
+@RequiredArgsConstructor
+public class PaperController {
+    private final PaperService paperService;
+
+    @GetMapping
+    public ApiResponse<List<PaperDTO>> findPapers() {
+        return ApiResponse.onSuccess(paperService.findPapers());
+    }
+}

src/main/java/postman/bottler/mapletter/domain/MapLetter.java

@@ -1,4 +1,92 @@
 package postman.bottler.mapletter.domain;
 
+import java.math.BigDecimal;
+import java.time.LocalDateTime;
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import postman.bottler.mapletter.dto.request.CreatePublicMapLetterRequestDTO;
+import postman.bottler.mapletter.dto.request.CreateTargetMapLetterRequestDTO;
+import postman.bottler.mapletter.dto.response.OneLetterResponseDTO;
+
+@Builder
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+@AllArgsConstructor(access = AccessLevel.PRIVATE)
+@Getter
 public class MapLetter {
+    private Long id;
+    private String title;
+    private String content;
+    private BigDecimal latitude;
+    private BigDecimal longitude;
+    private String font;
+    private String paper;
+    private String label;
+    private String description;
+    private MapLetterType type;
+    private Long targetUserId;
+    private Long createUserId;
+    private LocalDateTime createdAt;
+    private LocalDateTime updatedAt;
+    private boolean isDeleted;
+    private boolean isBlocked;
+
+    public static MapLetter createPublicMapLetter(CreatePublicMapLetterRequestDTO createPublicMapLetterRequestDTO,
+                                                  Long userId) {
+        return MapLetter.builder()
+                .title(createPublicMapLetterRequestDTO.title())
+                .content(createPublicMapLetterRequestDTO.content())
+                .latitude(createPublicMapLetterRequestDTO.latitude())
+                .longitude(createPublicMapLetterRequestDTO.longitude())
+                .font(createPublicMapLetterRequestDTO.font())
+                .paper(createPublicMapLetterRequestDTO.paper())
+                .label(createPublicMapLetterRequestDTO.label())
+                .type(MapLetterType.PUBLIC)
+                .createUserId(userId)
+                .createdAt(LocalDateTime.now())
+                .updatedAt(LocalDateTime.now())
+                .isDeleted(false)
+                .isBlocked(false)
+                .description(createPublicMapLetterRequestDTO.description())
+                .build();
+    }
+
+    public static MapLetter createTargetMapLetter(CreateTargetMapLetterRequestDTO createTargetMapLetterRequestDTO,
+                                                  Long userId) {
+        return MapLetter.builder()
+                .title(createTargetMapLetterRequestDTO.title())
+                .content(createTargetMapLetterRequestDTO.content())
+                .latitude(createTargetMapLetterRequestDTO.latitude())
+                .longitude(createTargetMapLetterRequestDTO.longitude())
+                .font(createTargetMapLetterRequestDTO.font())
+                .paper(createTargetMapLetterRequestDTO.paper())
+                .label(createTargetMapLetterRequestDTO.label())
+                .type(MapLetterType.PRIVATE)
+                .createUserId(userId)
+                .targetUserId(createTargetMapLetterRequestDTO.target())
+                .createdAt(LocalDateTime.now())
+                .updatedAt(LocalDateTime.now())
+                .isDeleted(false)
+                .isBlocked(false)
+                .description(createTargetMapLetterRequestDTO.description())
+                .build();
+    }
+
+    public static OneLetterResponseDTO toOneLetterResponse(MapLetter mapLetter) {
+        return OneLetterResponseDTO.builder()
+                .title(mapLetter.getTitle())
+                .content(mapLetter.getContent())
+                .font(mapLetter.getFont())
+                .paper(mapLetter.getPaper())
+                .label(mapLetter.getLabel())
+                .createdAt(mapLetter.getCreatedAt())
+                .description(mapLetter.getDescription())
+                .build();
+    }
+
+    public void updateDelete(boolean deleted) {
+        this.isDeleted = deleted;
+    }
 }

src/main/java/postman/bottler/mapletter/domain/MapLetterArchive.java

@@ -0,0 +1,13 @@
+package postman.bottler.mapletter.domain;
+
+import lombok.*;
+
+@Builder
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+@AllArgsConstructor(access = AccessLevel.PRIVATE)
+@Getter
+public class MapLetterArchive {
+    private Long mapLetterArchiveId;
+    private Long mapLetterId;
+    private Long userId;
+}

src/main/java/postman/bottler/mapletter/domain/MapLetterType.java

@@ -0,0 +1,6 @@
+package postman.bottler.mapletter.domain;
+
+public enum MapLetterType {
+    PUBLIC,
+    PRIVATE,
+}

src/main/java/postman/bottler/mapletter/domain/Paper.java

@@ -0,0 +1,17 @@
+package postman.bottler.mapletter.domain;
+
+import lombok.*;
+import postman.bottler.mapletter.dto.PaperDTO;
+
+@Builder
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+@AllArgsConstructor(access = AccessLevel.PRIVATE)
+@Getter
+public class Paper {
+    Long paperId;
+    String paperUrl;
+
+    public static PaperDTO toPaperDTO(Paper paper) {
+        return new PaperDTO(paper.paperId, paper.paperUrl);
+    }
+}