feat: 검수할 장소 등록/ 조회 API 구현

backend/src/main/java/com/now/naaga/auth/presentation/interceptor/ManagerAuthInterceptor.java

@@ -20,7 +20,7 @@ public class ManagerAuthInterceptor implements HandlerInterceptor {
 
     public static final int AUTH_HEADER_INFO_SIZE = 2;
 
-    public static final String AUTH_HEADER_TYPE = "Basic ";
+    public static final String AUTH_HEADER_TYPE = "Basic";
 
     @Value("${manager.id}")
     private String id;
@@ -41,12 +41,12 @@ private List<String> extractHeaderInfo(final HttpServletRequest request) {
         if (header == null) {
             throw new AuthException(NOT_EXIST_HEADER);
         }
-        final String decodedHeader = new String(Base64.getDecoder().decode(header));
-        if (!decodedHeader.startsWith(AUTH_HEADER_TYPE)) {
+        final String[] authHeader = header.split(" ");
+        if (!AUTH_HEADER_TYPE.equals(authHeader[0])) {
             throw new AuthException(INVALID_HEADER);
         }
-        final String decodedHeaderWithoutType = decodedHeader.replace(AUTH_HEADER_TYPE, "");
-        final String[] idAndPassword = decodedHeaderWithoutType.split(":");
+        final String decodedHeader = new String(Base64.getDecoder().decode(authHeader[1]));
+        final String[] idAndPassword = decodedHeader.split(":");
         if (idAndPassword.length != AUTH_HEADER_INFO_SIZE) {
             throw new AuthException(INVALID_HEADER);
         }

backend/src/main/java/com/now/naaga/common/config/WebConfig.java

@@ -3,6 +3,7 @@
 import com.now.naaga.auth.presentation.argumentresolver.MemberAuthArgumentResolver;
 import com.now.naaga.auth.presentation.argumentresolver.PlayerArgumentResolver;
 import com.now.naaga.auth.presentation.interceptor.AuthInterceptor;
+import com.now.naaga.auth.presentation.interceptor.ManagerAuthInterceptor;
 import com.now.naaga.common.presentation.interceptor.RequestMatcherInterceptor;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.context.annotation.Configuration;
@@ -24,20 +25,25 @@ public class WebConfig implements WebMvcConfigurer {
 
     private final AuthInterceptor authInterceptor;
 
+    private final ManagerAuthInterceptor managerAuthInterceptor;
+
     @Value("${manager.origin-url}")
     private String managerUriPath;
 
     public WebConfig(final PlayerArgumentResolver playerArgumentResolver,
                      final MemberAuthArgumentResolver memberAuthArgumentResolver,
-                     final AuthInterceptor authInterceptor) {
+                     final AuthInterceptor authInterceptor,
+                     final ManagerAuthInterceptor managerAuthInterceptor) {
         this.playerArgumentResolver = playerArgumentResolver;
         this.memberAuthArgumentResolver = memberAuthArgumentResolver;
         this.authInterceptor = authInterceptor;
+        this.managerAuthInterceptor = managerAuthInterceptor;
     }
 
     @Override
     public void addInterceptors(final InterceptorRegistry registry) {
         registry.addInterceptor(mapAuthInterceptor());
+        registry.addInterceptor(mapManagerAuthInterceptor());
     }
 
     private HandlerInterceptor mapAuthInterceptor() {
@@ -51,7 +57,13 @@ private HandlerInterceptor mapAuthInterceptor() {
                 .excludeRequestPattern("/**/*.gif")
                 .excludeRequestPattern("/**/*.ico")
                 .excludeRequestPattern("/ranks")
-                .excludeRequestPattern("/**", HttpMethod.OPTIONS);
+                .excludeRequestPattern("/**", HttpMethod.OPTIONS)
+                .excludeRequestPattern("/temporary-places", HttpMethod.GET);
+    }
+
+    private HandlerInterceptor mapManagerAuthInterceptor() {
+        return new RequestMatcherInterceptor(managerAuthInterceptor)
+                .includeRequestPattern("/temporary-places", HttpMethod.GET);
     }
 
     @Override

backend/src/main/java/com/now/naaga/place/application/PlaceService.java

@@ -1,54 +1,35 @@
 package com.now.naaga.place.application;
 
-import static com.now.naaga.place.exception.PlaceExceptionType.NO_EXIST;
-
 import com.now.naaga.common.domain.OrderType;
-import com.now.naaga.common.infrastructure.FileManager;
 import com.now.naaga.place.application.dto.CreatePlaceCommand;
 import com.now.naaga.place.application.dto.FindAllPlaceCommand;
 import com.now.naaga.place.application.dto.FindPlaceByIdCommand;
 import com.now.naaga.place.application.dto.RecommendPlaceCommand;
 import com.now.naaga.place.domain.Place;
-import com.now.naaga.place.domain.PlaceCheckService;
 import com.now.naaga.place.domain.PlaceRecommendService;
 import com.now.naaga.place.domain.Position;
 import com.now.naaga.place.domain.SortType;
 import com.now.naaga.place.exception.PlaceException;
 import com.now.naaga.place.persistence.repository.PlaceRepository;
-import com.now.naaga.player.application.PlayerService;
-import com.now.naaga.player.domain.Player;
-import java.io.File;
-import java.util.List;
-
-import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
-import org.springframework.web.multipart.MultipartFile;
+
+import java.util.List;
+
+import static com.now.naaga.place.exception.PlaceExceptionType.NO_EXIST;
 
 @Transactional
 @Service
 public class PlaceService {
 
     private final PlaceRepository placeRepository;
 
-    private final PlayerService playerService;
-
-    private final PlaceCheckService placeCheckService;
-
     private final PlaceRecommendService placeRecommendService;
 
-    private final FileManager<MultipartFile> fileManager;
-
     public PlaceService(final PlaceRepository placeRepository,
-                        final PlayerService playerService,
-                        final PlaceCheckService placeCheckService,
-                        final PlaceRecommendService placeRecommendService,
-                        final FileManager<MultipartFile> fileManager) {
+                        final PlaceRecommendService placeRecommendService) {
         this.placeRepository = placeRepository;
-        this.playerService = playerService;
-        this.placeCheckService = placeCheckService;
         this.placeRecommendService = placeRecommendService;
-        this.fileManager = fileManager;
     }
 
     @Transactional(readOnly = true)
@@ -73,23 +54,6 @@ public Place recommendPlaceByPosition(final RecommendPlaceCommand recommendPlace
     }
 
     public Place createPlace(final CreatePlaceCommand createPlaceCommand) {
-        final Position position = createPlaceCommand.position();
-        placeCheckService.checkOtherPlaceNearby(position);
-        final File uploadPath = fileManager.save(createPlaceCommand.imageFile());
-        try {
-            final Long playerId = createPlaceCommand.playerId();
-            final Player registeredPlayer = playerService.findPlayerById(playerId);
-            final Place place = new Place(
-                    createPlaceCommand.name(),
-                    createPlaceCommand.description(),
-                    position,
-                    fileManager.convertToUrlPath(uploadPath),
-                    registeredPlayer);
-            placeRepository.save(place);
-            return place;
-        } catch (final RuntimeException exception) {
-            uploadPath.delete();
-            throw exception;
-        }
+        return null;
     }
 }

backend/src/main/java/com/now/naaga/place/domain/PlaceCheckService.java

@@ -3,10 +3,11 @@
 import com.now.naaga.place.exception.PlaceException;
 import com.now.naaga.place.exception.PlaceExceptionType;
 import com.now.naaga.place.persistence.repository.PlaceRepository;
-import java.util.List;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
+import java.util.List;
+
 @Transactional
 @Service
 public class PlaceCheckService {
@@ -20,7 +21,7 @@ public PlaceCheckService(final PlaceRepository placeRepository) {
     @Transactional(readOnly = true)
     public void checkOtherPlaceNearby(final Position position) {
         List<Place> places = placeRepository.findPlaceByPositionAndDistance(position, 0.02);
-        if (places.size() > 0) {
+        if (!places.isEmpty()) {
             throw new PlaceException(PlaceExceptionType.ALREADY_EXIST_NEARBY);
         }
     }

backend/src/main/java/com/now/naaga/place/exception/PlaceExceptionType.java

@@ -22,6 +22,7 @@ public enum PlaceExceptionType implements BaseExceptionType {
             HttpStatus.BAD_REQUEST,
             "이미 주변에 장소가 존재합니다."
     ),
+
     ;
 
     private final int errorCode;

backend/src/main/java/com/now/naaga/temporaryplace/application/TemporaryPlaceService.java

@@ -0,0 +1,61 @@
+package com.now.naaga.temporaryplace.application;
+
+import com.now.naaga.common.infrastructure.FileManager;
+import com.now.naaga.place.domain.Position;
+import com.now.naaga.player.application.PlayerService;
+import com.now.naaga.player.domain.Player;
+import com.now.naaga.temporaryplace.application.dto.CreateTemporaryPlaceCommand;
+import com.now.naaga.temporaryplace.domain.TemporaryPlace;
+import com.now.naaga.temporaryplace.repository.TemporaryPlaceRepository;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.web.multipart.MultipartFile;
+
+import java.io.File;
+import java.util.Comparator;
+import java.util.List;
+
+@Transactional
+@Service
+public class TemporaryPlaceService {
+
+    private final TemporaryPlaceRepository temporaryPlaceRepository;
+
+    private final PlayerService playerService;
+
+    private final FileManager<MultipartFile> fileManager;
+
+    public TemporaryPlaceService(final TemporaryPlaceRepository temporaryPlaceRepository,
+                                 final PlayerService playerService,
+                                 final FileManager<MultipartFile> fileManager) {
+        this.temporaryPlaceRepository = temporaryPlaceRepository;
+        this.playerService = playerService;
+        this.fileManager = fileManager;
+    }
+
+    public TemporaryPlace createTemporaryPlace(final CreateTemporaryPlaceCommand createTemporaryPlaceCommand) {
+        final Position position = createTemporaryPlaceCommand.position();
+        final File uploadPath = fileManager.save(createTemporaryPlaceCommand.imageFile());
+        try {
+            final Long playerId = createTemporaryPlaceCommand.playerId();
+            final Player registeredPlayer = playerService.findPlayerById(playerId);
+            final TemporaryPlace temporaryPlace = new TemporaryPlace(
+                    createTemporaryPlaceCommand.name(),
+                    createTemporaryPlaceCommand.description(),
+                    position,
+                    fileManager.convertToUrlPath(uploadPath),
+                    registeredPlayer);
+            return temporaryPlaceRepository.save(temporaryPlace);
+        } catch (final RuntimeException exception) {
+            uploadPath.delete();
+            throw exception;
+        }
+    }
+
+    @Transactional(readOnly = true)
+    public List<TemporaryPlace> findAllPlace() {
+        final List<TemporaryPlace> temporaryPlaces = temporaryPlaceRepository.findAll();
+        temporaryPlaces.sort(Comparator.comparing(TemporaryPlace::getCreatedAt));
+        return temporaryPlaces;
+    }
+}

backend/src/main/java/com/now/naaga/temporaryplace/application/dto/CreateTemporaryPlaceCommand.java

@@ -0,0 +1,24 @@
+package com.now.naaga.temporaryplace.application.dto;
+
+import com.now.naaga.place.domain.Position;
+import com.now.naaga.player.presentation.dto.PlayerRequest;
+import com.now.naaga.temporaryplace.presentation.dto.CreateTemporaryPlaceRequest;
+import org.springframework.web.multipart.MultipartFile;
+
+public record CreateTemporaryPlaceCommand(Long playerId,
+                                          String name,
+                                          String description,
+                                          Position position,
+                                          MultipartFile imageFile)  {
+
+    public static CreateTemporaryPlaceCommand of(final PlayerRequest playerRequest,
+                                                 final CreateTemporaryPlaceRequest createTemporaryPlaceRequest) {
+        Position position = Position.of(createTemporaryPlaceRequest.latitude(), createTemporaryPlaceRequest.longitude());
+        return new CreateTemporaryPlaceCommand(
+                playerRequest.playerId(),
+                createTemporaryPlaceRequest.name(),
+                createTemporaryPlaceRequest.description(),
+                position,
+                createTemporaryPlaceRequest.imageFile());
+    }
+}

backend/src/main/java/com/now/naaga/temporaryplace/presentation/TemporaryPlaceController.java

@@ -1,9 +1,47 @@
 package com.now.naaga.temporaryplace.presentation;
 
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RestController;
+import com.now.naaga.auth.presentation.annotation.Auth;
+import com.now.naaga.player.presentation.dto.PlayerRequest;
+import com.now.naaga.temporaryplace.application.TemporaryPlaceService;
+import com.now.naaga.temporaryplace.application.dto.CreateTemporaryPlaceCommand;
+import com.now.naaga.temporaryplace.domain.TemporaryPlace;
+import com.now.naaga.temporaryplace.presentation.dto.CreateTemporaryPlaceRequest;
+import com.now.naaga.temporaryplace.presentation.dto.TemporaryPlaceResponse;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.net.URI;
+import java.util.List;
 
 @RequestMapping("/temporary-places")
 @RestController
 public class TemporaryPlaceController {
+
+    private final TemporaryPlaceService temporaryPlaceService;
+
+    public TemporaryPlaceController(final TemporaryPlaceService temporaryPlaceService) {
+        this.temporaryPlaceService = temporaryPlaceService;
+    }
+
+    @GetMapping
+    public ResponseEntity<List<TemporaryPlaceResponse>> findAllTemporaryPlace() {
+        final List<TemporaryPlace> temporaryPlaces = temporaryPlaceService.findAllPlace();
+        final List<TemporaryPlaceResponse> response = TemporaryPlaceResponse.convertToResponses(temporaryPlaces);
+        return ResponseEntity
+                .status(HttpStatus.OK)
+                .body(response);
+    }
+
+    @PostMapping
+    public ResponseEntity<TemporaryPlaceResponse> createTemporaryPlace(@Auth final PlayerRequest playerRequest,
+                                                                       @ModelAttribute final CreateTemporaryPlaceRequest createTemporaryPlaceRequest) {
+        final CreateTemporaryPlaceCommand createTemporaryPlaceCommand = CreateTemporaryPlaceCommand.of(playerRequest, createTemporaryPlaceRequest);
+        final TemporaryPlace temporaryPlace = temporaryPlaceService.createTemporaryPlace(createTemporaryPlaceCommand);
+        final TemporaryPlaceResponse response = TemporaryPlaceResponse.from(temporaryPlace);
+        return ResponseEntity
+                .status(HttpStatus.CREATED)
+                .location(URI.create("/temporary-places/" + temporaryPlace.getId()))
+                .body(response);
+    }
 }

backend/src/main/java/com/now/naaga/temporaryplace/presentation/dto/CreateTemporaryPlaceRequest.java

@@ -0,0 +1,10 @@
+package com.now.naaga.temporaryplace.presentation.dto;
+
+import org.springframework.web.multipart.MultipartFile;
+
+public record CreateTemporaryPlaceRequest(String name,
+                                          String description,
+                                          Double latitude,
+                                          Double longitude,
+                                          MultipartFile imageFile) {
+}

backend/src/main/java/com/now/naaga/temporaryplace/presentation/dto/TemporaryPlaceResponse.java

@@ -0,0 +1,33 @@
+package com.now.naaga.temporaryplace.presentation.dto;
+
+import com.now.naaga.game.presentation.dto.CoordinateResponse;
+import com.now.naaga.temporaryplace.domain.TemporaryPlace;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+public record TemporaryPlaceResponse(Long id,
+                                     String name,
+                                     CoordinateResponse coordinate,
+                                     String imageUrl,
+                                     String description
+
+) {
+
+    public static TemporaryPlaceResponse from(final TemporaryPlace savedTemporaryPlace) {
+        CoordinateResponse coordinateResponse = CoordinateResponse.of(savedTemporaryPlace.getPosition());
+        return new TemporaryPlaceResponse(
+                savedTemporaryPlace.getId(),
+                savedTemporaryPlace.getName(),
+                coordinateResponse,
+                savedTemporaryPlace.getImageUrl(),
+                savedTemporaryPlace.getDescription()
+        );
+    }
+
+    public static List<TemporaryPlaceResponse> convertToResponses(final List<TemporaryPlace> temporaryPlaces) {
+        return temporaryPlaces.stream()
+                .map(TemporaryPlaceResponse::from)
+                .collect(Collectors.toList());
+    }
+}

backend/src/main/resources/logback-spring.xml

@@ -28,7 +28,7 @@
                   value="/home/ubuntu/logs"/>
     </springProfile>
 
-    <root level="DEBUG">
+    <root level="INFO">
         <appender-ref ref="CONSOLE"/>
     </root>
 

backend/src/test/java/com/now/naaga/auth/presentation/interceptor/ManagerAuthInterceptorTest.java

@@ -36,12 +36,12 @@ class ManagerAuthInterceptorTest {
     @Test
     void Auth_헤더를_Base64_헤더를_디코딩해서_관리자_로그인을_처리한다() throws Exception {
         // given
-        final String s = "Basic "+id+":"+password;
+        final String s = id+":"+password;
         final String authHeader = new String(Base64.getEncoder().encode(s.getBytes()));
         final MockHttpServletRequest request = new MockHttpServletRequest();
         final MockHttpServletResponse response = new MockHttpServletResponse();
         final Controller controller = Mockito.mock(Controller.class);
-        request.addHeader("Authorization", authHeader);
+        request.addHeader("Authorization","Basic "+ authHeader);
 
         // when
         final boolean expected = managerAuthInterceptor.preHandle(request, response, controller);