[Feat] 스토리 등록 구현

src/main/java/eatda/controller/story/FilteredSearchResult.java

@@ -0,0 +1,9 @@
+package eatda.controller.story;
+
+public record FilteredSearchResult(
+        String kakaoId,
+        String name,
+        String address,
+        String category
+) {
+}

src/main/java/eatda/controller/story/StoriesResponse.java

@@ -0,0 +1,13 @@
+package eatda.controller.story;
+
+import java.util.List;
+
+public record StoriesResponse(
+        List<StoryPreview> stories
+) {
+    public record StoryPreview(
+            Long storyId,
+            String imageUrl
+    ) {
+    }
+}

src/main/java/eatda/controller/story/StoryController.java

@@ -0,0 +1,28 @@
+package eatda.controller.story;
+
+import eatda.controller.web.auth.LoginMember;
+import eatda.service.story.StoryService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestPart;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.multipart.MultipartFile;
+
+@RestController
+@RequiredArgsConstructor
+public class StoryController {
+
+    private final StoryService storyService;
+
+    @PostMapping("/api/stories")
+    public ResponseEntity<Void> registerStory(
+            @RequestPart("request") StoryRegisterRequest request,
+            @RequestPart("image") MultipartFile image,
+            LoginMember member
+    ) {
+        storyService.registerStory(request, image, member.id());
+        return ResponseEntity.status(HttpStatus.CREATED).build();
+    }
+}

src/main/java/eatda/controller/story/StoryRegisterRequest.java

@@ -0,0 +1,8 @@
+package eatda.controller.story;
+
+public record StoryRegisterRequest(
+        String query,
+        String storeKakaoId,
+        String description
+) {
+}

src/main/java/eatda/controller/story/StoryResponse.java

@@ -0,0 +1,11 @@
+package eatda.controller.story;
+
+public record StoryResponse(
+        String storeKakaoId,
+        String category,
+        String storeName,
+        String storeAddress,
+        String description,
+        String imageUrl
+) {
+}

src/main/java/eatda/domain/story/Story.java

@@ -0,0 +1,129 @@
+package eatda.domain.story;
+
+import eatda.domain.AuditingEntity;
+import eatda.domain.member.Member;
+import eatda.exception.BusinessErrorCode;
+import eatda.exception.BusinessException;
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.FetchType;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.ManyToOne;
+import jakarta.persistence.Table;
+import lombok.AccessLevel;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+@Table(name = "story")
+@Entity
+@Getter
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+public class Story extends AuditingEntity {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "member_id", nullable = false)
+    private Member member;
+
+    @Column(name = "store_kakao_id", nullable = false)
+    private String storeKakaoId;
+
+    @Column(name = "store_name", nullable = false)
+    private String storeName;
+
+    @Column(name = "store_address", nullable = false)
+    private String storeAddress;
+
+    @Column(name = "store_category", nullable = false)
+    private String storeCategory;
+
+    @Column(name = "description", nullable = false)
+    private String description;
+
+    @Column(name = "image_key", nullable = false)
+    private String imageKey;
+
+    @Builder
+    private Story(
+            Member member,
+            String storeKakaoId,
+            String storeName,
+            String storeAddress,
+            String storeCategory,
+            String description,
+            String imageKey
+    ) {
+        validateMember(member);
+        validateStore(storeKakaoId, storeName, storeAddress, storeCategory);
+        validateStory(description, imageKey);
+
+        this.member = member;
+        this.storeKakaoId = storeKakaoId;
+        this.storeName = storeName;
+        this.storeAddress = storeAddress;
+        this.storeCategory = storeCategory;
+        this.description = description;
+        this.imageKey = imageKey;
+    }
+
+    private void validateMember(Member member) {
+        if (member == null) {
+            throw new BusinessException(BusinessErrorCode.STORY_MEMBER_REQUIRED);
+        }
+    }
+
+    private void validateStore(String storeKakaoId, String storeName, String storeAddress, String storeCategory) {
+        validateStoreKakaoId(storeKakaoId);
+        validateStoreName(storeName);
+        validateStoreAddress(storeAddress);
+        validateStoreCategory(storeCategory);
+    }
+
+    private void validateStory(String description, String imageKey) {
+        validateDescription(description);
+        validateImage(imageKey);
+    }
+
+    private void validateStoreKakaoId(String storeKakaoId) {
+        if (storeKakaoId == null || storeKakaoId.isBlank()) {
+            throw new BusinessException(BusinessErrorCode.INVALID_STORE_KAKAO_ID);
+        }
+    }
+
+    private void validateStoreName(String storeName) {
+        if (storeName == null || storeName.isBlank()) {
+            throw new BusinessException(BusinessErrorCode.INVALID_STORE_NAME);
+        }
+    }
+
+    private void validateStoreAddress(String storeAddress) {
+        if (storeAddress == null || storeAddress.isBlank()) {
+            throw new BusinessException(BusinessErrorCode.INVALID_STORE_ADDRESS);
+        }
+    }
+
+    private void validateStoreCategory(String storeCategory) {
+        if (storeCategory == null || storeCategory.isBlank()) {
+            throw new BusinessException(BusinessErrorCode.INVALID_STORE_CATEGORY);
+        }
+    }
+
+    private void validateDescription(String description) {
+        if (description == null || description.isBlank()) {
+            throw new BusinessException(BusinessErrorCode.INVALID_STORY_DESCRIPTION);
+        }
+    }
+
+    private void validateImage(String imageKey) {
+        if (imageKey == null || imageKey.isBlank()) {
+            throw new BusinessException(BusinessErrorCode.INVALID_STORY_IMAGE_KEY);
+        }
+    }
+}

src/main/java/eatda/exception/BusinessErrorCode.java

@@ -21,6 +21,7 @@ public enum BusinessErrorCode {
     INVALID_STORE_COORDINATES_NULL("STO007", "좌표 값은 필수입니다."),
     OUT_OF_SEOUL_LATITUDE_RANGE("STO010", "서비스 지역(서울)을 벗어난 위도 값입니다."),
     OUT_OF_SEOUL_LONGITUDE_RANGE("STO011", "서비스 지역(서울)을 벗어난 경도 값입니다."),
+    STORE_NOT_FOUND("ST0012", "해당 가게 정보를 찾을수 없습니다."),
 
     // Cheer
     INVALID_CHEER_DESCRIPTION("CHE001", "응원 메시지는 필수입니다."),
@@ -40,7 +41,17 @@ public enum BusinessErrorCode {
     FILE_UPLOAD_FAILED("SERVER002", "파일 업로드에 실패했습니다.", HttpStatus.INTERNAL_SERVER_ERROR),
     FILE_URL_GENERATION_FAILED("SERVER003", "파일 URL 생성에 실패했습니다.", HttpStatus.INTERNAL_SERVER_ERROR),
     PRESIGNED_URL_GENERATION_FAILED("SERVER004", "Presigned URL 생성에 실패했습니다.", HttpStatus.INTERNAL_SERVER_ERROR),
-    ;
+
+    //story
+    INVALID_STORY_DESCRIPTION("STY001", "스토리 본문은 필수입니다."),
+    INVALID_STORY_IMAGE_KEY("STY002", "스토리 이미지 Key는 필수입니다."),
+    STORY_MEMBER_REQUIRED("STY003", "스토리 작성 시 회원 정보는 필수입니다."),
+    STORY_STORE_REQUIRED("STY004", "스토리 작성 시 가게 정보는 필수입니다."),
+    STORY_NOT_FOUND("STY005", "스토리를 찾을 수 없습니다."),
+    INVALID_STORE_ID("STY006", "유효하지 않은 가게 ID입니다."),
+    INVALID_STORE_KAKAO_ID("STY007", "스토어 Kakao ID는 필수입니다."),
+    INVALID_STORE_NAME("STY008", "스토어 이름은 필수입니다."),
+    INVALID_STORE_ADDRESS("STY009", "스토어 주소는 필수입니다.");
 
     private final String code;
     private final String message;

src/main/java/eatda/exception/GlobalExceptionHandler.java

@@ -2,6 +2,7 @@
 
 import jakarta.validation.ConstraintViolationException;
 import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
 import org.apache.catalina.connector.ClientAbortException;
 import org.springframework.http.ResponseEntity;
 import org.springframework.validation.BindException;
@@ -15,6 +16,7 @@
 import org.springframework.web.method.annotation.MethodArgumentTypeMismatchException;
 import org.springframework.web.servlet.resource.NoResourceFoundException;
 
+@Slf4j
 @RestControllerAdvice
 @RequiredArgsConstructor
 public class GlobalExceptionHandler {
@@ -77,13 +79,15 @@ public ResponseEntity<ErrorResponse> handleMissingServletRequestParameterExcepti
 
     @ExceptionHandler(BusinessException.class)
     public ResponseEntity<ErrorResponse> handleBusinessException(BusinessException exception) {
+        log.error("[BusinessException] handled: {}", exception.getErrorCode());
         ErrorResponse response = new ErrorResponse(exception.getErrorCode());
         return ResponseEntity.status(exception.getStatus())
                 .body(response);
     }
 
     @ExceptionHandler(Exception.class)
     public ResponseEntity<ErrorResponse> handleException(Exception exception) {
+        log.error("[Unhandled Exception] {}: {}", exception.getClass().getSimpleName(), exception.getMessage(), exception);
         return toErrorResponse(EtcErrorCode.INTERNAL_SERVER_ERROR);
     }
 

src/main/java/eatda/repository/story/StoryRepository.java

@@ -0,0 +1,19 @@
+package eatda.repository.story;
+
+import eatda.domain.story.Story;
+import eatda.exception.BusinessErrorCode;
+import eatda.exception.BusinessException;
+import java.util.Optional;
+import org.springframework.data.repository.Repository;
+
+public interface StoryRepository extends Repository<Story, Long> {
+
+    Story save(Story story);
+
+    Optional<Story> findById(Long id);
+
+    default Story getById(Long id) {
+        return findById(id)
+                .orElseThrow(() -> new BusinessException(BusinessErrorCode.STORY_NOT_FOUND));
+    }
+}

src/main/java/eatda/service/common/ImageDomain.java

@@ -0,0 +1,15 @@
+package eatda.service.common;
+
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+
+@Getter
+@RequiredArgsConstructor
+public enum ImageDomain {
+    ARTICLE("article"),
+    STORE("store"),
+    MEMBER("member"),
+    STORY("story");
+
+    private final String name;
+}

src/main/java/eatda/service/common/ImageService.java

@@ -20,6 +20,7 @@
 public class ImageService {
 
     private static final Set<String> ALLOWED_CONTENT_TYPES = Set.of("image/jpg", "image/jpeg", "image/png");
+    private static final String DEFAULT_CONTENT_TYPE = "bin";
     private static final String PATH_DELIMITER = "/";
     private static final String EXTENSION_DELIMITER = ".";
     private static final Duration PRESIGNED_URL_DURATION = Duration.ofMinutes(30);
@@ -37,11 +38,11 @@ public ImageService(
         this.s3Presigner = s3Presigner;
     }
 
-    public String upload(MultipartFile file, String domain) {
+    public String upload(MultipartFile file, ImageDomain domain) {
         validateContentType(file);
         String extension = getExtension(file.getOriginalFilename());
         String uuid = UUID.randomUUID().toString();
-        String key = domain + PATH_DELIMITER + uuid + EXTENSION_DELIMITER + extension;
+        String key = domain.getName() + PATH_DELIMITER + uuid + EXTENSION_DELIMITER + extension;
 
         try {
             PutObjectRequest request = PutObjectRequest.builder()
@@ -66,7 +67,7 @@ private void validateContentType(MultipartFile file) {
 
     private String getExtension(String filename) {
         if (filename == null || filename.lastIndexOf(EXTENSION_DELIMITER) == -1 || filename.startsWith(EXTENSION_DELIMITER)) {
-            return "bin";
+            return DEFAULT_CONTENT_TYPE;
         }
         return filename.substring(filename.lastIndexOf(EXTENSION_DELIMITER) + 1);
     }

src/main/java/eatda/service/store/StoreService.java

@@ -19,4 +19,9 @@ public StoreSearchResponses searchStores(String query) {
         List<StoreSearchResult> filteredResults = storeSearchFilter.filterSearchedStores(searchResults);
         return StoreSearchResponses.from(filteredResults);
     }
+
+    public List<StoreSearchResult> searchStoreResults(String query) {
+        List<StoreSearchResult> searchResults = mapClient.searchShops(query);
+        return storeSearchFilter.filterSearchedStores(searchResults);
+    }
 }