Merge pull request #221 from Team-Hankki/develop

[feat] 운영 서버 배포

src/main/java/org/hankki/hankkiserver/api/advice/GlobalExceptionHandler.java

@@ -1,11 +1,15 @@
 package org.hankki.hankkiserver.api.advice;
 
+import jakarta.validation.ConstraintViolationException;
 import lombok.extern.slf4j.Slf4j;
 import org.hankki.hankkiserver.api.dto.HankkiResponse;
 import org.hankki.hankkiserver.common.code.BusinessErrorCode;
 import org.hankki.hankkiserver.common.code.StoreErrorCode;
 import org.hankki.hankkiserver.common.code.StoreImageErrorCode;
-import org.hankki.hankkiserver.common.exception.*;
+import org.hankki.hankkiserver.common.exception.BadRequestException;
+import org.hankki.hankkiserver.common.exception.ConflictException;
+import org.hankki.hankkiserver.common.exception.NotFoundException;
+import org.hankki.hankkiserver.common.exception.UnauthorizedException;
 import org.springframework.http.converter.HttpMessageNotReadableException;
 import org.springframework.web.HttpRequestMethodNotSupportedException;
 import org.springframework.web.bind.MethodArgumentNotValidException;
@@ -98,4 +102,10 @@ public HankkiResponse<Void> handleException(Exception e) {
         log.error("[500] INTERNAL SERVER ERROR({}) : {}",e.getClass() , e.getMessage());
         return HankkiResponse.fail(BusinessErrorCode.INTERNAL_SERVER_ERROR);
     }
+
+    @ExceptionHandler(ConstraintViolationException.class)
+    public HankkiResponse<Void> handleConstraintViolationException(ConstraintViolationException e) {
+        log.warn("handleConstraintViolationException() in GlobalExceptionHandler throw ConstraintViolationException : {}", e.getMessage());
+        return HankkiResponse.fail(BusinessErrorCode.BAD_REQUEST);
+    }
 }

src/main/java/org/hankki/hankkiserver/api/menu/controller/MenuController.java

@@ -1,45 +1,66 @@
 package org.hankki.hankkiserver.api.menu.controller;
 
 import jakarta.validation.Valid;
+import jakarta.validation.constraints.Min;
+import java.util.List;
 import lombok.RequiredArgsConstructor;
 import org.hankki.hankkiserver.api.dto.HankkiResponse;
 import org.hankki.hankkiserver.api.menu.service.MenuCommandService;
 import org.hankki.hankkiserver.api.menu.service.command.MenuDeleteCommand;
 import org.hankki.hankkiserver.api.menu.service.command.MenuPatchCommand;
 import org.hankki.hankkiserver.api.menu.service.command.MenuPostCommand;
 import org.hankki.hankkiserver.api.menu.service.command.MenusPostCommand;
+import org.hankki.hankkiserver.api.menu.service.response.MenusGetResponse;
 import org.hankki.hankkiserver.api.menu.service.response.MenusPostResponse;
 import org.hankki.hankkiserver.api.store.controller.request.MenuPostRequest;
+import org.hankki.hankkiserver.auth.UserId;
 import org.hankki.hankkiserver.common.code.CommonSuccessCode;
-import org.springframework.web.bind.annotation.*;
-
-import java.util.List;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PatchMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+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")
+@Validated
 public class MenuController {
 
     private final MenuCommandService menuCommandService;
 
     @DeleteMapping("/{storeId}/menus/{id}")
-    public HankkiResponse<Void> deleteMenu(@PathVariable("storeId") final Long storeId, @PathVariable("id") final Long id) {
-        menuCommandService.deleteMenu(MenuDeleteCommand.of(storeId, id));
+    public HankkiResponse<Void> deleteMenu(@PathVariable("storeId") @Min(value = 1L) final long storeId,
+                                           @PathVariable("id") @Min(value = 1L) final long id,
+                                           @UserId final Long userId) {
+        menuCommandService.deleteMenu(MenuDeleteCommand.of(storeId, id, userId));
         return HankkiResponse.success(CommonSuccessCode.NO_CONTENT);
     }
 
     @PatchMapping("/{storeId}/menus/{id}")
-    public HankkiResponse<Void> updateMenu(@PathVariable("storeId") final Long storeId, @PathVariable("id") final Long id,
+    public HankkiResponse<Void> updateMenu(@PathVariable("storeId") @Min(value = 1L) final long storeId,
+                                           @PathVariable("id") @Min(value = 1L) final long id,
                                            @Valid @RequestBody final MenuPostRequest request) {
         menuCommandService.modifyMenu(MenuPatchCommand.of(storeId, id, request.name(), request.price()));
         return HankkiResponse.success(CommonSuccessCode.OK);
     }
 
-    @PostMapping("{storeId}/menus/bulk")
-    public HankkiResponse<MenusPostResponse> createMenu(@PathVariable final Long storeId, @Valid @RequestBody final List<MenuPostRequest> request) {
+    @PostMapping("/{storeId}/menus/bulk")
+    public HankkiResponse<MenusPostResponse> createMenu(@PathVariable @Min(value = 1L) final long storeId,
+                                                        @Valid @RequestBody final List<MenuPostRequest> request) {
         List<MenuPostCommand> command = request.stream()
                 .map(r -> MenuPostCommand.of(r.name(), r.price()))
                 .toList();
-        return HankkiResponse.success(CommonSuccessCode.CREATED, menuCommandService.createMenus(MenusPostCommand.of(storeId, command)));
+        return HankkiResponse.success(CommonSuccessCode.CREATED,
+                menuCommandService.createMenus(MenusPostCommand.of(storeId, command)));
+    }
+
+    @GetMapping("/{storeId}/menus")
+    public HankkiResponse<MenusGetResponse> getMenus(@PathVariable @Min(value = 1L) final long storeId) {
+        return HankkiResponse.success(CommonSuccessCode.OK, menuCommandService.getMenus(storeId));
     }
 }

src/main/java/org/hankki/hankkiserver/api/menu/service/DeletedMenuUpdater.java

@@ -0,0 +1,17 @@
+package org.hankki.hankkiserver.api.menu.service;
+
+import lombok.RequiredArgsConstructor;
+import org.hankki.hankkiserver.domain.menu.model.DeletedMenu;
+import org.hankki.hankkiserver.domain.menu.repository.DeletedMenuRepository;
+import org.springframework.stereotype.Component;
+
+@Component
+@RequiredArgsConstructor
+public class DeletedMenuUpdater {
+
+    private final DeletedMenuRepository deletedMenuRepository;
+
+    public void save(final DeletedMenu deletedMenu) {
+        deletedMenuRepository.save(deletedMenu);
+    }
+}

src/main/java/org/hankki/hankkiserver/api/menu/service/MenuCommandService.java

@@ -1,18 +1,22 @@
 package org.hankki.hankkiserver.api.menu.service;
 
+import java.util.List;
 import lombok.RequiredArgsConstructor;
 import org.hankki.hankkiserver.api.menu.service.command.MenuDeleteCommand;
 import org.hankki.hankkiserver.api.menu.service.command.MenuPatchCommand;
 import org.hankki.hankkiserver.api.menu.service.command.MenusPostCommand;
+import org.hankki.hankkiserver.api.menu.service.response.MenusGetResponse;
 import org.hankki.hankkiserver.api.menu.service.response.MenusPostResponse;
 import org.hankki.hankkiserver.api.store.service.StoreFinder;
+import org.hankki.hankkiserver.api.store.service.StoreUpdater;
+import org.hankki.hankkiserver.domain.menu.model.DeletedMenu;
 import org.hankki.hankkiserver.domain.menu.model.Menu;
 import org.hankki.hankkiserver.domain.store.model.Store;
+import org.hankki.hankkiserver.event.EventPublisher;
+import org.hankki.hankkiserver.event.store.DeleteStoreEvent;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
-import java.util.List;
-
 @Service
 @RequiredArgsConstructor
 public class MenuCommandService {
@@ -21,12 +25,18 @@ public class MenuCommandService {
     private final MenuFinder menuFinder;
     private final MenuUpdater menuUpdater;
     private final StoreFinder storeFinder;
+    private final StoreUpdater storeUpdater;
+    private final DeletedMenuUpdater deletedMenuUpdater;
+    private final EventPublisher publisher;
 
     @Transactional
     public void deleteMenu(final MenuDeleteCommand command) {
-        Menu menu = menuFinder.findByStoreIdAndId(command.storeId(), command.id());
+        Store findStore = storeFinder.findByIdWhereDeletedIsFalse(command.storeId());
+        Menu menu = menuFinder.findByStoreIdAndId(findStore.getId(), command.id());
         menuDeleter.deleteMenu(menu);
+        saveToDeletedMenu(menu, findStore.getId());
         updateLowestPriceInStore(storeFinder.findByIdWhereDeletedIsFalse(command.storeId()));
+        checkNoMenuInStore(findStore, command.userId());
     }
 
     @Transactional
@@ -48,11 +58,30 @@ public MenusPostResponse createMenus(final MenusPostCommand command) {
         return MenusPostResponse.of(menus);
     }
 
+    @Transactional(readOnly = true)
+    public MenusGetResponse getMenus(final long storeId) {
+        Store findStore = storeFinder.findByIdWhereDeletedIsFalse(storeId);
+        List<Menu> findMenus = menuFinder.findAllByStore(findStore);
+        return MenusGetResponse.of(findMenus);
+    }
+
     private void updateLowestPriceInStore(final Store findStore) {
         findStore.updateLowestPrice(menuFinder.findLowestPriceByStore(findStore));
     }
 
-    private boolean validateMenuConflict(Store store, String menuName) {
+    private boolean validateMenuConflict(final Store store, final String menuName) {
         return menuFinder.existsByStoreAndName(store, menuName);
     }
-}
+
+    private void checkNoMenuInStore(final Store store, final long userId) {
+        if (!menuFinder.existsByStoreId(store.getId())) {
+            storeUpdater.deleteStore(store.getId());
+            publisher.publish(DeleteStoreEvent.of(store.getName(), userId));
+        }
+    }
+
+    private void saveToDeletedMenu(final Menu menu, final long storedId) {
+        DeletedMenu deletedMenu = DeletedMenu.create(menu.getName(), menu.getPrice(), storedId);
+        deletedMenuUpdater.save(deletedMenu);
+    }
+}

src/main/java/org/hankki/hankkiserver/api/menu/service/MenuFinder.java

@@ -20,15 +20,20 @@ public List<Menu> findAllByStore(final Store store) {
         return menuRepository.findAllByStore(store);
     }
 
-    protected Menu findByStoreIdAndId(final Long storeId, final Long id) {
-        return menuRepository.findByStoreIdAndId(storeId,id).orElseThrow(() -> new NotFoundException(MenuErrorCode.MENU_NOT_FOUND));
+    protected Menu findByStoreIdAndId(final long storeId, final long id) {
+        return menuRepository.findByStoreIdAndId(storeId,id)
+                .orElseThrow(() -> new NotFoundException(MenuErrorCode.MENU_NOT_FOUND));
     }
 
     protected boolean existsByStoreAndName(final Store store, final String name) {
         return menuRepository.existsByStoreAndName(store, name);
     }
 
-    protected int findLowestPriceByStore(Store store) {
+    protected int findLowestPriceByStore(final Store store) {
         return menuRepository.findLowestPriceByStore(store);
     }
+
+    protected boolean existsByStoreId(final long storeId) {
+        return menuRepository.existsByStoreId(storeId);
+    }
 }

src/main/java/org/hankki/hankkiserver/api/menu/service/command/MenuDeleteCommand.java

@@ -2,9 +2,10 @@
 
 public record MenuDeleteCommand(
         long storeId,
-        long id
+        long id,
+        long userId
 ) {
-    public static MenuDeleteCommand of(long storeId, long id) {
-        return new MenuDeleteCommand(storeId, id);
+    public static MenuDeleteCommand of(long storeId, long id, long userId) {
+        return new MenuDeleteCommand(storeId, id, userId);
     }
 }

src/main/java/org/hankki/hankkiserver/api/menu/service/response/MenuGetResponse.java

@@ -0,0 +1,13 @@
+package org.hankki.hankkiserver.api.menu.service.response;
+
+import org.hankki.hankkiserver.domain.menu.model.Menu;
+
+public record MenuGetResponse (
+        long id,
+        int price,
+        String name
+){
+    public static MenuGetResponse of(final Menu menu) {
+        return new MenuGetResponse(menu.getId(), menu.getPrice(), menu.getName());
+    }
+}

src/main/java/org/hankki/hankkiserver/api/menu/service/response/MenusGetResponse.java

@@ -0,0 +1,15 @@
+package org.hankki.hankkiserver.api.menu.service.response;
+
+import java.util.List;
+import org.hankki.hankkiserver.domain.menu.model.Menu;
+
+public record MenusGetResponse(
+        List<MenuGetResponse> menus
+) {
+    public static MenusGetResponse of(final List<Menu> menus) {
+        List<MenuGetResponse> findmenus = menus.stream()
+                .map(MenuGetResponse::of)
+                .toList();
+        return new MenusGetResponse(findmenus);
+    }
+}

src/main/java/org/hankki/hankkiserver/api/menu/service/response/MenusPostResponse.java

@@ -5,12 +5,12 @@
 import java.util.List;
 
 public record MenusPostResponse(
-        List<MenuPostResponse> menuList
+        List<MenuPostResponse> menus
 ) {
     public static MenusPostResponse of(List<Menu> menus) {
         List<MenuPostResponse> menuResponses = menus.stream()
                 .map(MenuPostResponse::of)
                 .toList();
         return new MenusPostResponse(menuResponses);
     }
-}
+}

src/main/java/org/hankki/hankkiserver/api/store/service/StoreUpdater.java

@@ -1,6 +1,8 @@
 package org.hankki.hankkiserver.api.store.service;
 
 import lombok.RequiredArgsConstructor;
+import org.hankki.hankkiserver.common.code.StoreErrorCode;
+import org.hankki.hankkiserver.common.exception.NotFoundException;
 import org.hankki.hankkiserver.domain.store.model.Store;
 import org.hankki.hankkiserver.domain.store.repository.StoreRepository;
 import org.springframework.stereotype.Component;
@@ -14,4 +16,10 @@ public class StoreUpdater {
     public Store save(final Store store) {
         return storeRepository.save(store);
     }
+
+    public void deleteStore(final Long id) {
+        Store store =  storeRepository.findByIdAndIsDeletedIsFalse(id)
+                .orElseThrow(() -> new NotFoundException(StoreErrorCode.STORE_NOT_FOUND));
+        store.softDelete();
+    }
 }

src/main/java/org/hankki/hankkiserver/api/university/controller/UniversityController.java

@@ -2,10 +2,15 @@
 
 import lombok.RequiredArgsConstructor;
 import org.hankki.hankkiserver.api.dto.HankkiResponse;
+import org.hankki.hankkiserver.api.university.controller.request.UniversitiesPostRequest;
+import org.hankki.hankkiserver.api.university.service.UniversityCommandService;
 import org.hankki.hankkiserver.api.university.service.UniversityQueryService;
+import org.hankki.hankkiserver.api.university.service.command.UniversitiesPostCommand;
 import org.hankki.hankkiserver.api.university.service.response.UniversitiesResponse;
 import org.hankki.hankkiserver.common.code.CommonSuccessCode;
 import org.springframework.web.bind.annotation.GetMapping;
+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;
 
@@ -15,9 +20,16 @@
 public class UniversityController {
 
     private final UniversityQueryService universityQueryService;
+    private final UniversityCommandService universityCommandService;
 
     @GetMapping("/universities")
     public HankkiResponse<UniversitiesResponse> getUniversities() {
         return HankkiResponse.success(CommonSuccessCode.OK, universityQueryService.findAllByOrderByName());
     }
+
+    @PostMapping("/universities")
+    public HankkiResponse<Void> createUniversities(@RequestBody UniversitiesPostRequest universitiesPostRequest) {
+        universityCommandService.createUniversities(UniversitiesPostCommand.of(universitiesPostRequest));
+        return HankkiResponse.success(CommonSuccessCode.CREATED);
+    }
 }

src/main/java/org/hankki/hankkiserver/api/university/controller/request/UniversitiesPostRequest.java

@@ -0,0 +1,7 @@
+package org.hankki.hankkiserver.api.university.controller.request;
+
+import java.util.List;
+
+public record UniversitiesPostRequest(List<UniversityRequest> universities) {
+  public record UniversityRequest(String name, double longitude, double latitude) { }
+}

src/main/java/org/hankki/hankkiserver/api/university/service/UniversityCommandService.java

@@ -0,0 +1,18 @@
+package org.hankki.hankkiserver.api.university.service;
+
+import lombok.RequiredArgsConstructor;
+import org.hankki.hankkiserver.api.university.service.command.UniversitiesPostCommand;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+@Service
+@RequiredArgsConstructor
+public class UniversityCommandService {
+
+  private final UniversityUpdater universityUpdater;
+
+  @Transactional
+  public void createUniversities(UniversitiesPostCommand universitiesPostCommand) {
+    universityUpdater.saveAll(universitiesPostCommand.toEntityList());
+  }
+}

src/main/java/org/hankki/hankkiserver/api/university/service/UniversityUpdater.java

@@ -0,0 +1,18 @@
+package org.hankki.hankkiserver.api.university.service;
+
+import java.util.List;
+import lombok.RequiredArgsConstructor;
+import org.hankki.hankkiserver.domain.university.model.University;
+import org.hankki.hankkiserver.domain.university.repository.UniversityRepository;
+import org.springframework.stereotype.Component;
+
+@Component
+@RequiredArgsConstructor
+public class UniversityUpdater {
+
+  private final UniversityRepository universityRepository;
+
+  void saveAll(List<University> universities){
+    universityRepository.saveAll(universities);
+  }
+}