Feat/address

.gitignore

@@ -41,4 +41,7 @@ out/
 rebel.xml
 
 ### .DS_Store ###
-.DS_Store
+.DS_Store
+
+### application.yml ###
+src/main/resources/application-local.yml

build.gradle

@@ -68,7 +68,9 @@ dependencies {
 	annotationProcessor "jakarta.persistence:jakarta.persistence-api"
 	//s3 bucket (img)
 	implementation 'org.springframework.cloud:spring-cloud-starter-aws:2.2.6.RELEASE'
-
+	//json-simple
+	implementation group: 'com.googlecode.json-simple', name: 'json-simple', version: '1.1.1'
+	implementation 'org.json:json:20210307'
 	testImplementation 'org.springframework.boot:spring-boot-starter-test'
 }
 

src/main/java/com/kusitms/jipbap/common/response/ErrorCode.java

@@ -34,6 +34,14 @@ public enum ErrorCode {
     //food
     CATEGORY_NOT_FOUND_ERROR(false, HttpStatus.BAD_REQUEST.value(), "존재하지 않는 카테고리입니다."),
     FOOD_NOT_FOUND_ERROR(false, HttpStatus.BAD_REQUEST.value(), "존재하지 않는 메뉴입니다."),
+
+    //address
+    REGION_ALREADY_EXISTS_ERROR(false, HttpStatus.BAD_REQUEST.value(), "이미 존재하는 지역입니다."),
+    REGION_NOT_FOUND_ERROR(false, HttpStatus.BAD_REQUEST.value(), "존재하지 않는 지역입니다."),
+    GEOCODING_CONNECTION_ERROR(false, HttpStatus.BAD_REQUEST.value(), "지오코딩 서버와 연결할 수 없습니다."),
+    GEOCODING_INVALID_REQUEST_ERROR(false, HttpStatus.BAD_REQUEST.value(), "지오코딩 서버의 알 수 없는 오류입니다. 다시 요청해주세요."),
+    GEOCODING_UNKNOWN_ADDRESS_ERROR(false, HttpStatus.BAD_REQUEST.value(), "찾을 수 없는 주소입니다. 주소를 다시 확인해주세요."),
+    GEOCODING_QUERY_MISSING_ERROR(false, HttpStatus.BAD_REQUEST.value(), "지오코딩 쿼리가 없습니다. 다시 요청해주세요.")
     ;
 
     private Boolean isSuccess;

src/main/java/com/kusitms/jipbap/config/SpringSecurityConfig.java

@@ -65,7 +65,8 @@ public WebSecurityCustomizer webSecurityCustomizer() {
                 "/error",
                 "/auth/**",
                 "/ws/**", //ws://localhost:8080/ws/chat
-                "/ws-stomp/**"
+                "/ws-stomp/**",
+                "/addresses/**"
                 );
     }
 }

src/main/java/com/kusitms/jipbap/user/User.java

@@ -1,6 +1,7 @@
 package com.kusitms.jipbap.user;
 
 import com.kusitms.jipbap.common.entity.DateEntity;
+import com.kusitms.jipbap.user.entity.GlobalRegion;
 import jakarta.persistence.*;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
@@ -33,9 +34,19 @@ public class User extends DateEntity {
     @Column(unique = true)
     private String username; //닉네임
 
+    @ManyToOne
+    @JoinColumn(name = "global_region_id")
+    private GlobalRegion globalRegion; //지역
+
     @NotBlank
     private String address; //주소
 
+    @NotBlank
+    private String detailAddress; //상세주소
+
+    @NotBlank
+    private String postalCode; //우편번호
+
     private String image; //프로필 사진
 
     private String phoneNum;

src/main/java/com/kusitms/jipbap/user/UserAddressController.java

@@ -0,0 +1,50 @@
+package com.kusitms.jipbap.user;
+
+import com.kusitms.jipbap.common.response.CommonResponse;
+import com.kusitms.jipbap.user.dto.address.*;
+import com.kusitms.jipbap.user.entity.GlobalRegion;
+import com.kusitms.jipbap.user.repository.GlobalRegionRepository;
+import io.swagger.v3.oas.annotations.Operation;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.HttpStatus;
+import org.springframework.web.bind.annotation.*;
+
+import javax.validation.Valid;
+import java.util.List;
+
+@RequiredArgsConstructor
+@RestController
+@RequestMapping("/addresses")
+public class UserAddressController {
+
+    private final UserAddressService userAddressService;
+
+    @Operation(summary = "사용자 주소 설정")
+    @PostMapping("")
+    @ResponseStatus(HttpStatus.CREATED)
+    public CommonResponse<UserAddressResponse> saveUserAddress(@Valid @RequestBody UserAddressRequest dto) {
+        return new CommonResponse<>(userAddressService.saveUserAddress(dto));
+    }
+
+    @Operation(summary = "유효한 주소인지 확인하고 우편번호 반환하기")
+    @GetMapping("/valid")
+    @ResponseStatus(HttpStatus.OK)
+    public CommonResponse<PostalAddressDto> getValidPostalCode(@RequestParam String address) {
+        return new CommonResponse<>(userAddressService.getValidPostalCode(address));
+    }
+
+    @Operation(summary = "지역 코드 데이터 저장하기")
+    @PostMapping("/global-area")
+    @ResponseStatus(HttpStatus.CREATED)
+    public CommonResponse<GlobalRegionResponse> saveGlobalAreaData(@Valid @RequestBody GlobalRegionRequest dto) {
+        return new CommonResponse<>(userAddressService.saveGlobalAreaData(dto));
+    }
+
+    @Operation(summary = "모든 지역 코드 데이터 조회하기")
+    @GetMapping("/global-area")
+    @ResponseStatus(HttpStatus.OK)
+    public CommonResponse<List<GlobalRegionResponse>> getAllGlobalAreaData() {
+        return new CommonResponse<>(userAddressService.getAllGlobalAreaData());
+    }
+
+}

src/main/java/com/kusitms/jipbap/user/UserAddressExceptionController.java

@@ -0,0 +1,57 @@
+package com.kusitms.jipbap.user;
+
+import com.kusitms.jipbap.common.response.CommonResponse;
+import com.kusitms.jipbap.common.response.ErrorCode;
+import com.kusitms.jipbap.user.exception.*;
+import jakarta.servlet.http.HttpServletRequest;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.HttpStatus;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.bind.annotation.ResponseStatus;
+import org.springframework.web.bind.annotation.RestControllerAdvice;
+
+@Slf4j
+@RestControllerAdvice
+public class UserAddressExceptionController {
+    @ExceptionHandler(RegionExistsException.class)
+    @ResponseStatus(HttpStatus.BAD_REQUEST)
+    public CommonResponse<?> RegionExistsException(RegionExistsException e, HttpServletRequest request) {
+        log.warn("UserAddress-001> 요청 URI: " + request.getRequestURI() + ", 에러 메세지: " + e.getMessage());
+        return new CommonResponse<>(ErrorCode.REGION_ALREADY_EXISTS_ERROR);
+    }
+
+    @ExceptionHandler(RegionNotFoundException.class)
+    @ResponseStatus(HttpStatus.BAD_REQUEST)
+    public CommonResponse<?> RegionNotFoundException(RegionNotFoundException e, HttpServletRequest request) {
+        log.warn("UserAddress-002> 요청 URI: " + request.getRequestURI() + ", 에러 메세지: " + e.getMessage());
+        return new CommonResponse<>(ErrorCode.REGION_NOT_FOUND_ERROR);
+    }
+
+    @ExceptionHandler(GeocodingConnectionException.class)
+    @ResponseStatus(HttpStatus.BAD_REQUEST)
+    public CommonResponse<?> GeocodingConnectionException(GeocodingConnectionException e, HttpServletRequest request) {
+        log.warn("UserAddress-003> 요청 URI: " + request.getRequestURI() + ", 에러 메세지: " + e.getMessage());
+        return new CommonResponse<>(ErrorCode.GEOCODING_CONNECTION_ERROR);
+    }
+
+    @ExceptionHandler(GeocodingUnknownAddressException.class)
+    @ResponseStatus(HttpStatus.BAD_REQUEST)
+    public CommonResponse<?> GeocodingUnknownAddressException(GeocodingUnknownAddressException e, HttpServletRequest request) {
+        log.warn("UserAddress-004> 요청 URI: " + request.getRequestURI() + ", 에러 메세지: " + e.getMessage());
+        return new CommonResponse<>(ErrorCode.GEOCODING_UNKNOWN_ADDRESS_ERROR);
+    }
+
+    @ExceptionHandler(GeocodingInvalidRequestException.class)
+    @ResponseStatus(HttpStatus.BAD_REQUEST)
+    public CommonResponse<?> GeocodingInvalidRequestException(GeocodingInvalidRequestException e, HttpServletRequest request) {
+        log.warn("UserAddress-005> 요청 URI: " + request.getRequestURI() + ", 에러 메세지: " + e.getMessage());
+        return new CommonResponse<>(ErrorCode.GEOCODING_INVALID_REQUEST_ERROR);
+    }
+
+    @ExceptionHandler(GeocodingQueryMissingException.class)
+    @ResponseStatus(HttpStatus.BAD_REQUEST)
+    public CommonResponse<?> GeocodingQueryMissingException(GeocodingQueryMissingException e, HttpServletRequest request) {
+        log.warn("UserAddress-006> 요청 URI: " + request.getRequestURI() + ", 에러 메세지: " + e.getMessage());
+        return new CommonResponse<>(ErrorCode.GEOCODING_QUERY_MISSING_ERROR);
+    }
+}

src/main/java/com/kusitms/jipbap/user/UserAddressService.java

@@ -0,0 +1,128 @@
+package com.kusitms.jipbap.user;
+
+import com.kusitms.jipbap.user.dto.address.*;
+import com.kusitms.jipbap.user.dto.geolocation.AddressComponentDto;
+import com.kusitms.jipbap.user.dto.geolocation.GeocodingAddressDto;
+import com.kusitms.jipbap.user.dto.geolocation.GeocodingResponseDto;
+import com.kusitms.jipbap.user.entity.GlobalRegion;
+import com.kusitms.jipbap.user.exception.*;
+import com.kusitms.jipbap.user.repository.GlobalRegionRepository;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.web.client.RestTemplate;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class UserAddressService {
+
+    private final GlobalRegionRepository globalRegionRepository;
+    private final UserRepository userRepository;
+
+    @Value("${secret.geocodingApiKey}")
+    private String apiKey;
+
+    @Transactional
+    public UserAddressResponse saveUserAddress(UserAddressRequest dto) {
+        User user = userRepository.findById(dto.getUserId())
+                .orElseThrow(() -> new UserNotFoundException("유저 정보가 존재하지 않습니다."));
+        GlobalRegion globalRegion = globalRegionRepository.findById(dto.getGlobalRegionId())
+                .orElseThrow(() -> new RegionNotFoundException("지역 정보가 존재하지 않습니다."));
+
+        setUserData(user, globalRegion, dto);
+
+        return new UserAddressResponse(user);
+    }
+
+    public GlobalRegionResponse saveGlobalAreaData(GlobalRegionRequest dto) {
+        if (globalRegionRepository.existsByRegionName(dto.getRegionName()))
+            throw new RegionExistsException("이미 존재하는 지역입니다.");
+
+        GlobalRegion globalRegion = globalRegionRepository.save(dto.toEntity());
+        return new GlobalRegionResponse(globalRegion);
+    }
+
+    public List<GlobalRegionResponse> getAllGlobalAreaData() {
+        List<GlobalRegion> globalRegionList = globalRegionRepository.findAll();
+
+        List<GlobalRegionResponse> globalRegionResponse = globalRegionList.stream()
+                .map(GlobalRegionResponse::new)
+                .collect(Collectors.toList());
+
+        return globalRegionResponse;
+    }
+
+    @Transactional
+    public PostalAddressDto getValidPostalCode(String address) {
+        return getGeocodingData(address);
+    }
+
+    private PostalAddressDto getGeocodingData(String address) {
+        try {
+            String apiUrl = "https://maps.googleapis.com/maps/api/geocode/json?address=" + address + "&key=" + apiKey;
+
+            RestTemplate restTemplate = new RestTemplate();
+            GeocodingResponseDto responseDto = restTemplate.getForObject(apiUrl, GeocodingResponseDto.class);
+            //String response = restTemplate.getForObject(apiUrl, String.class);
+            log.info("{} 주소에 대한 getGeocodingData API response 결과 : {} ", address, responseDto.getStatus());
+
+            switch (responseDto.getStatus()) {
+                case "OK":
+                    return findPostalAddress(responseDto.getResults().get(0));
+                case "ZERO_RESULTS":
+                    throw new GeocodingUnknownAddressException("주소가 존재하지 않습니다.");
+                case "OVER_DAILY_LIMIT":
+                case "OVER_QUERY_LIMIT":
+                case "REQUEST_DENIED":
+                    throw new GeocodingConnectionException("API키가 잘못되었거나 결제가 사용 설정 되지 않았습니다.");
+                case "INVALID_REQUEST":
+                    throw new GeocodingQueryMissingException("쿼리가 누락되었습니다.");
+                case "UNKNOWN_ERROR":
+                    throw new GeocodingUnknownAddressException("알 수 없는 지오코딩 에러입니다.");
+                default:
+                    throw new GeocodingConnectionException("서버 에러입니다.");
+            }
+        } catch (Exception e) {
+            //e.printStackTrace();
+            throw e;
+        }
+    }
+
+    private void setUserData(User user, GlobalRegion globalRegion, UserAddressRequest dto) {
+        user.setGlobalRegion(globalRegion);
+        user.setAddress(dto.getAddress());
+        user.setDetailAddress(dto.getDetailAddress());
+        user.setPostalCode(dto.getPostalCode());
+    }
+
+    private PostalAddressDto findPostalAddress(GeocodingAddressDto geocodingAddressDto) {
+        try {
+            String formattedAddress = geocodingAddressDto.getFormattedAddress(); // 실제 데이터베이스에 저장할 주소
+
+            Double lat = geocodingAddressDto.getGeometry().getLocation().getLat();
+            Double lng = geocodingAddressDto.getGeometry().getLocation().getLng();
+
+            String countryName = null;
+            String postalCode = null;
+            for (AddressComponentDto addressComponent : geocodingAddressDto.getAddressComponentList()) {
+                List<String> types = addressComponent.getTypes();
+                if (types != null && types.contains("country")) {
+                    countryName = addressComponent.getLongName();
+                }
+                if (types != null && types.contains("postal_code")) {
+                    postalCode = addressComponent.getLongName();
+                }
+            }
+            return new PostalAddressDto(formattedAddress, postalCode);
+        } catch (NullPointerException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+}

src/main/java/com/kusitms/jipbap/user/dto/address/GlobalRegionRequest.java

@@ -0,0 +1,36 @@
+package com.kusitms.jipbap.user.dto.address;
+
+import com.kusitms.jipbap.user.entity.GlobalRegion;
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.persistence.Column;
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+public class GlobalRegionRequest {
+    @Schema(description = "국가명(영문)", example = "United States")
+    private String countryLongName;
+
+    @Schema(description = "축약 국가명(영문)", example = "US")
+    private String countryShortName;
+
+    @Schema(description = "국가명(한글)", example = "미국")
+    private String countryKorean;
+
+    @Schema(description = "지역명(영문)", example = "New York")
+    private String regionName;
+
+    @Schema(description = "지역명(한글)", example = "뉴욕")
+    private String regionKorean;
+
+    public GlobalRegion toEntity() {
+        return GlobalRegion.builder()
+                .countryLongName(countryLongName)
+                .countryShortName(countryShortName)
+                .countryKorean(countryKorean)
+                .regionName(regionName)
+                .regionKorean(regionKorean)
+                .build();
+    }
+}

src/main/java/com/kusitms/jipbap/user/dto/address/GlobalRegionResponse.java

@@ -0,0 +1,30 @@
+package com.kusitms.jipbap.user.dto.address;
+
+import com.kusitms.jipbap.user.entity.GlobalRegion;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+public class GlobalRegionResponse {
+    private Long id;
+    private String countryShortName;
+    private String countryKorean;
+    private String regionName;
+    private String regionKorean;
+
+    public GlobalRegionResponse(GlobalRegion globalRegion) {
+        this.id = globalRegion.getId();
+        this.countryShortName = globalRegion.getCountryShortName();
+        this.countryKorean = globalRegion.getCountryKorean();
+        this.regionName = globalRegion.getRegionName();
+        this.regionKorean = globalRegion.getRegionKorean();
+    }
+}

src/main/java/com/kusitms/jipbap/user/dto/address/PostalAddressDto.java

@@ -0,0 +1,15 @@
+package com.kusitms.jipbap.user.dto.address;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+public class PostalAddressDto {
+    String formattedAddress;
+    String postalCode;
+}