refactor: 어플리케이션단에서 Enum 컬랙션을 List 대신 Set 사용하도록 변경

parkingkim · May 8, 2024 · b45b4f4 · b45b4f4
1 parent 5740b6a
commit b45b4f4
Show file tree

Hide file tree

Showing 33 changed files with 138 additions and 108 deletions.
diff --git a/app-api/src/main/java/com/parkingcomestrue/parking/application/SearchConditionMapper.java b/app-api/src/main/java/com/parkingcomestrue/parking/application/SearchConditionMapper.java
@@ -5,16 +5,18 @@
 import com.parkingcomestrue.parking.support.exception.ClientExceptionInformation;
 import java.util.Arrays;
 import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
 import org.springframework.stereotype.Component;
 
 @Component
 public class SearchConditionMapper {
 
-    public <E extends Enum<E> & SearchConditionAvailable> List<E> toEnums(Class<E> searchConditionAvailableClass,
-                                                                          List<String> descriptions) {
+    public <E extends Enum<E> & SearchConditionAvailable> Set<E> toEnums(Class<E> searchConditionAvailableClass,
+                                                                         List<String> descriptions) {
         return descriptions.stream()
                 .map(description -> toEnum(searchConditionAvailableClass, description))
-                .toList();
+                .collect(Collectors.toSet());
     }
 
     public <E extends Enum<E> & SearchConditionAvailable> E toEnum(Class<E> searchConditionAvailableClass,

diff --git a/app-api/src/main/java/com/parkingcomestrue/parking/application/parking/ParkingService.java b/app-api/src/main/java/com/parkingcomestrue/parking/application/parking/ParkingService.java
@@ -89,10 +89,10 @@ private List<Parking> findParkingLotsByOrderCondition(String priority, ParkingQu
     }
 
     private SearchingCondition toSearchingCondition(ParkingSearchConditionRequest request) {
-        List<ParkingType> parkingTypes = searchConditionMapper.toEnums(ParkingType.class, request.getParkingTypes());
-        List<OperationType> operationTypes = searchConditionMapper.toEnums(OperationType.class,
+        Set<ParkingType> parkingTypes = searchConditionMapper.toEnums(ParkingType.class, request.getParkingTypes());
+        Set<OperationType> operationTypes = searchConditionMapper.toEnums(OperationType.class,
                 request.getOperationTypes());
-        List<PayType> payTypes = searchConditionMapper.toEnums(PayType.class, request.getPayTypes());
+        Set<PayType> payTypes = searchConditionMapper.toEnums(PayType.class, request.getPayTypes());
         FeeType feeType = searchConditionMapper.toEnum(FeeType.class, request.getFeeType());
 
         return new SearchingCondition(operationTypes, parkingTypes, payTypes, feeType, request.getHours());

diff --git a/...rc/main/java/com/parkingcomestrue/parking/application/review/dto/ReviewCreateRequest.java b/...rc/main/java/com/parkingcomestrue/parking/application/review/dto/ReviewCreateRequest.java
@@ -2,12 +2,14 @@
 
 import com.parkingcomestrue.common.domain.review.Content;
 import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
 
 public record ReviewCreateRequest(List<String> contents) {
 
-    public List<Content> toContents() {
+    public Set<Content> toContents() {
         return contents.stream()
                 .map(Content::find)
-                .toList();
+                .collect(Collectors.toSet());
     }
 }
diff --git a/...java/com/parkingcomestrue/parking/application/searchcondition/SearchConditionService.java b/...java/com/parkingcomestrue/parking/application/searchcondition/SearchConditionService.java
@@ -13,6 +13,7 @@
 import com.parkingcomestrue.common.domain.searchcondition.repository.SearchConditionRepository;
 import com.parkingcomestrue.common.support.Association;
 import java.util.List;
+import java.util.Set;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
@@ -41,9 +42,10 @@ private SearchConditionDto toSearchConditionDto(SearchCondition searchCondition)
         );
     }
 
-    private <E extends SearchConditionAvailable> List<String> toDescriptions(List<E> enums) {
+    private <E extends SearchConditionAvailable> List<String> toDescriptions(Set<E> enums) {
         return enums.stream()
                 .map(SearchConditionAvailable::getDescription)
+                .sorted()
                 .toList();
     }
 

diff --git a/app-api/src/main/resources/application.yml b/app-api/src/main/resources/application.yml
@@ -28,4 +28,4 @@ authcode:
 cors:
   allowedOrigins: ${ORIGIN:http://localhost:3000}
 
-api-prefix: ${API_PREFIX:/api/}
+api-prefix: ${API_PREFIX:/}
diff --git a/...api/src/test/java/com/parkingcomestrue/parking/application/SearchConditionMapperTest.java b/...api/src/test/java/com/parkingcomestrue/parking/application/SearchConditionMapperTest.java
@@ -14,6 +14,7 @@
 import com.parkingcomestrue.common.domain.searchcondition.SearchConditionAvailable;
 
 import java.util.List;
+import java.util.Set;
 import java.util.stream.Stream;
 import org.junit.Test;
 import org.junit.jupiter.params.ParameterizedTest;
@@ -63,7 +64,7 @@ static Stream<Arguments> parametersProvider1() {
                                                                                        List<String> descriptions,
                                                                                        List<E> expected) {
         //given, when
-        List<E> actual = searchConditionMapper.toEnums(clazz, descriptions);
+        Set<E> actual = searchConditionMapper.toEnums(clazz, descriptions);
 
         //then
         assertThat(actual).containsExactlyInAnyOrderElementsOf(expected);

diff --git a/...pi/src/test/java/com/parkingcomestrue/parking/application/parking/ParkingServiceTest.java b/...pi/src/test/java/com/parkingcomestrue/parking/application/parking/ParkingServiceTest.java
@@ -25,6 +25,7 @@
 import com.parkingcomestrue.parking.application.review.dto.ReviewCreateRequest;
 import java.time.LocalTime;
 import java.util.List;
+import java.util.Set;
 import org.assertj.core.api.Assertions;
 import org.junit.jupiter.api.Test;
 
@@ -64,7 +65,7 @@ class ParkingServiceTest extends ContainerTest {
     private Parking makeParking(String parkingName) {
         return new Parking
                 (
-                        new BaseInformation(parkingName, "010", "부산", List.of(PayType.NO_INFO), ParkingType.MECHANICAL,
+                        new BaseInformation(parkingName, "010", "부산", Set.of(PayType.NO_INFO), ParkingType.MECHANICAL,
                                 OperationType.PRIVATE),
                         Location.of(30d, 30d),
                         Space.of(100, 30),

diff --git a/app-api/src/test/java/com/parkingcomestrue/parking/application/review/ReviewServiceTest.java b/app-api/src/test/java/com/parkingcomestrue/parking/application/review/ReviewServiceTest.java
@@ -15,6 +15,7 @@
 import com.parkingcomestrue.common.support.Association;
 import com.parkingcomestrue.common.support.exception.DomainException;
 import java.util.List;
+import java.util.Set;
 import org.junit.jupiter.api.Test;
 import repository.BasicMemberRepository;
 import repository.BasicParkingRepository;
@@ -65,9 +66,9 @@ class ReviewServiceTest {
         Association<Parking> parkingId = Association.from(parking.getId());
         List<Member> reviewers = memberRepository.saveAndGet(3);
 
-        List<Content> contents1 = List.of(Content.LOW_PRICE);
-        List<Content> contents2 = List.of(Content.LOW_PRICE, Content.EASY_TO_PAY);
-        List<Content> contents3 = List.of(Content.LOW_PRICE, Content.EASY_TO_PAY, Content.GOOD_ACCESSIBILITY);
+        Set<Content> contents1 = Set.of(Content.LOW_PRICE);
+        Set<Content> contents2 = Set.of(Content.LOW_PRICE, Content.EASY_TO_PAY);
+        Set<Content> contents3 = Set.of(Content.LOW_PRICE, Content.EASY_TO_PAY, Content.GOOD_ACCESSIBILITY);
         reviewRepository.save(
                 new Review(parkingId, Association.from(reviewers.get(0).getId()), contents1)
         );

diff --git a/...ler/src/main/java/com/parkingcomestrue/external/parkingapi/korea/KoreaParkingAdapter.java b/...ler/src/main/java/com/parkingcomestrue/external/parkingapi/korea/KoreaParkingAdapter.java
@@ -10,15 +10,15 @@
 import com.parkingcomestrue.common.domain.parking.Parking;
 import com.parkingcomestrue.common.domain.parking.ParkingType;
 import com.parkingcomestrue.common.domain.parking.PayType;
-import com.parkingcomestrue.common.domain.parking.PayTypes;
 import com.parkingcomestrue.common.domain.parking.Space;
 import com.parkingcomestrue.common.domain.parking.TimeInfo;
 import com.parkingcomestrue.common.domain.parking.TimeUnit;
 import java.time.DateTimeException;
 import java.time.LocalTime;
 import java.time.format.DateTimeFormatter;
-import java.util.ArrayList;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Set;
 import org.apache.logging.log4j.util.Strings;
 import org.springframework.stereotype.Component;
 
@@ -66,14 +66,17 @@ private String filterAddress(KoreaParkingResponse.Response.Body.Item item) {
         return item.getOldAddress();
     }
 
-    private PayTypes toPayTypes(KoreaParkingResponse.Response.Body.Item item) {
-        List<PayType> payTypes = new ArrayList<>();
+    private Set<PayType> toPayTypes(KoreaParkingResponse.Response.Body.Item item) {
+        Set<PayType> payTypes = new HashSet<>();
         for (PayType payType : PayType.values()) {
             if (item.getPayType().contains(payType.getDescription())) {
                 payTypes.add(payType);
             }
         }
-        return PayTypes.from(payTypes);
+        if (payTypes.isEmpty()) {
+            return Set.of(PayType.NO_INFO);
+        }
+        return payTypes;
     }
 
     private Location getLocation(KoreaParkingResponse.Response.Body.Item item) {

diff --git a/...c/main/java/com/parkingcomestrue/external/parkingapi/pusan/PusanPublicParkingAdapter.java b/...c/main/java/com/parkingcomestrue/external/parkingapi/pusan/PusanPublicParkingAdapter.java
@@ -16,8 +16,9 @@
 import java.time.DateTimeException;
 import java.time.LocalTime;
 import java.time.format.DateTimeFormatter;
-import java.util.ArrayList;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Set;
 import org.springframework.stereotype.Component;
 
 @Component
@@ -63,14 +64,17 @@ private String filterAddress(PusanPublicParkingResponse.ParkingInfo.Item respons
         return response.getOldAddress();
     }
 
-    private PayTypes toPayTypes(PusanPublicParkingResponse.ParkingInfo.Item item) {
-        List<PayType> payTypes = new ArrayList<>();
+    private Set<PayType> toPayTypes(PusanPublicParkingResponse.ParkingInfo.Item item) {
+        Set<PayType> payTypes = new HashSet<>();
         for (PayType payType : PayType.values()) {
             if (item.getPayType().contains(payType.getDescription())) {
                 payTypes.add(payType);
             }
         }
-        return PayTypes.from(payTypes);
+        if (payTypes.isEmpty()) {
+            return Set.of(PayType.NO_INFO);
+        }
+        return payTypes;
     }
 
     private Location getLocation(final PusanPublicParkingResponse.ParkingInfo.Item response) {

diff --git a/...c/main/java/com/parkingcomestrue/external/parkingapi/seoul/SeoulPublicParkingAdapter.java b/...c/main/java/com/parkingcomestrue/external/parkingapi/seoul/SeoulPublicParkingAdapter.java
@@ -79,7 +79,7 @@ private BaseInformation getBaseInformation(final SeoulPublicParkingResponse.Park
                 response.getParkingName(),
                 response.getTel(),
                 response.getAddr(),
-                List.of(PayType.NO_INFO),
+                Set.of(PayType.NO_INFO),
                 ParkingType.find(response.getParkingTypeNM()),
                 OperationType.PUBLIC
         );

diff --git a/...src/test/java/com/parkingcomestrue/external/parkingapi/korea/KoreaParkingAdapterTest.java b/...src/test/java/com/parkingcomestrue/external/parkingapi/korea/KoreaParkingAdapterTest.java
@@ -72,14 +72,14 @@ class KoreaParkingAdapterTest {
                     soft.assertThat(parking.getFeePolicy().getBaseFee()).isEqualTo(Fee.ZERO);
                     soft.assertThat(parking.getFeePolicy().getBaseTimeUnit()).isEqualTo(TimeUnit.from(0));
                     soft.assertThat(parking.getFeePolicy().getExtraFee()).isEqualTo(Fee.NO_INFO);
-                    soft.assertThat(parking.getFeePolicy().getExtraTimUnit()).isEqualTo(TimeUnit.NO_INFO);
+                    soft.assertThat(parking.getFeePolicy().getExtraTimeUnit()).isEqualTo(TimeUnit.NO_INFO);
                     soft.assertThat(parking.getFeePolicy().getDayMaximumFee()).isEqualTo(Fee.NO_INFO);
 
                     soft.assertThat(parking.getOperatingTime().getWeekday()).isEqualTo(TimeInfo.ALL_DAY);
                     soft.assertThat(parking.getOperatingTime().getSaturday()).isEqualTo(TimeInfo.ALL_DAY);
                     soft.assertThat(parking.getOperatingTime().getHoliday()).isEqualTo(TimeInfo.ALL_DAY);
 
-                    soft.assertThat(parking.getBaseInformation().getPayTypes().getDescription()).isEqualTo(PayType.CARD.getDescription());
+                    soft.assertThat(parking.getBaseInformation().getPayTypesDescription()).isEqualTo(PayType.CARD.getDescription());
                 }
         );
     }

diff --git a/...st/java/com/parkingcomestrue/external/parkingapi/pusan/PusanPublicParkingAdapterTest.java b/...st/java/com/parkingcomestrue/external/parkingapi/pusan/PusanPublicParkingAdapterTest.java
@@ -73,14 +73,14 @@ class PusanPublicParkingAdapterTest {
                     soft.assertThat(parking.getFeePolicy().getBaseFee()).isEqualTo(Fee.ZERO);
                     soft.assertThat(parking.getFeePolicy().getBaseTimeUnit()).isEqualTo(TimeUnit.from(10));
                     soft.assertThat(parking.getFeePolicy().getExtraFee()).isEqualTo(Fee.ZERO);
-                    soft.assertThat(parking.getFeePolicy().getExtraTimUnit()).isEqualTo(TimeUnit.from(10));
+                    soft.assertThat(parking.getFeePolicy().getExtraTimeUnit()).isEqualTo(TimeUnit.from(10));
                     soft.assertThat(parking.getFeePolicy().getDayMaximumFee()).isEqualTo(Fee.ZERO);
 
                     soft.assertThat(parking.getOperatingTime().getWeekday()).isEqualTo(TimeInfo.ALL_DAY);
                     soft.assertThat(parking.getOperatingTime().getSaturday()).isEqualTo(TimeInfo.ALL_DAY);
                     soft.assertThat(parking.getOperatingTime().getHoliday()).isEqualTo(TimeInfo.ALL_DAY);
 
-                    soft.assertThat(parking.getBaseInformation().getPayTypes().getDescription()).isEqualTo(PayType.NO_INFO.getDescription());
+                    soft.assertThat(parking.getBaseInformation().getPayTypesDescription()).isEqualTo(PayType.NO_INFO.getDescription());
                 }
         );
     }

diff --git a/...st/java/com/parkingcomestrue/external/parkingapi/seoul/SeoulPublicParkingAdapterTest.java b/...st/java/com/parkingcomestrue/external/parkingapi/seoul/SeoulPublicParkingAdapterTest.java
@@ -73,14 +73,14 @@ class SeoulPublicParkingAdapterTest {
             soft.assertThat(parking.getFeePolicy().getBaseFee()).isEqualTo(Fee.from(220));
             soft.assertThat(parking.getFeePolicy().getBaseTimeUnit()).isEqualTo(TimeUnit.from(5));
             soft.assertThat(parking.getFeePolicy().getExtraFee()).isEqualTo(Fee.from(220));
-            soft.assertThat(parking.getFeePolicy().getExtraTimUnit()).isEqualTo(TimeUnit.from(5));
+            soft.assertThat(parking.getFeePolicy().getExtraTimeUnit()).isEqualTo(TimeUnit.from(5));
             soft.assertThat(parking.getFeePolicy().getDayMaximumFee()).isEqualTo(Fee.ZERO);
 
             soft.assertThat(parking.getOperatingTime().getWeekday()).isEqualTo(new TimeInfo(LocalTime.of(9, 0), LocalTime.of(19, 0)));
             soft.assertThat(parking.getOperatingTime().getSaturday()).isEqualTo(new TimeInfo(LocalTime.of(9, 0), LocalTime.of(15, 0)));
             soft.assertThat(parking.getOperatingTime().getHoliday()).isEqualTo(new TimeInfo(LocalTime.of(0, 0), LocalTime.of(0, 0)));
 
-            soft.assertThat(parking.getBaseInformation().getPayTypes().getDescription()).isEqualTo(PayType.NO_INFO.getDescription());
+            soft.assertThat(parking.getBaseInformation().getPayTypesDescription()).isEqualTo(PayType.NO_INFO.getDescription());
         }
         );
     }

diff --git a/app-scheduler/src/test/java/com/parkingcomestrue/fake/NotOfferCurrentParkingApiService.java b/app-scheduler/src/test/java/com/parkingcomestrue/fake/NotOfferCurrentParkingApiService.java
@@ -15,6 +15,7 @@
 import com.parkingcomestrue.external.parkingapi.ParkingApiService;
 import java.util.LinkedList;
 import java.util.List;
+import java.util.Set;
 
 public class NotOfferCurrentParkingApiService implements ParkingApiService {
 
@@ -35,7 +36,7 @@ public List<Parking> read() {
         for (int i = 0; i < readSize; i++) {
             Parking parking = new Parking(
                     new BaseInformation("not offer parking" + i, "051-000" + i, "부산시 어딘가 " + i,
-                            List.of(PayType.NO_INFO),
+                            Set.of(PayType.NO_INFO),
                             ParkingType.NO_INFO,
                             OperationType.PUBLIC),
                     Location.of("33.333" + i, "44.444" + i),

diff --git a/app-scheduler/src/test/java/com/parkingcomestrue/fake/OfferCurrentParkingApiService.java b/app-scheduler/src/test/java/com/parkingcomestrue/fake/OfferCurrentParkingApiService.java
@@ -15,6 +15,7 @@
 import com.parkingcomestrue.external.parkingapi.ParkingApiService;
 import java.util.LinkedList;
 import java.util.List;
+import java.util.Set;
 
 public class OfferCurrentParkingApiService implements ParkingApiService {
 
@@ -34,7 +35,7 @@ public List<Parking> read() {
         LinkedList<Parking> result = new LinkedList<>();
         for (int i = 0; i < readSize; i++) {
             Parking parking = new Parking(
-                    new BaseInformation("offer parking" + i, "02-000" + i, "서울시 어딘가 " + i, List.of(PayType.NO_INFO),
+                    new BaseInformation("offer parking" + i, "02-000" + i, "서울시 어딘가 " + i, Set.of(PayType.NO_INFO),
                             ParkingType.NO_INFO,
                             OperationType.PUBLIC),
                     Location.of("11.111" + i, "22.222" + i),

diff --git a/domain/src/main/java/com/parkingcomestrue/common/domain/parking/BaseInformation.java b/domain/src/main/java/com/parkingcomestrue/common/domain/parking/BaseInformation.java
@@ -3,10 +3,12 @@
 import static jakarta.persistence.EnumType.STRING;
 
 import com.parkingcomestrue.common.infra.converter.PayTypeConverter;
+import com.parkingcomestrue.common.support.exception.DomainException;
+import com.parkingcomestrue.common.support.exception.DomainExceptionInformation;
 import jakarta.persistence.Convert;
 import jakarta.persistence.Embeddable;
 import jakarta.persistence.Enumerated;
-import java.util.List;
+import java.util.Set;
 import java.util.stream.Collectors;
 import lombok.AccessLevel;
 import lombok.Getter;
@@ -24,16 +26,17 @@ public class BaseInformation {
     private String address;
 
     @Convert(converter = PayTypeConverter.class)
-    private List<PayType> payTypes;
+    private Set<PayType> payTypes;
 
     @Enumerated(STRING)
     private ParkingType parkingType;
 
     @Enumerated(STRING)
     private OperationType operationType;
 
-    public BaseInformation(String name, String tel, String address, List<PayType> payTypes, ParkingType parkingType,
+    public BaseInformation(String name, String tel, String address, Set<PayType> payTypes, ParkingType parkingType,
                            OperationType operationType) {
+        validatePayTypes(payTypes);
         this.name = name;
         this.tel = tel;
         this.address = address;
@@ -42,17 +45,23 @@ public BaseInformation(String name, String tel, String address, List<PayType> pa
         this.operationType = operationType;
     }
 
-    public boolean containsOperationType(List<OperationType> operationTypes) {
+    private void validatePayTypes(Set<PayType> payTypes) {
+        if (payTypes == null || payTypes.isEmpty() || payTypes.size() >= PayType.values().length) {
+            throw new DomainException(DomainExceptionInformation.INVALID_PAY_TYPES_SIZE);
+        }
+    }
+
+    public boolean containsOperationType(Set<OperationType> operationTypes) {
         return operationTypes.stream()
                 .anyMatch(operationType -> this.operationType == operationType);
     }
 
-    public boolean containsParkingType(List<ParkingType> parkingTypes) {
+    public boolean containsParkingType(Set<ParkingType> parkingTypes) {
         return parkingTypes.stream()
                 .anyMatch(parkingType -> this.parkingType == parkingType);
     }
 
-    public boolean containsPayType(List<PayType> memberPayTypes) {
+    public boolean containsPayType(Set<PayType> memberPayTypes) {
         if (memberPayTypes.contains(PayType.NO_INFO)) {
             return true;
         }

diff --git a/domain/src/main/java/com/parkingcomestrue/common/domain/parking/Location.java b/domain/src/main/java/com/parkingcomestrue/common/domain/parking/Location.java
@@ -19,7 +19,7 @@
 public class Location {
 
     private static final GeometryFactory geometryFactory = new GeometryFactory(new PrecisionModel(), 4326);
-    private static final Location NO_PROVIDE = new Location(-1.0, -1.0);
+    public static final Location NO_PROVIDE = new Location(-1.0, -1.0);
 
     private static final Double MAX_LONGITUDE = 180.0;
     private static final Double MIN_LONGITUDE = -180.0;

diff --git a/domain/src/main/java/com/parkingcomestrue/common/domain/parking/Parking.java b/domain/src/main/java/com/parkingcomestrue/common/domain/parking/Parking.java
@@ -10,8 +10,8 @@
 import jakarta.persistence.Id;
 import java.time.Duration;
 import java.time.LocalDateTime;
-import java.util.List;
 import java.util.Objects;
+import java.util.Set;
 import lombok.AccessLevel;
 import lombok.Builder;
 import lombok.Getter;
@@ -93,15 +93,15 @@ public void update(Location location) {
         this.location = location;
     }
 
-    public boolean containsOperationType(List<OperationType> operationTypes) {
+    public boolean containsOperationType(Set<OperationType> operationTypes) {
         return baseInformation.containsOperationType(operationTypes);
     }
 
-    public boolean containsParkingType(List<ParkingType> parkingTypes) {
+    public boolean containsParkingType(Set<ParkingType> parkingTypes) {
         return baseInformation.containsParkingType(parkingTypes);
     }
 
-    public boolean containsPayType(List<PayType> memberPayTypes) {
+    public boolean containsPayType(Set<PayType> memberPayTypes) {
         return baseInformation.containsPayType(memberPayTypes);
     }