Refactor/#57 user

build.gradle

@@ -66,9 +66,13 @@ dependencies {
 	runtimeOnly 'com.mysql:mysql-connector-j'
 
 	// MongoDB
-	/*implementation 'org.springframework.boot:spring-boot-starter-data-mongodb'
-	implementation 'org.mongodb:mongodb-driver-sync'
-	implementation 'org.mongodb:mongodb-driver-core'*/
+	implementation 'org.springframework.boot:spring-boot-starter-data-mongodb'
+//	implementation 'org.mongodb:mongodb-driver-sync'
+//	implementation 'org.mongodb:mongodb-driver-core'
+
+	// Caffeine
+	implementation 'org.springframework.boot:spring-boot-starter-cache'
+	implementation 'com.github.ben-manes.caffeine:caffeine'
 
 	// redis
 	implementation 'org.springframework.boot:spring-boot-starter-data-redis'

src/main/java/com/hyetaekon/hyetaekon/HyetaekonApplication.java

@@ -4,10 +4,12 @@
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.data.jpa.repository.config.EnableJpaAuditing;
 import org.springframework.scheduling.annotation.EnableScheduling;
+import org.springframework.data.mongodb.repository.config.EnableMongoRepositories;
 
 @EnableJpaAuditing
 @SpringBootApplication
 @EnableScheduling
+@EnableMongoRepositories
 public class HyetaekonApplication {
 
 	public static void main(String[] args) {

src/main/java/com/hyetaekon/hyetaekon/bookmark/controller/BookMarkController.java

@@ -19,7 +19,7 @@ public class BookMarkController {
   // 북마크 추가
   @PostMapping
   public ResponseEntity<Void> addBookmark(
-      @PathVariable("serviceId") Long serviceId,
+      @PathVariable("serviceId") String serviceId,
       @AuthenticationPrincipal CustomUserDetails customUserDetails
   ) {
     bookmarkService.addBookmark(serviceId, customUserDetails.getId());
@@ -29,7 +29,7 @@ public ResponseEntity<Void> addBookmark(
   // 북마크 제거
   @DeleteMapping
   public ResponseEntity<Void> removeBookmark(
-      @PathVariable("serviceId") Long serviceId,
+      @PathVariable("serviceId") String serviceId,
       @AuthenticationPrincipal CustomUserDetails customUserDetails
   ) {
     bookmarkService.removeBookmark(serviceId, customUserDetails.getId());

src/main/java/com/hyetaekon/hyetaekon/bookmark/repository/BookmarkRepository.java

@@ -11,9 +11,9 @@
 @Repository
 public interface BookmarkRepository extends JpaRepository<Bookmark, Long> {
 
-    boolean existsByUserIdAndPublicServiceId(Long userId, Long serviceId);
+    boolean existsByUserIdAndPublicServiceId(Long userId, String serviceId);
 
-    Optional<Bookmark> findByUserIdAndPublicServiceId(Long userId, Long serviceId);
+    Optional<Bookmark> findByUserIdAndPublicServiceId(Long userId, String serviceId);
 
     /*@Query("SELECT b FROM Bookmark b " +
         "JOIN FETCH b.publicService ps " +

src/main/java/com/hyetaekon/hyetaekon/bookmark/service/BookmarkService.java

@@ -5,6 +5,7 @@
 import com.hyetaekon.hyetaekon.common.exception.GlobalException;
 import com.hyetaekon.hyetaekon.publicservice.entity.PublicService;
 import com.hyetaekon.hyetaekon.publicservice.repository.PublicServiceRepository;
+import com.hyetaekon.hyetaekon.publicservice.service.PublicServiceHandler;
 import com.hyetaekon.hyetaekon.user.entity.User;
 import com.hyetaekon.hyetaekon.user.repository.UserRepository;
 import jakarta.transaction.Transactional;
@@ -20,8 +21,9 @@ public class BookmarkService {
     private final BookmarkRepository bookmarkRepository;
     private final UserRepository userRepository;
     private final PublicServiceRepository publicServiceRepository;
+    private final PublicServiceHandler publicServiceHandler;
 
-    public void addBookmark(Long serviceId, Long userId) {
+    public void addBookmark(String serviceId, Long userId) {
         User user = userRepository.findById(userId)
             .orElseThrow(() -> new GlobalException(BOOKMARK_USER_NOT_FOUND));
 
@@ -42,10 +44,11 @@ public void addBookmark(Long serviceId, Long userId) {
 
         // 북마크 수 증가
         publicService.increaseBookmarkCount();
+        publicServiceRepository.save(publicService);
     }
 
     @Transactional
-    public void removeBookmark(Long serviceId, Long userId) {
+    public void removeBookmark(String serviceId, Long userId) {
         Bookmark bookmark = bookmarkRepository.findByUserIdAndPublicServiceId(userId, serviceId)
             .orElseThrow(() -> new GlobalException(BOOKMARK_NOT_FOUND));
 
@@ -54,5 +57,6 @@ public void removeBookmark(Long serviceId, Long userId) {
         // 북마크 수 감소
         PublicService publicService = bookmark.getPublicService();
         publicService.decreaseBookmarkCount();
+        publicServiceRepository.save(publicService);
     }
 }

src/main/java/com/hyetaekon/hyetaekon/common/config/CacheConfig.java

@@ -0,0 +1,35 @@
+package com.hyetaekon.hyetaekon.common.config;
+
+import com.github.benmanes.caffeine.cache.Caffeine;
+import org.springframework.cache.CacheManager;
+import org.springframework.cache.annotation.EnableCaching;
+import org.springframework.cache.caffeine.CaffeineCacheManager;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import com.hyetaekon.hyetaekon.publicservice.entity.mongodb.CacheType;
+
+import java.time.Duration;
+import java.util.Arrays;
+
+@Configuration
+@EnableCaching
+public class CacheConfig {
+    @Bean
+    public CacheManager cacheManager() {
+        CaffeineCacheManager cacheManager = new CaffeineCacheManager();
+
+        // 각 캐시 타입에 대한 설정 등록
+        Arrays.stream(CacheType.values())
+            .forEach(cacheType -> {
+                cacheManager.registerCustomCache(cacheType.getCacheName(),
+                    Caffeine.newBuilder()
+                        .recordStats()   // 캐시 통계 기록
+                        .expireAfterWrite(Duration.ofHours(cacheType.getExpiredAfterWrite()))  // 항목 만료 시간
+                        .maximumSize(cacheType.getMaximumSize())  // 최대 크기
+                        .build()
+                );
+            });
+
+        return cacheManager;
+    }
+}

src/main/java/com/hyetaekon/hyetaekon/common/config/SecurityConfig.java

@@ -4,6 +4,7 @@
 import lombok.RequiredArgsConstructor;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
+import org.springframework.http.HttpMethod;
 import org.springframework.security.authentication.AuthenticationManager;
 import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
 import org.springframework.security.config.annotation.method.configuration.EnableMethodSecurity;
@@ -49,8 +50,9 @@ public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
     // 경로별 인가 작업
     http
         .authorizeHttpRequests((auth) -> auth
+            .requestMatchers("/api/posts/type", "/api/posts/type/**", "/api/posts/search").permitAll()
             .requestMatchers(SecurityPath.ADMIN_ENDPOINTS).hasRole("ADMIN")
-            .requestMatchers(SecurityPath.USER_ENDPOINTS).hasRole("USER")
+            .requestMatchers(SecurityPath.USER_ENDPOINTS).hasAnyRole("USER", "ADMIN")
             .requestMatchers(SecurityPath.PUBLIC_ENDPOINTS).permitAll()
             .anyRequest().permitAll()
         );
@@ -72,8 +74,8 @@ public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
   public CorsConfigurationSource corsConfigurationSource() {
     org.springframework.web.cors.CorsConfiguration configuration = new org.springframework.web.cors.CorsConfiguration();
     configuration.addAllowedOrigin("http://localhost:3000"); // 개발 환경
-    configuration.addAllowedOrigin("https://hyetaek-on.site"); // 혜택온 도메인
-    configuration.addAllowedOrigin("https://www.hyetaek-on.site");
+    configuration.addAllowedOrigin("https://hyetaek-on.co.kr"); // 혜택온 도메인
+    configuration.addAllowedOrigin("https://www.hyetaek-on.co.kr");
     configuration.addAllowedMethod("*"); // 모든 HTTP 메서드 허용
     configuration.addAllowedHeader("*"); // 모든 헤더 허용
     configuration.setAllowedHeaders(java.util.List.of("Authorization", "Content-Type"));

src/main/java/com/hyetaekon/hyetaekon/common/config/SecurityPath.java

@@ -11,26 +11,33 @@ public class SecurityPath {
       "/api/users/check-duplicate",
       "/",
       "/api/services",
+      "/api/services/popular",
       "/api/services/category/*",
       "/api/services/detail/*",
-      "/api/public-data/serviceList/test"
+      "/api/public-data/serviceList/test",
+      "/api/mongo/services/search",
+      "/api/mongo/services/search/autocomplete"
   };
 
-
   // hasRole("USER")
   public static final String[] USER_ENDPOINTS = {
-      "/api/users/me/**",
       "/api/users/me",
+      "/api/users/me/**",
       "/api/logout",
-      "/api/services/popular",
       "/api/services/*/bookmark",
       "/api/interests",
-      "/api/interests/me"
+      "/api/interests/me",
+      "/api/posts",
+      "/api/posts/*",
+      "/api/search/history",
+      "/api/search/history/*",
+      "/api/mongo/services/matched",
+      "/api/users/reports"
   };
 
   // hasRole("ADMIN")
   public static final String[] ADMIN_ENDPOINTS = {
-      "/api/admin/users/**",
+      "/api/admin/**",
       "/api/public-data/serviceDetailList",
       "/api/public-data/supportConditionsList",
       "/api/public-data/serviceList"

src/main/java/com/hyetaekon/hyetaekon/common/config/redis/SearchHistoryConfig.java

@@ -0,0 +1,24 @@
+package com.hyetaekon.hyetaekon.common.config.redis;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.data.redis.repository.configuration.EnableRedisRepositories;
+import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
+import org.springframework.data.redis.serializer.StringRedisSerializer;
+
+@Configuration
+@EnableRedisRepositories(basePackages = "com.hyetaekon.hyetaekon.publicservice.repository.redis")
+public class SearchHistoryConfig {
+
+    @Bean
+    public RedisTemplate<String, Object> searchHistoryRedisTemplate(RedisTemplate<String, Object> redisTemplate) {
+        // 키와 값의 직렬화 방식 지정
+        redisTemplate.setKeySerializer(new StringRedisSerializer());
+        redisTemplate.setValueSerializer(new Jackson2JsonRedisSerializer<>(Object.class));
+        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
+        redisTemplate.setHashValueSerializer(new Jackson2JsonRedisSerializer<>(Object.class));
+
+        return redisTemplate;
+    }
+}

src/main/java/com/hyetaekon/hyetaekon/common/converter/ServiceCategoryConverter.java

@@ -6,7 +6,9 @@
 import com.hyetaekon.hyetaekon.publicservice.entity.ServiceCategory;
 import jakarta.persistence.AttributeConverter;
 import jakarta.persistence.Converter;
+import lombok.extern.slf4j.Slf4j;
 
+@Slf4j
 @Converter(autoApply = true) // autoApply를 true로 설정하면 @Convert없이 해당 타입에 대해 자동으로 변환
 public class ServiceCategoryConverter implements AttributeConverter<ServiceCategory, String> {
 
@@ -17,12 +19,20 @@ public String convertToDatabaseColumn(ServiceCategory serviceCategory) {
 
     @Override
     public ServiceCategory convertToEntityAttribute(String dbData) {
+        if (dbData == null) {
+            return null;
+        }
+
         for (ServiceCategory serviceCategory : ServiceCategory.values()) {
             if (serviceCategory.getType().equals(dbData)) {
                 return serviceCategory;
             }
         }
-        throw new GlobalException(ErrorCode.SERVICE_CATEGORY_NOT_FOUND);
+        // throw new GlobalException(ErrorCode.SERVICE_CATEGORY_NOT_FOUND);
+
+        // 일치하는 카테고리가 없을 경우 로그를 남기고 기본값 반환
+        log.warn("Unknown service category found: '{}'. Using 'OTHER' category instead.", dbData);
+        return ServiceCategory.OTHER;
     }
 
 }

src/main/java/com/hyetaekon/hyetaekon/common/exception/ErrorCode.java

@@ -16,8 +16,12 @@ public enum ErrorCode {
     INVALID_CREDENTIALS(HttpStatus.UNAUTHORIZED, "AUTH-006", "유효하지 않은 사용자 이름 또는 비밀번호입니다."),
     INVALID_SECRET_KEY(HttpStatus.UNAUTHORIZED, "AUTH-007", "유효하지 않은 비밀 키입니다."),
     DELETE_USER_DENIED(HttpStatus.FORBIDDEN, "AUTH-008", "회원 탈퇴가 거부되었습니다."),
-    ROLE_NOT_FOUND(HttpStatus.FORBIDDEN, "AUTH-009", "권한 정보가 없습니다."),
-    BLACKLIST_TOKEN(HttpStatus.UNAUTHORIZED, "AUTH-010", "사용할 수 없는 액세스 토큰입니다."),
+    CANNOT_REPORT_SELF(HttpStatus.BAD_REQUEST, "AUTH-009","자기 자신을 신고할 수 없습니다."),
+    ROLE_NOT_FOUND(HttpStatus.FORBIDDEN, "AUTH-010", "권한 정보가 없습니다."),
+    BLACKLIST_TOKEN(HttpStatus.UNAUTHORIZED, "AUTH-011", "사용할 수 없는 액세스 토큰입니다."),
+    REPORT_NOT_FOUND(HttpStatus.NOT_FOUND, "AUTH-012", "해당 신고 내역을 찾을 수 없습니다."),
+    REPORT_ALREADY_PROCESSED(HttpStatus.BAD_REQUEST, "AUTH-013", "이미 처리된 신고입니다."),
+    INVALID_REPORT_REQUEST(HttpStatus.BAD_REQUEST, "AUTH-014","잘못된 신고 요청입니다."),
 
     // 계정 관련
     DUPLICATED_REAL_ID(HttpStatus.CONFLICT, "ACCOUNT-001", "이미 존재하는 아이디입니다."),
@@ -40,15 +44,19 @@ public enum ErrorCode {
     // 좋아요
     RECOMMEND_ALREADY_EXISTS(HttpStatus.CONFLICT, "RECOMMEND-001", "이미 좋아요를 누른 게시글입니다."),
     RECOMMEND_NOT_FOUND(HttpStatus.NOT_FOUND, "RECOMMEND-002", "좋아요 정보를 찾을 수 없습니다."),
-    POST_NOT_FOUND(HttpStatus.NOT_FOUND, "POST-001", "해당 게시글을 찾을 수 없습니다."),
+    RECOMMEND_USER_NOT_FOUND(HttpStatus.NOT_FOUND, "RECOMMEND-003", "추천한 유저를 찾을 수 없습니다."),
+
+    // 게시글
+    POST_NOT_FOUND_BY_ID(HttpStatus.NOT_FOUND,"POST-001", "해당 아이디의 게시글을 찾을 수 없습니다"),
 
     // 관심사 선택 제한
     INTEREST_LIMIT_EXCEEDED(HttpStatus.BAD_REQUEST, "INTEREST-001", "관심사는 최대 6개까지만 등록 가능합니다."),
     INVALID_INTEREST(HttpStatus.BAD_REQUEST, "INTEREST-002", "유효하지 않은 관심사입니다."),
 
     // 공공서비스
     // 유효 JACODE 확인
-    INVALID_ENUM_CODE(HttpStatus.BAD_REQUEST, "ENUM-001", "유효하지 않은 코드 값입니다."),
+    INVALID_ENUM_CODE(HttpStatus.BAD_REQUEST, "SERVICE-001", "유효하지 않은 코드 값입니다."),
+    INCOMPLETE_SERVICE_DETAIL(HttpStatus.BAD_REQUEST, "SERVICE-002","서비스 상세 정보가 불완전합니다."),
 
     SERVICE_CATEGORY_NOT_FOUND(HttpStatus.NOT_FOUND, "SERVICE-001", "해당 서비스 분야를 찾을 수 없습니다."),
     SERVICE_NOT_FOUND_BY_ID(HttpStatus.NOT_FOUND,"SERVICE-002", "해당 아이디의 서비스를 찾을 수 없습니다"),

src/main/java/com/hyetaekon/hyetaekon/common/publicdata/controller/PublicServiceDataController.java

@@ -41,27 +41,27 @@ public ResponseEntity<String> createAndStoreServiceList() {
   /**
    * 공공서비스 상세정보 전체 동기화 (페이징 처리)
    */
-  @PostMapping("/serviceDetailList")
+  @PostMapping("/serviceDetail")
   public ResponseEntity<String> createAndStoreServiceDetailList() {
     validator.validateAndHandleException(() -> {
       // 전체 상세정보 동기화 (페이징 처리)
-      publicServiceDataService.syncPublicServiceDetailData(SERVICE_DETAIL_LIST);
+      publicServiceDataService.syncPublicServiceDetailData(SERVICE_DETAIL);
       return null;
-    }, SERVICE_DETAIL_LIST);
+    }, SERVICE_DETAIL);
 
     return ResponseEntity.status(HttpStatus.OK).body("공공서비스 상세정보 데이터 동기화 완료");
   }
 
   /**
    * 공공서비스 지원조건 전체 동기화 (페이징 처리)
    */
-  @PostMapping("/supportConditionsList")
+  @PostMapping("/supportConditions")
   public ResponseEntity<String> createAndStoreSupportConditionsList() {
     validator.validateAndHandleException(() -> {
       // 전체 지원조건 동기화 (페이징 처리)
-      publicServiceDataService.syncPublicServiceConditionsData(SERVICE_CONDITIONS_LIST);
+      publicServiceDataService.syncPublicServiceConditionsData(SERVICE_CONDITIONS);
       return null;
-    }, SERVICE_CONDITIONS_LIST);
+    }, SERVICE_CONDITIONS);
 
     return ResponseEntity.status(HttpStatus.OK).body("공공서비스 지원조건 데이터 동기화 완료");
   }
@@ -85,4 +85,18 @@ public ResponseEntity<List<PublicServiceDataDto.Data>> getServiceListByPage(
 
     return ResponseEntity.status(HttpStatus.OK).body(result);
   }
+
+  // 통합 동기화
+  @PostMapping("/sync-all")
+  public ResponseEntity<String> syncAllPublicServiceData() {
+    // 순차적으로 실행
+    createAndStoreServiceList();
+    createAndStoreServiceDetailList();
+    createAndStoreSupportConditionsList();
+
+    // 미사용 데이터 정리
+    publicServiceDataService.cleanupObsoleteServices();
+
+    return ResponseEntity.status(HttpStatus.OK).body("모든 공공서비스 데이터 동기화 완료");
+  }
 }