Merge pull request '코드 컨벤션 적용' (#12) from feat/demo-20251205 into develop

Reviewed-on: https://kamco.gitea.gs.dabeeo.com/dabeeo/kamco-dabeeo-backoffice/pulls/12

src/main/java/com/kamco/cd/kamcoback/changedetection/ChangeDetectionApiController.java

@@ -5,13 +5,12 @@ import com.kamco.cd.kamcoback.changedetection.service.ChangeDetectionService;
 import com.kamco.cd.kamcoback.config.api.ApiResponseDto;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import jakarta.transaction.Transactional;
+import java.util.List;
 import lombok.RequiredArgsConstructor;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;
 
-import java.util.List;
-
 @Tag(name = "변화탐지", description = "변화탐지 API")
 @RequiredArgsConstructor
 @RestController

src/main/java/com/kamco/cd/kamcoback/changedetection/dto/ChangeDetectionDto.java

@@ -2,9 +2,4 @@ package com.kamco.cd.kamcoback.changedetection.dto;
 
 import org.locationtech.jts.geom.Geometry;
 
-public record ChangeDetectionDto(
+public record ChangeDetectionDto(Long id, Geometry polygon, double centroidX, double centroidY) {}
-  Long id,
-  Geometry polygon,
-  double centroidX,
-  double centroidY
-) {}

src/main/java/com/kamco/cd/kamcoback/changedetection/service/ChangeDetectionService.java

@@ -1,13 +1,11 @@
 package com.kamco.cd.kamcoback.changedetection.service;
 
 import com.kamco.cd.kamcoback.changedetection.dto.ChangeDetectionDto;
-import com.kamco.cd.kamcoback.config.api.ApiResponseDto;
 import com.kamco.cd.kamcoback.postgres.core.ChangeDetectionCoreService;
+import java.util.List;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
 
-import java.util.List;
-
 @Service
 @RequiredArgsConstructor
 public class ChangeDetectionService {

src/main/java/com/kamco/cd/kamcoback/geojson/config/GeoJsonMonitorConfig.java

@@ -1,60 +1,40 @@
 package com.kamco.cd.kamcoback.geojson.config;
 
+import jakarta.annotation.PostConstruct;
 import lombok.Getter;
 import lombok.Setter;
 import org.springframework.boot.context.properties.ConfigurationProperties;
 import org.springframework.stereotype.Component;
 
-import jakarta.annotation.PostConstruct;
+/** GeoJSON 파일 모니터링 설정 */
-
-/**
- * GeoJSON 파일 모니터링 설정
- */
 @Component
 @ConfigurationProperties(prefix = "geojson.monitor")
 @Getter
 @Setter
 public class GeoJsonMonitorConfig {
 
-    /**
+  /** 모니터링할 폴더 경로 */
-     * 모니터링할 폴더 경로
-     */
   private String watchDirectory = "~/geojson/upload";
 
-    /**
+  /** 처리 완료 후 파일을 이동할 폴더 경로 */
-     * 처리 완료 후 파일을 이동할 폴더 경로
-     */
   private String processedDirectory = "~/geojson/processed";
 
-    /**
+  /** 처리 실패 파일을 이동할 폴더 경로 */
-     * 처리 실패 파일을 이동할 폴더 경로
-     */
   private String errorDirectory = "~/geojson/error";
 
-    /**
+  /** 파일 모니터링 스케줄 (cron 표현식) 기본값: 매 30초마다 실행 */
-     * 파일 모니터링 스케줄 (cron 표현식)
-     * 기본값: 매 30초마다 실행
-     */
   private String cronExpression = "0/30 * * * * *";
 
-    /**
+  /** 지원하는 압축파일 확장자 */
-     * 지원하는 압축파일 확장자
-     */
   private String[] supportedExtensions = {"zip", "tar", "tar.gz", "tgz"};
 
-    /**
+  /** 처리할 최대 파일 크기 (바이트) */
-     * 처리할 최대 파일 크기 (바이트)
-     */
   private long maxFileSize = 100 * 1024 * 1024; // 100MB
 
-    /**
+  /** 임시 압축해제 폴더 */
-     * 임시 압축해제 폴더
-     */
   private String tempDirectory = "/tmp/geojson_extract";
 
-    /**
+  /** 홈 디렉토리 경로 확장 */
-     * 홈 디렉토리 경로 확장
-     */
   @PostConstruct
   public void expandPaths() {
     watchDirectory = expandPath(watchDirectory);

src/main/java/com/kamco/cd/kamcoback/geojson/controller/GeoJsonDataController.java

@@ -4,20 +4,17 @@ import com.kamco.cd.kamcoback.postgres.entity.MapSheetLearnDataEntity;
 import com.kamco.cd.kamcoback.postgres.entity.MapSheetLearnDataGeomEntity;
 import com.kamco.cd.kamcoback.postgres.repository.MapSheetLearnDataGeomRepository;
 import com.kamco.cd.kamcoback.postgres.repository.MapSheetLearnDataRepository;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.data.domain.PageRequest;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.*;
 
-import java.util.HashMap;
+/** GeoJSON 데이터 조회 및 테스트용 API 컨트롤러 */
-import java.util.List;
-import java.util.Map;
-import java.util.Optional;
-
-/**
- * GeoJSON 데이터 조회 및 테스트용 API 컨트롤러
- */
 @Slf4j
 @RestController
 @RequestMapping("/api/geojson/data")
@@ -27,9 +24,7 @@ public class GeoJsonDataController {
   private final MapSheetLearnDataRepository mapSheetLearnDataRepository;
   private final MapSheetLearnDataGeomRepository mapSheetLearnDataGeomRepository;
 
-    /**
+  /** 학습 데이터 목록 조회 */
-     * 학습 데이터 목록 조회
-     */
   @GetMapping("/learn-data")
   public ResponseEntity<Map<String, Object>> getLearnDataList(
       @RequestParam(defaultValue = "0") int page,
@@ -62,15 +57,12 @@ public class GeoJsonDataController {
     }
   }
 
-    /**
+  /** 특정 학습 데이터 상세 조회 */
-     * 특정 학습 데이터 상세 조회
-     */
   @GetMapping("/learn-data/{id}")
   public ResponseEntity<Map<String, Object>> getLearnDataDetail(@PathVariable Long id) {
     try {
       if (id == null) {
-                return ResponseEntity.badRequest()
+        return ResponseEntity.badRequest().body(Map.of("error", "ID가 필요합니다."));
-                        .body(Map.of("error", "ID가 필요합니다."));
       }
 
       Optional<MapSheetLearnDataEntity> learnDataOpt = mapSheetLearnDataRepository.findById(id);
@@ -80,7 +72,8 @@ public class GeoJsonDataController {
       }
 
       MapSheetLearnDataEntity learnData = learnDataOpt.get();
-            List<MapSheetLearnDataGeomEntity> geometryList = mapSheetLearnDataGeomRepository.findByDataUid(id);
+      List<MapSheetLearnDataGeomEntity> geometryList =
+          mapSheetLearnDataGeomRepository.findByDataUid(id);
 
       Map<String, Object> response = new HashMap<>();
       response.put("learnData", learnData);
@@ -95,9 +88,7 @@ public class GeoJsonDataController {
     }
   }
 
-    /**
+  /** Geometry 데이터 목록 조회 */
-     * Geometry 데이터 목록 조회
-     */
   @GetMapping("/geometry")
   public ResponseEntity<Map<String, Object>> getGeometryDataList(
       @RequestParam(defaultValue = "0") int page,
@@ -130,19 +121,21 @@ public class GeoJsonDataController {
     }
   }
 
-    /**
+  /** 시스템 통계 정보 조회 */
-     * 시스템 통계 정보 조회
-     */
   @GetMapping("/statistics")
   public ResponseEntity<Map<String, Object>> getStatistics() {
     try {
       long totalLearnData = mapSheetLearnDataRepository.count();
       long totalGeometryData = mapSheetLearnDataGeomRepository.count();
 
-            List<MapSheetLearnDataEntity> processedData = mapSheetLearnDataRepository.findByDataState("PROCESSED");
+      List<MapSheetLearnDataEntity> processedData =
-            List<MapSheetLearnDataEntity> pendingAnalysis = mapSheetLearnDataRepository.findByAnalState("PENDING");
+          mapSheetLearnDataRepository.findByDataState("PROCESSED");
-            List<MapSheetLearnDataEntity> completedAnalysis = mapSheetLearnDataRepository.findByAnalState("COMPLETED");
+      List<MapSheetLearnDataEntity> pendingAnalysis =
-            List<MapSheetLearnDataEntity> errorAnalysis = mapSheetLearnDataRepository.findByAnalState("ERROR");
+          mapSheetLearnDataRepository.findByAnalState("PENDING");
+      List<MapSheetLearnDataEntity> completedAnalysis =
+          mapSheetLearnDataRepository.findByAnalState("COMPLETED");
+      List<MapSheetLearnDataEntity> errorAnalysis =
+          mapSheetLearnDataRepository.findByAnalState("ERROR");
 
       Map<String, Object> statistics = new HashMap<>();
       statistics.put("totalLearnData", totalLearnData);
@@ -160,10 +153,8 @@ public class GeoJsonDataController {
         statistics.put("completionRate", 0.0);
       }
 
-            return ResponseEntity.ok(Map.of(
+      return ResponseEntity.ok(
-                    "statistics", statistics,
+          Map.of("statistics", statistics, "timestamp", java.time.Instant.now()));
-                    "timestamp", java.time.Instant.now()
-            ));
     } catch (Exception e) {
       log.error("통계 정보 조회 실패", e);
       return ResponseEntity.internalServerError()
@@ -171,9 +162,7 @@ public class GeoJsonDataController {
     }
   }
 
-    /**
+  /** 데이터 상태별 카운트 조회 */
-     * 데이터 상태별 카운트 조회
-     */
   @GetMapping("/status-counts")
   public ResponseEntity<Map<String, Object>> getStatusCounts() {
     try {
@@ -181,19 +170,25 @@ public class GeoJsonDataController {
       Map<String, Long> analStateCounts = new HashMap<>();
 
       // 데이터 상태별 카운트
-            dataStateCounts.put("PROCESSED", mapSheetLearnDataRepository.findByDataState("PROCESSED").size() + 0L);
+      dataStateCounts.put(
-            dataStateCounts.put("PENDING", mapSheetLearnDataRepository.findByDataStateIsNullOrDataState("PENDING").size() + 0L);
+          "PROCESSED", mapSheetLearnDataRepository.findByDataState("PROCESSED").size() + 0L);
+      dataStateCounts.put(
+          "PENDING",
+          mapSheetLearnDataRepository.findByDataStateIsNullOrDataState("PENDING").size() + 0L);
 
       // 분석 상태별 카운트
-            analStateCounts.put("PENDING", mapSheetLearnDataRepository.findByAnalState("PENDING").size() + 0L);
+      analStateCounts.put(
-            analStateCounts.put("COMPLETED", mapSheetLearnDataRepository.findByAnalState("COMPLETED").size() + 0L);
+          "PENDING", mapSheetLearnDataRepository.findByAnalState("PENDING").size() + 0L);
-            analStateCounts.put("ERROR", mapSheetLearnDataRepository.findByAnalState("ERROR").size() + 0L);
+      analStateCounts.put(
+          "COMPLETED", mapSheetLearnDataRepository.findByAnalState("COMPLETED").size() + 0L);
+      analStateCounts.put(
+          "ERROR", mapSheetLearnDataRepository.findByAnalState("ERROR").size() + 0L);
 
-            return ResponseEntity.ok(Map.of(
+      return ResponseEntity.ok(
+          Map.of(
               "dataStateCounts", dataStateCounts,
               "analStateCounts", analStateCounts,
-                    "timestamp", java.time.Instant.now()
+              "timestamp", java.time.Instant.now()));
-            ));
     } catch (Exception e) {
       log.error("상태별 카운트 조회 실패", e);
       return ResponseEntity.internalServerError()

src/main/java/com/kamco/cd/kamcoback/geojson/controller/GeoJsonMonitorController.java

@@ -2,17 +2,14 @@ package com.kamco.cd.kamcoback.geojson.controller;
 
 import com.kamco.cd.kamcoback.geojson.service.GeoJsonFileMonitorService;
 import com.kamco.cd.kamcoback.geojson.service.GeometryConversionService;
+import java.util.List;
+import java.util.Map;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.*;
 
-import java.util.List;
+/** GeoJSON 파일 모니터링 및 처리 API 컨트롤러 */
-import java.util.Map;
-
-/**
- * GeoJSON 파일 모니터링 및 처리 API 컨트롤러
- */
 @Slf4j
 @RestController
 @RequestMapping("/api/geojson")
@@ -22,17 +19,13 @@ public class GeoJsonMonitorController {
   private final GeoJsonFileMonitorService monitorService;
   private final GeometryConversionService geometryConversionService;
 
-    /**
+  /** 모니터링 상태 조회 */
-     * 모니터링 상태 조회
-     */
   @GetMapping("/monitor/status")
   public Map<String, Object> getMonitorStatus() {
     return monitorService.getMonitorStatus();
   }
 
-    /**
+  /** 시스템 통계 정보 조회 */
-     * 시스템 통계 정보 조회
-     */
   @GetMapping("/monitor/stats")
   public ResponseEntity<Map<String, Object>> getSystemStats() {
     try {
@@ -41,114 +34,101 @@ public class GeoJsonMonitorController {
     } catch (Exception e) {
       log.error("시스템 통계 조회 실패", e);
       return ResponseEntity.internalServerError()
-                    .body(Map.of(
+          .body(Map.of("error", "시스템 통계 조회 실패: " + e.getMessage(), "status", "error"));
-                            "error", "시스템 통계 조회 실패: " + e.getMessage(),
-                            "status", "error"
-                    ));
     }
   }
 
-    /**
+  /** 디렉토리 초기화 (수동 실행) */
-     * 디렉토리 초기화 (수동 실행)
-     */
   @PostMapping("/monitor/init-directories")
   public ResponseEntity<Map<String, Object>> initializeDirectories() {
     try {
       log.info("디렉토리 초기화 수동 실행 요청");
       monitorService.initializeDirectoriesManually();
 
-            return ResponseEntity.ok(Map.of(
+      return ResponseEntity.ok(
+          Map.of(
               "message", "디렉토리 초기화가 완료되었습니다.",
-                    "status", "success"
+              "status", "success"));
-            ));
     } catch (Exception e) {
       log.error("디렉토리 초기화 실패", e);
       return ResponseEntity.internalServerError()
-                    .body(Map.of(
+          .body(Map.of("error", "디렉토리 초기화 실패: " + e.getMessage(), "status", "error"));
-                            "error", "디렉토리 초기화 실패: " + e.getMessage(),
-                            "status", "error"
-                    ));
     }
   }
 
-    /**
+  /** 수동으로 특정 파일 처리 */
-     * 수동으로 특정 파일 처리
-     */
   @PostMapping("/process/file")
   public ResponseEntity<Map<String, Object>> processFileManually(@RequestParam String filePath) {
     try {
       log.info("수동 파일 처리 요청: {}", filePath);
       monitorService.processFileManually(filePath);
 
-            return ResponseEntity.ok(Map.of(
+      return ResponseEntity.ok(
+          Map.of(
               "message", "파일 처리가 완료되었습니다.",
               "filePath", filePath,
-                    "status", "success"
+              "status", "success"));
-            ));
     } catch (Exception e) {
       log.error("수동 파일 처리 실패: {}", filePath, e);
       return ResponseEntity.internalServerError()
-                    .body(Map.of(
+          .body(
-                            "error", "파일 처리 실패: " + e.getMessage(),
+              Map.of(
-                            "filePath", filePath,
+                  "error", "파일 처리 실패: " + e.getMessage(), "filePath", filePath, "status", "error"));
-                            "status", "error"
-                    ));
     }
   }
 
-    /**
+  /** 미처리된 Geometry 데이터 수동 변환 */
-     * 미처리된 Geometry 데이터 수동 변환
-     */
   @PostMapping("/process/geometry")
   public ResponseEntity<Map<String, Object>> processUnprocessedGeometry() {
     try {
       log.info("미처리 Geometry 변환 수동 실행 요청");
       List<Long> processedIds = geometryConversionService.processUnprocessedLearnData();
 
-            return ResponseEntity.ok(Map.of(
+      return ResponseEntity.ok(
-                    "message", "Geometry 변환이 완료되었습니다.",
+          Map.of(
-                    "processedCount", processedIds.size(),
+              "message",
-                    "processedIds", processedIds,
+              "Geometry 변환이 완료되었습니다.",
-                    "status", "success"
+              "processedCount",
-            ));
+              processedIds.size(),
+              "processedIds",
+              processedIds,
+              "status",
+              "success"));
     } catch (Exception e) {
       log.error("Geometry 변환 실패", e);
       return ResponseEntity.internalServerError()
-                    .body(Map.of(
+          .body(Map.of("error", "Geometry 변환 실패: " + e.getMessage(), "status", "error"));
-                            "error", "Geometry 변환 실패: " + e.getMessage(),
-                            "status", "error"
-                    ));
     }
   }
 
-    /**
+  /** 특정 학습 데이터의 Geometry 변환 */
-     * 특정 학습 데이터의 Geometry 변환
-     */
   @PostMapping("/process/geometry/convert")
-    public ResponseEntity<Map<String, Object>> convertSpecificGeometry(@RequestBody List<Long> learnDataIds) {
+  public ResponseEntity<Map<String, Object>> convertSpecificGeometry(
+      @RequestBody List<Long> learnDataIds) {
     try {
       if (learnDataIds == null || learnDataIds.isEmpty()) {
-                return ResponseEntity.badRequest()
+        return ResponseEntity.badRequest().body(Map.of("error", "변환할 학습 데이터 ID가 없습니다."));
-                        .body(Map.of("error", "변환할 학습 데이터 ID가 없습니다."));
       }
 
       log.info("특정 학습 데이터 Geometry 변환 요청: {}", learnDataIds);
       List<Long> geometryIds = geometryConversionService.convertToGeometryData(learnDataIds);
 
-            return ResponseEntity.ok(Map.of(
+      return ResponseEntity.ok(
-                    "message", "Geometry 변환이 완료되었습니다.",
+          Map.of(
-                    "inputCount", learnDataIds.size(),
+              "message",
-                    "outputCount", geometryIds.size(),
+              "Geometry 변환이 완료되었습니다.",
-                    "geometryIds", geometryIds,
+              "inputCount",
-                    "status", "success"
+              learnDataIds.size(),
-            ));
+              "outputCount",
+              geometryIds.size(),
+              "geometryIds",
+              geometryIds,
+              "status",
+              "success"));
     } catch (Exception e) {
       log.error("특정 Geometry 변환 실패: {}", learnDataIds, e);
       return ResponseEntity.internalServerError()
-                    .body(Map.of(
+          .body(Map.of("error", "Geometry 변환 실패: " + e.getMessage(), "status", "error"));
-                            "error", "Geometry 변환 실패: " + e.getMessage(),
-                            "status", "error"
-                    ));
     }
   }
 }

src/main/java/com/kamco/cd/kamcoback/geojson/service/ArchiveExtractorService.java

@@ -1,6 +1,9 @@
 package com.kamco.cd.kamcoback.geojson.service;
 
 import com.kamco.cd.kamcoback.geojson.config.GeoJsonMonitorConfig;
+import java.io.*;
+import java.nio.file.*;
+import java.util.*;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.compress.archivers.ArchiveEntry;
@@ -10,15 +13,7 @@ import org.apache.commons.compress.archivers.zip.ZipFile;
 import org.apache.commons.compress.compressors.gzip.GzipCompressorInputStream;
 import org.springframework.stereotype.Service;
 
-import java.io.*;
+/** 압축파일 처리 서비스 */
-import java.nio.file.*;
-import java.util.*;
-import java.util.stream.Stream;
-import java.util.zip.ZipInputStream;
-
-/**
- * 압축파일 처리 서비스
- */
 @Slf4j
 @Service
 @RequiredArgsConstructor
@@ -26,9 +21,7 @@ public class ArchiveExtractorService {
 
   private final GeoJsonMonitorConfig config;
 
-    /**
+  /** 압축파일에서 GeoJSON 파일들을 추출 */
-     * 압축파일에서 GeoJSON 파일들을 추출
-     */
   public Map<String, String> extractGeoJsonFiles(Path archiveFile) throws IOException {
     Map<String, String> geoJsonContents = new HashMap<>();
     String fileName = archiveFile.getFileName().toString().toLowerCase();
@@ -38,7 +31,9 @@ public class ArchiveExtractorService {
     try {
       if (fileName.endsWith(".zip")) {
         extractFromZip(archiveFile, geoJsonContents);
-            } else if (fileName.endsWith(".tar") || fileName.endsWith(".tar.gz") || fileName.endsWith(".tgz")) {
+      } else if (fileName.endsWith(".tar")
+          || fileName.endsWith(".tar.gz")
+          || fileName.endsWith(".tgz")) {
         extractFromTar(archiveFile, geoJsonContents);
       } else {
         throw new IllegalArgumentException("지원하지 않는 압축파일 형식: " + fileName);
@@ -52,10 +47,9 @@ public class ArchiveExtractorService {
     return geoJsonContents;
   }
 
-    /**
+  /** ZIP 파일에서 GeoJSON 추출 */
-     * ZIP 파일에서 GeoJSON 추출
+  private void extractFromZip(Path zipFile, Map<String, String> geoJsonContents)
-     */
+      throws IOException {
-    private void extractFromZip(Path zipFile, Map<String, String> geoJsonContents) throws IOException {
     try (ZipFile zip = new ZipFile(zipFile.toFile())) {
       Enumeration<ZipArchiveEntry> entries = zip.getEntries();
 
@@ -73,10 +67,9 @@ public class ArchiveExtractorService {
     }
   }
 
-    /**
+  /** TAR 파일에서 GeoJSON 추출 */
-     * TAR 파일에서 GeoJSON 추출
+  private void extractFromTar(Path tarFile, Map<String, String> geoJsonContents)
-     */
+      throws IOException {
-    private void extractFromTar(Path tarFile, Map<String, String> geoJsonContents) throws IOException {
     String fileName = tarFile.getFileName().toString().toLowerCase();
     InputStream fileInputStream = Files.newInputStream(tarFile);
 
@@ -106,9 +99,7 @@ public class ArchiveExtractorService {
     }
   }
 
-    /**
+  /** InputStream에서 문자열 읽기 */
-     * InputStream에서 문자열 읽기
-     */
   private String readInputStream(InputStream inputStream) throws IOException {
     try (BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream, "UTF-8"))) {
       StringBuilder content = new StringBuilder();
@@ -122,17 +113,13 @@ public class ArchiveExtractorService {
     }
   }
 
-    /**
+  /** 파일이 GeoJSON 파일인지 확인 */
-     * 파일이 GeoJSON 파일인지 확인
-     */
   private boolean isGeoJsonFile(String fileName) {
     String lowerFileName = fileName.toLowerCase();
     return lowerFileName.endsWith(".geojson") || lowerFileName.endsWith(".json");
   }
 
-    /**
+  /** 지원하는 압축파일인지 확인 */
-     * 지원하는 압축파일인지 확인
-     */
   public boolean isSupportedArchive(Path file) {
     String fileName = file.getFileName().toString().toLowerCase();
 
@@ -145,17 +132,18 @@ public class ArchiveExtractorService {
     return false;
   }
 
-    /**
+  /** 파일 크기가 제한 범위 내인지 확인 */
-     * 파일 크기가 제한 범위 내인지 확인
-     */
   public boolean isFileSizeValid(Path file) {
     try {
       long fileSize = Files.size(file);
       boolean isValid = fileSize <= config.getMaxFileSize();
 
       if (!isValid) {
-                log.warn("파일 크기가 제한을 초과했습니다: {} ({}MB > {}MB)", 
+        log.warn(
-                    file, fileSize / 1024 / 1024, config.getMaxFileSize() / 1024 / 1024);
+            "파일 크기가 제한을 초과했습니다: {} ({}MB > {}MB)",
+            file,
+            fileSize / 1024 / 1024,
+            config.getMaxFileSize() / 1024 / 1024);
       }
 
       return isValid;

src/main/java/com/kamco/cd/kamcoback/geojson/service/GeoJsonDataService.java

@@ -5,17 +5,13 @@ import com.fasterxml.jackson.databind.ObjectMapper;
 import com.kamco.cd.kamcoback.postgres.entity.MapSheetLearnDataEntity;
 import com.kamco.cd.kamcoback.postgres.repository.MapSheetLearnDataRepository;
 import java.time.ZonedDateTime;
+import java.util.*;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
-import java.time.Instant;
+/** GeoJSON 데이터 처리 서비스 */
-import java.util.*;
-
-/**
- * GeoJSON 데이터 처리 서비스
- */
 @Slf4j
 @Service
 @RequiredArgsConstructor
@@ -24,11 +20,10 @@ public class GeoJsonDataService {
   private final MapSheetLearnDataRepository mapSheetLearnDataRepository;
   private final ObjectMapper objectMapper;
 
-    /**
+  /** GeoJSON 파일들을 데이터베이스에 저장 */
-     * GeoJSON 파일들을 데이터베이스에 저장
-     */
   @Transactional
-    public List<Long> processGeoJsonFiles(Map<String, String> geoJsonContents, String archiveFileName) {
+  public List<Long> processGeoJsonFiles(
+      Map<String, String> geoJsonContents, String archiveFileName) {
     List<Long> savedIds = new ArrayList<>();
 
     log.info("GeoJSON 파일 처리 시작: {} ({}개 파일)", archiveFileName, geoJsonContents.size());
@@ -49,15 +44,16 @@ public class GeoJsonDataService {
       }
     }
 
-        log.info("GeoJSON 파일 처리 완료: {} (성공: {}개, 전체: {}개)",
+    log.info(
-                archiveFileName, savedIds.size(), geoJsonContents.size());
+        "GeoJSON 파일 처리 완료: {} (성공: {}개, 전체: {}개)",
+        archiveFileName,
+        savedIds.size(),
+        geoJsonContents.size());
 
     return savedIds;
   }
 
-    /**
+  /** 개별 GeoJSON 파일을 MapSheetLearnDataEntity로 변환하여 저장 */
-     * 개별 GeoJSON 파일을 MapSheetLearnDataEntity로 변환하여 저장
-     */
   private Long processGeoJsonFile(String fileName, String geoJsonContent, String archiveFileName) {
     try {
       // GeoJSON 파싱 및 검증
@@ -66,7 +62,8 @@ public class GeoJsonDataService {
 
       // 파일이 이미 처리되었는지 확인
       String dataPath = generateDataPath(archiveFileName, fileName);
-            Optional<MapSheetLearnDataEntity> existingData = mapSheetLearnDataRepository.findByDataPath(dataPath);
+      Optional<MapSheetLearnDataEntity> existingData =
+          mapSheetLearnDataRepository.findByDataPath(dataPath);
 
       if (existingData.isPresent()) {
         log.warn("이미 처리된 파일입니다: {}", dataPath);
@@ -74,7 +71,8 @@ public class GeoJsonDataService {
       }
 
       // 새 엔티티 생성 및 저장
-            MapSheetLearnDataEntity entity = createMapSheetLearnDataEntity(fileName, geoJsonContent, archiveFileName, geoJsonNode);
+      MapSheetLearnDataEntity entity =
+          createMapSheetLearnDataEntity(fileName, geoJsonContent, archiveFileName, geoJsonNode);
       MapSheetLearnDataEntity savedEntity = mapSheetLearnDataRepository.save(entity);
 
       return savedEntity.getId();
@@ -85,9 +83,7 @@ public class GeoJsonDataService {
     }
   }
 
-    /**
+  /** GeoJSON 구조 검증 */
-     * GeoJSON 구조 검증
-     */
   private void validateGeoJsonStructure(JsonNode geoJsonNode) {
     if (!geoJsonNode.has("type")) {
       throw new IllegalArgumentException("유효하지 않은 GeoJSON: 'type' 필드가 없습니다.");
@@ -99,9 +95,7 @@ public class GeoJsonDataService {
     }
   }
 
-    /**
+  /** MapSheetLearnDataEntity 생성 */
-     * MapSheetLearnDataEntity 생성
-     */
   private MapSheetLearnDataEntity createMapSheetLearnDataEntity(
       String fileName, String geoJsonContent, String archiveFileName, JsonNode geoJsonNode) {
 
@@ -146,9 +140,7 @@ public class GeoJsonDataService {
     return entity;
   }
 
-    /**
+  /** CRS 정보 설정 */
-     * CRS 정보 설정
-     */
   private void setCrsInformation(MapSheetLearnDataEntity entity, JsonNode geoJsonNode) {
     if (geoJsonNode.has("crs")) {
       JsonNode crsNode = geoJsonNode.get("crs");
@@ -169,9 +161,7 @@ public class GeoJsonDataService {
     }
   }
 
-    /**
+  /** 연도 정보 추출 */
-     * 연도 정보 추출
-     */
   private void setYearInformation(MapSheetLearnDataEntity entity, String fileName) {
     // 파일명에서 연도 추출 시도 (예: kamco_2021_2022_35813023.geojson)
     String[] parts = fileName.split("_");
@@ -194,9 +184,7 @@ public class GeoJsonDataService {
     }
   }
 
-    /**
+  /** 제목 추출 */
-     * 제목 추출
-     */
   private String extractTitle(String fileName, JsonNode geoJsonNode) {
     // GeoJSON 메타데이터에서 제목 추출 시도
     if (geoJsonNode.has("properties")) {
@@ -218,16 +206,12 @@ public class GeoJsonDataService {
     return fileName;
   }
 
-    /**
+  /** 데이터 경로 생성 */
-     * 데이터 경로 생성
-     */
   private String generateDataPath(String archiveFileName, String fileName) {
     return archiveFileName + "/" + fileName;
   }
 
-    /**
+  /** 처리 가능한 파일 개수 확인 */
-     * 처리 가능한 파일 개수 확인
-     */
   public boolean isProcessable(Map<String, String> geoJsonContents) {
     if (geoJsonContents == null || geoJsonContents.isEmpty()) {
       return false;

src/main/java/com/kamco/cd/kamcoback/geojson/service/GeoJsonFileMonitorService.java

@@ -1,25 +1,20 @@
 package com.kamco.cd.kamcoback.geojson.service;
 
 import com.kamco.cd.kamcoback.geojson.config.GeoJsonMonitorConfig;
-import com.kamco.cd.kamcoback.postgres.repository.MapSheetLearnDataRepository;
 import com.kamco.cd.kamcoback.postgres.repository.MapSheetLearnDataGeomRepository;
-import lombok.RequiredArgsConstructor;
+import com.kamco.cd.kamcoback.postgres.repository.MapSheetLearnDataRepository;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.scheduling.annotation.Scheduled;
-import org.springframework.stereotype.Service;
 import jakarta.annotation.PostConstruct;
-
 import java.io.IOException;
 import java.nio.file.*;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.stream.Stream;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
 
-/**
+/** GeoJSON 파일 모니터링 서비스 지정된 폴더를 주기적으로 모니터링하여 압축파일을 자동으로 처리합니다. */
- * GeoJSON 파일 모니터링 서비스
- * 지정된 폴더를 주기적으로 모니터링하여 압축파일을 자동으로 처리합니다.
- */
 @Slf4j
 @Service
 @RequiredArgsConstructor
@@ -32,16 +27,17 @@ public class GeoJsonFileMonitorService {
   private final MapSheetLearnDataRepository learnDataRepository;
   private final MapSheetLearnDataGeomRepository geomRepository;
 
-    /**
+  /** 애플리케이션 시작 시 필요한 디렉토리들을 미리 생성 */
-     * 애플리케이션 시작 시 필요한 디렉토리들을 미리 생성
-     */
   @PostConstruct
   public void initializeDirectories() {
     try {
       log.info("GeoJSON 모니터링 시스템 초기화 중...");
-            log.info("설정된 경로 - Watch: {}, Processed: {}, Error: {}, Temp: {}",
+      log.info(
-                config.getWatchDirectory(), config.getProcessedDirectory(),
+          "설정된 경로 - Watch: {}, Processed: {}, Error: {}, Temp: {}",
-                config.getErrorDirectory(), config.getTempDirectory());
+          config.getWatchDirectory(),
+          config.getProcessedDirectory(),
+          config.getErrorDirectory(),
+          config.getTempDirectory());
 
       ensureDirectoriesExist();
       log.info("GeoJSON 모니터링 시스템 초기화 완료");
@@ -51,10 +47,7 @@ public class GeoJsonFileMonitorService {
     }
   }
 
-    /**
+  /** 스케줄러를 통한 파일 모니터링 설정된 cron 표현식에 따라 주기적으로 실행 */
-     * 스케줄러를 통한 파일 모니터링
-     * 설정된 cron 표현식에 따라 주기적으로 실행
-     */
   //    @Scheduled(cron = "#{@geoJsonMonitorConfig.cronExpression}")
   public void monitorFiles() {
     log.debug("파일 모니터링 시작");
@@ -78,9 +71,7 @@ public class GeoJsonFileMonitorService {
     log.debug("파일 모니터링 완료");
   }
 
-    /**
+  /** 필요한 디렉토리들이 존재하는지 확인하고 생성 */
-     * 필요한 디렉토리들이 존재하는지 확인하고 생성
-     */
   private void ensureDirectoriesExist() {
     boolean hasError = false;
     try {
@@ -123,9 +114,7 @@ public class GeoJsonFileMonitorService {
     }
   }
 
-    /**
+  /** 디렉토리가 존재하지 않으면 생성 */
-     * 디렉토리가 존재하지 않으면 생성
-     */
   private void createDirectoryIfNotExists(String directory) throws IOException {
     if (directory == null || directory.trim().isEmpty()) {
       throw new IllegalArgumentException("디렉토리 경로가 비어있습니다.");
@@ -143,8 +132,7 @@ public class GeoJsonFileMonitorService {
           if (!System.getProperty("os.name").toLowerCase().contains("windows")) {
             // rwxrwxr-x 권한 설정
             java.nio.file.attribute.PosixFilePermissions.asFileAttribute(
-                            java.nio.file.attribute.PosixFilePermissions.fromString("rwxrwxr-x")
+                java.nio.file.attribute.PosixFilePermissions.fromString("rwxrwxr-x"));
-                        );
           }
         } catch (Exception permissionException) {
           log.debug("권한 설정 실패 (무시됨): {}", permissionException.getMessage());
@@ -163,9 +151,7 @@ public class GeoJsonFileMonitorService {
     }
   }
 
-    /**
+  /** 모니터링 폴더에서 압축파일들을 찾아서 처리 */
-     * 모니터링 폴더에서 압축파일들을 찾아서 처리
-     */
   private void processArchiveFiles() {
     Path watchDir = Paths.get(config.getWatchDirectory());
 
@@ -186,7 +172,8 @@ public class GeoJsonFileMonitorService {
     }
 
     try (Stream<Path> files = Files.list(watchDir)) {
-            files.filter(Files::isRegularFile)
+      files
+          .filter(Files::isRegularFile)
           .filter(archiveExtractorService::isSupportedArchive)
           .filter(archiveExtractorService::isFileSizeValid)
           .forEach(this::processArchiveFile);
@@ -196,16 +183,15 @@ public class GeoJsonFileMonitorService {
     }
   }
 
-    /**
+  /** 개별 압축파일 처리 */
-     * 개별 압축파일 처리
-     */
   private void processArchiveFile(Path archiveFile) {
     String fileName = archiveFile.getFileName().toString();
     log.info("압축파일 처리 시작: {}", fileName);
 
     try {
       // 1. 압축파일에서 GeoJSON 파일들 추출
-            Map<String, String> geoJsonContents = archiveExtractorService.extractGeoJsonFiles(archiveFile);
+      Map<String, String> geoJsonContents =
+          archiveExtractorService.extractGeoJsonFiles(archiveFile);
 
       if (geoJsonContents.isEmpty()) {
         log.warn("압축파일에서 GeoJSON 파일을 찾을 수 없습니다: {}", fileName);
@@ -221,7 +207,8 @@ public class GeoJsonFileMonitorService {
       }
 
       // 3. GeoJSON 데이터를 데이터베이스에 저장
-            List<Long> savedLearnDataIds = geoJsonDataService.processGeoJsonFiles(geoJsonContents, fileName);
+      List<Long> savedLearnDataIds =
+          geoJsonDataService.processGeoJsonFiles(geoJsonContents, fileName);
 
       if (savedLearnDataIds.isEmpty()) {
         log.warn("저장된 학습 데이터가 없습니다: {}", fileName);
@@ -235,8 +222,11 @@ public class GeoJsonFileMonitorService {
       // 5. 처리 완료된 파일을 처리된 폴더로 이동
       moveFileToProcessed(archiveFile);
 
-            log.info("압축파일 처리 완료: {} (학습 데이터: {}개, Geometry: {}개)",
+      log.info(
-                    fileName, savedLearnDataIds.size(), geometryIds.size());
+          "압축파일 처리 완료: {} (학습 데이터: {}개, Geometry: {}개)",
+          fileName,
+          savedLearnDataIds.size(),
+          geometryIds.size());
 
     } catch (Exception e) {
       log.error("압축파일 처리 실패: {}", fileName, e);
@@ -248,9 +238,7 @@ public class GeoJsonFileMonitorService {
     }
   }
 
-    /**
+  /** 미처리된 Geometry 변환 작업 수행 */
-     * 미처리된 Geometry 변환 작업 수행
-     */
   private void processUnprocessedGeometryData() {
     try {
       List<Long> processedIds = geometryConversionService.processUnprocessedLearnData();
@@ -262,9 +250,7 @@ public class GeoJsonFileMonitorService {
     }
   }
 
-    /**
+  /** 처리 완료된 파일을 processed 폴더로 이동 */
-     * 처리 완료된 파일을 processed 폴더로 이동
-     */
   private void moveFileToProcessed(Path sourceFile) throws IOException {
     String fileName = sourceFile.getFileName().toString();
     String timestampedFileName = addTimestamp(fileName);
@@ -274,9 +260,7 @@ public class GeoJsonFileMonitorService {
     log.info("파일을 처리된 폴더로 이동: {} -> {}", fileName, timestampedFileName);
   }
 
-    /**
+  /** 오류가 발생한 파일을 error 폴더로 이동 */
-     * 오류가 발생한 파일을 error 폴더로 이동
-     */
   private void moveFileToError(Path sourceFile, String errorReason) throws IOException {
     String fileName = sourceFile.getFileName().toString();
     String errorFileName = addTimestamp(fileName) + ".error";
@@ -287,16 +271,15 @@ public class GeoJsonFileMonitorService {
     // 오류 정보를 별도 파일로 저장
     String errorInfoFileName = errorFileName + ".info";
     Path errorInfoPath = Paths.get(config.getErrorDirectory(), errorInfoFileName);
-        String errorInfo = String.format("파일: %s%n오류 시간: %s%n오류 원인: %s%n",
+    String errorInfo =
-                fileName, java.time.Instant.now(), errorReason);
+        String.format(
+            "파일: %s%n오류 시간: %s%n오류 원인: %s%n", fileName, java.time.Instant.now(), errorReason);
     Files.write(errorInfoPath, errorInfo.getBytes());
 
     log.warn("파일을 오류 폴더로 이동: {} (원인: {})", fileName, errorReason);
   }
 
-    /**
+  /** 파일명에 타임스탬프 추가 */
-     * 파일명에 타임스탬프 추가
-     */
   private String addTimestamp(String fileName) {
     int lastDotIndex = fileName.lastIndexOf('.');
     String name = (lastDotIndex > 0) ? fileName.substring(0, lastDotIndex) : fileName;
@@ -305,9 +288,7 @@ public class GeoJsonFileMonitorService {
     return String.format("%s_%d%s", name, System.currentTimeMillis(), extension);
   }
 
-    /**
+  /** 수동으로 특정 파일 처리 (테스트/관리 목적) */
-     * 수동으로 특정 파일 처리 (테스트/관리 목적)
-     */
   public void processFileManually(String filePath) {
     Path archiveFile = Paths.get(filePath);
 
@@ -325,9 +306,7 @@ public class GeoJsonFileMonitorService {
     processArchiveFile(archiveFile);
   }
 
-    /**
+  /** 디렉토리 초기화를 수동으로 실행 (API에서 호출 가능) */
-     * 디렉토리 초기화를 수동으로 실행 (API에서 호출 가능)
-     */
   public void initializeDirectoriesManually() {
     log.info("디렉토리 수동 초기화 시작");
     try {
@@ -339,9 +318,7 @@ public class GeoJsonFileMonitorService {
     }
   }
 
-    /**
+  /** 모니터링 상태 정보 반환 */
-     * 모니터링 상태 정보 반환
-     */
   public Map<String, Object> getMonitorStatus() {
     return Map.of(
         "watchDirectory", config.getWatchDirectory(),
@@ -350,13 +327,10 @@ public class GeoJsonFileMonitorService {
         "cronExpression", config.getCronExpression(),
         "supportedExtensions", config.getSupportedExtensions(),
         "maxFileSize", config.getMaxFileSize(),
-                "maxFileSizeMB", config.getMaxFileSize() / 1024 / 1024
+        "maxFileSizeMB", config.getMaxFileSize() / 1024 / 1024);
-        );
   }
 
-    /**
+  /** 시스템 통계 정보 조회 */
-     * 시스템 통계 정보 조회
-     */
   public Map<String, Object> getSystemStats() {
     Map<String, Object> stats = new HashMap<>();
 
@@ -366,23 +340,25 @@ public class GeoJsonFileMonitorService {
       long totalGeomData = geomRepository.count();
       long pendingAnalysis = learnDataRepository.countByAnalState("PENDING");
 
-            stats.put("database", Map.of(
+      stats.put(
+          "database",
+          Map.of(
               "totalLearnData", totalLearnData,
               "totalGeomData", totalGeomData,
-                "pendingAnalysis", pendingAnalysis
+              "pendingAnalysis", pendingAnalysis));
-            ));
 
       // 파일 시스템 통계
       stats.put("fileSystem", getFileSystemStats());
 
       // 모니터링 설정
-            stats.put("monitoring", Map.of(
+      stats.put(
+          "monitoring",
+          Map.of(
               "isActive", true,
               "cronExpression", "0/30 * * * * *",
               "watchDirectory", config.getWatchDirectory(),
               "processedDirectory", config.getProcessedDirectory(),
-                "errorDirectory", config.getErrorDirectory()
+              "errorDirectory", config.getErrorDirectory()));
-            ));
 
     } catch (Exception e) {
       log.error("통계 정보 조회 실패", e);
@@ -392,9 +368,7 @@ public class GeoJsonFileMonitorService {
     return stats;
   }
 
-    /**
+  /** 파일 시스템 통계 조회 */
-     * 파일 시스템 통계 조회
-     */
   private Map<String, Object> getFileSystemStats() {
     Map<String, Object> fileStats = new HashMap<>();
 
@@ -416,9 +390,7 @@ public class GeoJsonFileMonitorService {
     return fileStats;
   }
 
-    /**
+  /** 디렉토리 내 파일 개수 계산 */
-     * 디렉토리 내 파일 개수 계산
-     */
   private long countFilesInDirectory(Path directory) {
     if (!Files.exists(directory) || !Files.isDirectory(directory)) {
       return 0;

src/main/java/com/kamco/cd/kamcoback/geojson/service/GeometryConversionService.java

@@ -7,18 +7,14 @@ import com.kamco.cd.kamcoback.postgres.entity.MapSheetLearnDataGeomEntity;
 import com.kamco.cd.kamcoback.postgres.repository.MapSheetLearnDataGeomRepository;
 import com.kamco.cd.kamcoback.postgres.repository.MapSheetLearnDataRepository;
 import java.time.ZonedDateTime;
+import java.util.*;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.locationtech.jts.geom.*;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
-import java.time.Instant;
+/** Geometry 데이터 변환 서비스 */
-import java.util.*;
-
-/**
- * Geometry 데이터 변환 서비스
- */
 @Slf4j
 @Service
 @RequiredArgsConstructor
@@ -29,9 +25,7 @@ public class GeometryConversionService {
   private final ObjectMapper objectMapper;
   private final GeometryFactory geometryFactory = new GeometryFactory();
 
-    /**
+  /** MapSheetLearnData의 JSON 데이터를 기반으로 Geometry 테이블에 저장 */
-     * MapSheetLearnData의 JSON 데이터를 기반으로 Geometry 테이블에 저장
-     */
   @Transactional
   public List<Long> convertToGeometryData(List<Long> learnDataIds) {
     List<Long> processedIds = new ArrayList<>();
@@ -41,7 +35,8 @@ public class GeometryConversionService {
     for (Long dataId : learnDataIds) {
       try {
         if (dataId != null) {
-                    Optional<MapSheetLearnDataEntity> learnDataOpt = mapSheetLearnDataRepository.findById(dataId);
+          Optional<MapSheetLearnDataEntity> learnDataOpt =
+              mapSheetLearnDataRepository.findById(dataId);
           if (learnDataOpt.isPresent()) {
             List<Long> geometryIds = processLearnDataToGeometry(learnDataOpt.get());
             processedIds.addAll(geometryIds);
@@ -56,13 +51,12 @@ public class GeometryConversionService {
       }
     }
 
-        log.info("Geometry 변환 완료: {} 개 처리, {} 개의 geometry 생성", learnDataIds.size(), processedIds.size());
+    log.info(
+        "Geometry 변환 완료: {} 개 처리, {} 개의 geometry 생성", learnDataIds.size(), processedIds.size());
     return processedIds;
   }
 
-    /**
+  /** 개별 학습 데이터를 Geometry 데이터로 변환 */
-     * 개별 학습 데이터를 Geometry 데이터로 변환
-     */
   private List<Long> processLearnDataToGeometry(MapSheetLearnDataEntity learnData) {
     List<Long> geometryIds = new ArrayList<>();
 
@@ -116,10 +110,9 @@ public class GeometryConversionService {
     return geometryIds;
   }
 
-    /**
+  /** FeatureCollection 처리 */
-     * FeatureCollection 처리
+  private List<Long> processFeatureCollection(
-     */
+      JsonNode featureCollectionNode, MapSheetLearnDataEntity learnData) {
-    private List<Long> processFeatureCollection(JsonNode featureCollectionNode, MapSheetLearnDataEntity learnData) {
     List<Long> geometryIds = new ArrayList<>();
 
     if (!featureCollectionNode.has("features")) {
@@ -144,9 +137,7 @@ public class GeometryConversionService {
     return geometryIds;
   }
 
-    /**
+  /** Feature 처리 */
-     * Feature 처리
-     */
   private Long processFeature(JsonNode featureNode, MapSheetLearnDataEntity learnData) {
     try {
       if (!featureNode.has("geometry")) {
@@ -155,7 +146,8 @@ public class GeometryConversionService {
       }
 
       JsonNode geometryNode = featureNode.get("geometry");
-            JsonNode propertiesNode = featureNode.has("properties") ? featureNode.get("properties") : null;
+      JsonNode propertiesNode =
+          featureNode.has("properties") ? featureNode.get("properties") : null;
 
       return createGeometryEntity(geometryNode, propertiesNode, learnData);
 
@@ -165,17 +157,14 @@ public class GeometryConversionService {
     }
   }
 
-    /**
+  /** 직접 Geometry 처리 */
-     * 직접 Geometry 처리
-     */
   private Long processDirectGeometry(JsonNode geometryNode, MapSheetLearnDataEntity learnData) {
     return createGeometryEntity(geometryNode, null, learnData);
   }
 
-    /**
+  /** GeometryEntity 생성 및 저장 */
-     * GeometryEntity 생성 및 저장
+  private Long createGeometryEntity(
-     */
+      JsonNode geometryNode, JsonNode propertiesNode, MapSheetLearnDataEntity learnData) {
-    private Long createGeometryEntity(JsonNode geometryNode, JsonNode propertiesNode, MapSheetLearnDataEntity learnData) {
     try {
       MapSheetLearnDataGeomEntity geometryEntity = new MapSheetLearnDataGeomEntity();
 
@@ -211,7 +200,8 @@ public class GeometryConversionService {
       geometryEntity.setUpdatedDttm(now);
 
       // 저장
-            MapSheetLearnDataGeomEntity savedEntity = mapSheetLearnDataGeomRepository.save(geometryEntity);
+      MapSheetLearnDataGeomEntity savedEntity =
+          mapSheetLearnDataGeomRepository.save(geometryEntity);
       return savedEntity.getId();
 
     } catch (Exception e) {
@@ -220,9 +210,7 @@ public class GeometryConversionService {
     }
   }
 
-    /**
+  /** GeoJSON 노드에서 JTS Geometry 객체 생성 */
-     * GeoJSON 노드에서 JTS Geometry 객체 생성
-     */
   private Geometry parseGeometryFromGeoJson(JsonNode geometryNode) {
     try {
       if (!geometryNode.has("type") || !geometryNode.has("coordinates")) {
@@ -349,10 +337,11 @@ public class GeometryConversionService {
     return geometryFactory.createMultiPolygon(polygons.toArray(new Polygon[0]));
   }
 
-    /**
+  /** Properties에서 추가 정보 추출 */
-     * Properties에서 추가 정보 추출
+  private void extractPropertiesData(
-     */
+      MapSheetLearnDataGeomEntity geometryEntity,
-    private void extractPropertiesData(MapSheetLearnDataGeomEntity geometryEntity, JsonNode propertiesNode, MapSheetLearnDataEntity learnData) {
+      JsonNode propertiesNode,
+      MapSheetLearnDataEntity learnData) {
     // CD 정확도 정보
     if (propertiesNode.has("cd_prob")) {
       try {
@@ -410,13 +399,12 @@ public class GeometryConversionService {
     }
   }
 
-    /**
+  /** 미처리된 학습 데이터들을 찾아서 자동으로 geometry 변환 수행 */
-     * 미처리된 학습 데이터들을 찾아서 자동으로 geometry 변환 수행
-     */
   @Transactional
   public List<Long> processUnprocessedLearnData() {
     // 분석 상태가 PENDING인 학습 데이터 조회
-        List<MapSheetLearnDataEntity> unprocessedData = mapSheetLearnDataRepository.findByAnalState("PENDING");
+    List<MapSheetLearnDataEntity> unprocessedData =
+        mapSheetLearnDataRepository.findByAnalState("PENDING");
 
     if (unprocessedData.isEmpty()) {
       log.debug("처리할 미완료 학습 데이터가 없습니다.");

src/main/java/com/kamco/cd/kamcoback/inference/InferenceResultApiController.java

@@ -4,7 +4,6 @@ import com.kamco.cd.kamcoback.config.api.ApiResponseDto;
 import com.kamco.cd.kamcoback.inference.dto.InferenceResultDto;
 import com.kamco.cd.kamcoback.inference.dto.InferenceResultDto.Dashboard;
 import com.kamco.cd.kamcoback.inference.dto.InferenceResultDto.Detail;
-import com.kamco.cd.kamcoback.inference.dto.InferenceResultDto.SearchReq;
 import com.kamco.cd.kamcoback.inference.service.InferenceResultService;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.Parameter;
@@ -29,10 +28,7 @@ public class InferenceResultApiController {
 
   private final InferenceResultService inferenceResultService;
 
-  @Operation(
+  @Operation(summary = "추론관리 분석결과 목록 조회", description = "분석상태, 제목으로 분석결과를 조회 합니다.")
-    summary = "추론관리 분석결과 목록 조회",
-    description =
-      "분석상태, 제목으로 분석결과를 조회 합니다.")
   @ApiResponses(
       value = {
         @ApiResponse(
@@ -47,8 +43,7 @@ public class InferenceResultApiController {
       })
   @GetMapping("/list")
   public ApiResponseDto<Page<InferenceResultDto.AnalResList>> getInferenceResultList(
-    @Parameter(description = "분석상태", example = "0000")
+      @Parameter(description = "분석상태", example = "0000") @RequestParam(required = false)
-    @RequestParam(required = false)
           String statCode,
       @Parameter(description = "제목", example = "2023_2024년도") @RequestParam(required = false)
           String title,
@@ -58,17 +53,15 @@ public class InferenceResultApiController {
           int size,
       @Parameter(description = "정렬 조건 (형식: 필드명,방향)", example = "name,asc")
           @RequestParam(required = false)
-      String sort
+          String sort) {
-  ) {
+    InferenceResultDto.SearchReq searchReq =
-    InferenceResultDto.SearchReq searchReq = new InferenceResultDto.SearchReq(statCode, title, page, size, sort);
+        new InferenceResultDto.SearchReq(statCode, title, page, size, sort);
-    Page<InferenceResultDto.AnalResList> analResList = inferenceResultService.getInferenceResultList(searchReq);
+    Page<InferenceResultDto.AnalResList> analResList =
+        inferenceResultService.getInferenceResultList(searchReq);
     return ApiResponseDto.ok(analResList);
   }
 
-  @Operation(
+  @Operation(summary = "추론관리 분석결과 요약정보", description = "분석결과 요약정보를 조회합니다.")
-    summary = "추론관리 분석결과 요약정보",
-    description =
-      "분석결과 요약정보를 조회합니다.")
   @ApiResponses(
       value = {
         @ApiResponse(
@@ -83,16 +76,11 @@ public class InferenceResultApiController {
       })
   @GetMapping("/summary")
   public ApiResponseDto<InferenceResultDto.AnalResSummary> getInferenceResultSummary(
-    @Parameter(description = "목록 id", example = "1")
+      @Parameter(description = "목록 id", example = "1") @RequestParam Long id) {
-    @RequestParam Long id) {
     return ApiResponseDto.ok(inferenceResultService.getInferenceResultSummary(id));
   }
 
-
+  @Operation(summary = "추론관리 분석결과 상세", description = "분석결과 상제 정보 Summary, DashBoard")
-  @Operation(
-    summary = "추론관리 분석결과 상세",
-    description =
-      "분석결과 상제 정보 Summary, DashBoard")
   @ApiResponses(
       value = {
         @ApiResponse(
@@ -107,19 +95,16 @@ public class InferenceResultApiController {
       })
   @GetMapping("/detail")
   public ApiResponseDto<InferenceResultDto.Detail> getInferenceDetail(
-    @Parameter(description = "목록 id", example = "1")
+      @Parameter(description = "목록 id", example = "1") @RequestParam Long id) {
-    @RequestParam Long id) {
     // summary
-    InferenceResultDto.AnalResSummary summary = inferenceResultService.getInferenceResultSummary(id);
+    InferenceResultDto.AnalResSummary summary =
+        inferenceResultService.getInferenceResultSummary(id);
     // dashBoard
     List<InferenceResultDto.Dashboard> dashboardList = this.getInferenceResultDashboard(id);
     return ApiResponseDto.ok(new Detail(summary, dashboardList));
   }
 
-  @Operation(
+  @Operation(summary = "추론관리 분석결과 상세 목록", description = "추론관리 분석결과 상세 목록 geojson 데이터 조회")
-    summary = "추론관리 분석결과 상세 목록",
-    description =
-      "추론관리 분석결과 상세 목록 geojson 데이터 조회")
   @ApiResponses(
       value = {
         @ApiResponse(
@@ -134,27 +119,34 @@ public class InferenceResultApiController {
       })
   @GetMapping("/geom")
   public ApiResponseDto<Page<InferenceResultDto.Geom>> getInferenceResultGeomList(
-    @Parameter(description = "기준년도 분류", example = "0001") @RequestParam(required = false) String targetClass,
+      @Parameter(description = "기준년도 분류", example = "0001") @RequestParam(required = false)
-    @Parameter(description = "비교년도 분류", example = "0002") @RequestParam(required = false) String compareClass,
+          String targetClass,
-    @Parameter(description = "5000:1 도협번호 37801011,37801012") @RequestParam(required = false) List<Long> mapSheetNum,
+      @Parameter(description = "비교년도 분류", example = "0002") @RequestParam(required = false)
-    @Parameter(description = "페이지 번호 (0부터 시작)", example = "0") @RequestParam(defaultValue = "0") int page,
+          String compareClass,
-    @Parameter(description = "페이지 크기", example = "20") @RequestParam(defaultValue = "20") int size,
+      @Parameter(description = "5000:1 도협번호 37801011,37801012") @RequestParam(required = false)
-    @Parameter(description = "정렬 조건 (형식: 필드명,방향)", example = "name,asc") @RequestParam(required = false) String sort
+          List<Long> mapSheetNum,
-  ) {
+      @Parameter(description = "페이지 번호 (0부터 시작)", example = "0") @RequestParam(defaultValue = "0")
-    InferenceResultDto.SearchGeoReq searchGeoReq = new InferenceResultDto.SearchGeoReq(targetClass, compareClass, mapSheetNum, page, size, sort);
+          int page,
-    Page<InferenceResultDto.Geom> geomList = inferenceResultService.getInferenceResultGeomList(searchGeoReq);
+      @Parameter(description = "페이지 크기", example = "20") @RequestParam(defaultValue = "20")
+          int size,
+      @Parameter(description = "정렬 조건 (형식: 필드명,방향)", example = "name,asc")
+          @RequestParam(required = false)
+          String sort) {
+    InferenceResultDto.SearchGeoReq searchGeoReq =
+        new InferenceResultDto.SearchGeoReq(
+            targetClass, compareClass, mapSheetNum, page, size, sort);
+    Page<InferenceResultDto.Geom> geomList =
+        inferenceResultService.getInferenceResultGeomList(searchGeoReq);
     return ApiResponseDto.ok(geomList);
   }
 
   /**
    * 분석결과 상세 대시보드 조회
+   *
    * @param id
    * @return
    */
   private List<Dashboard> getInferenceResultDashboard(Long id) {
     return inferenceResultService.getInferenceResultBasic(id);
   }
-
-
-
 }

src/main/java/com/kamco/cd/kamcoback/inference/dto/InferenceResultDto.java

@@ -8,7 +8,6 @@ import lombok.AllArgsConstructor;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
 import lombok.Setter;
-import org.springframework.data.domain.Page;
 import org.springframework.data.domain.PageRequest;
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.domain.Sort;
@@ -23,10 +22,8 @@ public class InferenceResultDto {
     private String dataName;
     private Long mapSheepNum;
     private Long detectingCnt;
-    @JsonFormatDttm
+    @JsonFormatDttm private ZonedDateTime analStrtDttm;
-    private ZonedDateTime analStrtDttm;
+    @JsonFormatDttm private ZonedDateTime analEndDttm;
-    @JsonFormatDttm
-    private ZonedDateTime analEndDttm;
     private Long analSec;
     private String analState;
 
@@ -38,8 +35,7 @@ public class InferenceResultDto {
         ZonedDateTime analStrtDttm,
         ZonedDateTime analEndDttm,
         Long analSec,
-      String analState
+        String analState) {
-    ) {
       this.id = id;
       this.dataName = dataName;
       this.mapSheepNum = mapSheepNum;
@@ -58,10 +54,8 @@ public class InferenceResultDto {
     private String analTitle;
     private String analMapSheet;
     private Long detectingCnt;
-    @JsonFormatDttm
+    @JsonFormatDttm private ZonedDateTime analStrtDttm;
-    private ZonedDateTime analStrtDttm;
+    @JsonFormatDttm private ZonedDateTime analEndDttm;
-    @JsonFormatDttm
-    private ZonedDateTime analEndDttm;
     private Long analSec;
     private Long analPredSec;
     private String analState;
@@ -79,8 +73,7 @@ public class InferenceResultDto {
         Long analPredSec,
         String analState,
         String analStateNm,
-      String gukyuinUsed
+        String gukyuinUsed) {
-    ) {
       this.id = id;
       this.analTitle = analTitle;
       this.analMapSheet = analMapSheet;
@@ -103,10 +96,8 @@ public class InferenceResultDto {
     private Integer targetYyyy;
     private Integer compareYyyy;
     private String analMapSheet;
-    @JsonFormatDttm
+    @JsonFormatDttm private ZonedDateTime analStrtDttm;
-    private ZonedDateTime analStrtDttm;
+    @JsonFormatDttm private ZonedDateTime analEndDttm;
-    @JsonFormatDttm
-    private ZonedDateTime analEndDttm;
     private Long analSec;
     private Long analPredSec;
     private String resultUrl;
@@ -129,8 +120,7 @@ public class InferenceResultDto {
         Long detectingCnt,
         Double accuracy,
         String analState,
-      String analStateNm
+        String analStateNm) {
-    ) {
       this.id = id;
       this.modelInfo = modelInfo;
       this.targetYyyy = targetYyyy;
@@ -157,11 +147,9 @@ public class InferenceResultDto {
     String classAfterName;
     Long classBeforeCnt;
     Long classAfterCnt;
-    @JsonFormatDttm
+    @JsonFormatDttm ZonedDateTime createdDttm;
-    ZonedDateTime createdDttm;
     Long createdUid;
-    @JsonFormatDttm
+    @JsonFormatDttm ZonedDateTime updatedDttm;
-    ZonedDateTime updatedDttm;
     Long updatedUid;
     Long refMapSheetNum;
     Long dataUid;
@@ -179,8 +167,7 @@ public class InferenceResultDto {
         ZonedDateTime updatedDttm,
         Long updatedUid,
         Long refMapSheetNum,
-      Long dataUid
+        Long dataUid) {
-    ) {
       this.compareYyyy = compareYyyy;
       this.targetYyyy = targetYyyy;
       this.mapSheetNum = mapSheetNum;
@@ -202,10 +189,7 @@ public class InferenceResultDto {
     AnalResSummary summary;
     List<Dashboard> dashboard;
 
-    public Detail(
+    public Detail(AnalResSummary summary, List<Dashboard> dashboard) {
-      AnalResSummary summary,
-      List<Dashboard> dashboard
-    ) {
       this.summary = summary;
       this.dashboard = dashboard;
     }
@@ -232,8 +216,7 @@ public class InferenceResultDto {
         String classAfterCd,
         String classAfterName,
         Double classAfterProb,
-      Long mapSheetNum
+        Long mapSheetNum) {
-    ) {
       this.compareYyyy = compareYyyy;
       this.targetYyyy = targetYyyy;
       this.classBeforeCd = classBeforeCd;
@@ -246,9 +229,6 @@ public class InferenceResultDto {
     }
   }
 
-
-
-
   @Schema(name = "InferenceResultSearchReq", description = "분석결과 목록 요청 정보")
   @Getter
   @Setter

src/main/java/com/kamco/cd/kamcoback/inference/service/InferenceResultService.java

@@ -1,7 +1,6 @@
 package com.kamco.cd.kamcoback.inference.service;
 
 import com.kamco.cd.kamcoback.inference.dto.InferenceResultDto;
-import com.kamco.cd.kamcoback.inference.dto.InferenceResultDto.Basic;
 import com.kamco.cd.kamcoback.inference.dto.InferenceResultDto.Dashboard;
 import com.kamco.cd.kamcoback.postgres.core.InferenceResultCoreService;
 import java.util.List;
@@ -19,15 +18,18 @@ public class InferenceResultService {
 
   /**
    * 추론관리 > 분석결과 목록 조회
+   *
    * @param searchReq
    * @return
    */
-  public Page<InferenceResultDto.AnalResList> getInferenceResultList(InferenceResultDto.SearchReq searchReq) {
+  public Page<InferenceResultDto.AnalResList> getInferenceResultList(
+      InferenceResultDto.SearchReq searchReq) {
     return inferenceResultCoreService.getInferenceResultList(searchReq);
   }
 
   /**
    * 분석결과 요약정보
+   *
    * @param id
    * @return
    */
@@ -37,6 +39,7 @@ public class InferenceResultService {
 
   /**
    * 분석결과 대시보드 조회
+   *
    * @param id
    * @return
    */
@@ -46,12 +49,12 @@ public class InferenceResultService {
 
   /**
    * 분석결과 상세 목록
+   *
    * @param searchGeoReq
    * @return
    */
-  public Page<InferenceResultDto.Geom> getInferenceResultGeomList(InferenceResultDto.SearchGeoReq searchGeoReq) {
+  public Page<InferenceResultDto.Geom> getInferenceResultGeomList(
+      InferenceResultDto.SearchGeoReq searchGeoReq) {
     return inferenceResultCoreService.getInferenceResultGeomList(searchGeoReq);
   }
-
-
 }

src/main/java/com/kamco/cd/kamcoback/log/AuditLogApiController.java

@@ -3,7 +3,6 @@ package com.kamco.cd.kamcoback.log;
 import com.kamco.cd.kamcoback.config.api.ApiResponseDto;
 import com.kamco.cd.kamcoback.log.dto.AuditLogDto;
 import com.kamco.cd.kamcoback.log.service.AuditLogService;
-import com.kamco.cd.kamcoback.postgres.core.AuditLogCoreService;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import java.time.LocalDate;
@@ -29,8 +28,7 @@ public class AuditLogApiController {
       @RequestParam(required = false) LocalDate endDate,
       @RequestParam int page,
       @RequestParam(defaultValue = "20") int size) {
-    AuditLogDto.searchReq searchReq =
+    AuditLogDto.searchReq searchReq = new AuditLogDto.searchReq(page, size, "created_dttm,desc");
-        new AuditLogDto.searchReq(page, size, "created_dttm,desc");
 
     Page<AuditLogDto.DailyAuditList> result =
         auditLogService.getLogByDaily(searchReq, startDate, endDate);
@@ -44,10 +42,8 @@ public class AuditLogApiController {
       @RequestParam LocalDate logDate,
       @RequestParam int page,
       @RequestParam(defaultValue = "20") int size) {
-    AuditLogDto.searchReq searchReq =
+    AuditLogDto.searchReq searchReq = new AuditLogDto.searchReq(page, size, "created_dttm,desc");
-        new AuditLogDto.searchReq(page, size, "created_dttm,desc");
+    Page<AuditLogDto.DailyDetail> result = auditLogService.getLogByDailyResult(searchReq, logDate);
-    Page<AuditLogDto.DailyDetail> result =
-        auditLogService.getLogByDailyResult(searchReq, logDate);
 
     return ApiResponseDto.ok(result);
   }
@@ -58,8 +54,7 @@ public class AuditLogApiController {
       @RequestParam(required = false) String searchValue,
       @RequestParam int page,
       @RequestParam(defaultValue = "20") int size) {
-    AuditLogDto.searchReq searchReq =
+    AuditLogDto.searchReq searchReq = new AuditLogDto.searchReq(page, size, "created_dttm,desc");
-        new AuditLogDto.searchReq(page, size, "created_dttm,desc");
     Page<AuditLogDto.MenuAuditList> result = auditLogService.getLogByMenu(searchReq, searchValue);
 
     return ApiResponseDto.ok(result);
@@ -71,10 +66,8 @@ public class AuditLogApiController {
       @RequestParam String menuId,
       @RequestParam int page,
       @RequestParam(defaultValue = "20") int size) {
-    AuditLogDto.searchReq searchReq =
+    AuditLogDto.searchReq searchReq = new AuditLogDto.searchReq(page, size, "created_dttm,desc");
-        new AuditLogDto.searchReq(page, size, "created_dttm,desc");
+    Page<AuditLogDto.MenuDetail> result = auditLogService.getLogByMenuResult(searchReq, menuId);
-    Page<AuditLogDto.MenuDetail> result =
-        auditLogService.getLogByMenuResult(searchReq, menuId);
 
     return ApiResponseDto.ok(result);
   }
@@ -85,8 +78,7 @@ public class AuditLogApiController {
       @RequestParam(required = false) String searchValue,
       @RequestParam int page,
       @RequestParam(defaultValue = "20") int size) {
-    AuditLogDto.searchReq searchReq =
+    AuditLogDto.searchReq searchReq = new AuditLogDto.searchReq(page, size, "created_dttm,desc");
-        new AuditLogDto.searchReq(page, size, "created_dttm,desc");
     Page<AuditLogDto.UserAuditList> result =
         auditLogService.getLogByAccount(searchReq, searchValue);
 
@@ -99,10 +91,8 @@ public class AuditLogApiController {
       @RequestParam Long userUid,
       @RequestParam int page,
       @RequestParam(defaultValue = "20") int size) {
-    AuditLogDto.searchReq searchReq =
+    AuditLogDto.searchReq searchReq = new AuditLogDto.searchReq(page, size, "created_dttm,desc");
-        new AuditLogDto.searchReq(page, size, "created_dttm,desc");
+    Page<AuditLogDto.UserDetail> result = auditLogService.getLogByAccountResult(searchReq, userUid);
-    Page<AuditLogDto.UserDetail> result =
-        auditLogService.getLogByAccountResult(searchReq, userUid);
 
     return ApiResponseDto.ok(result);
   }

src/main/java/com/kamco/cd/kamcoback/log/ErrorLogApiController.java

@@ -4,7 +4,6 @@ import com.kamco.cd.kamcoback.config.api.ApiResponseDto;
 import com.kamco.cd.kamcoback.log.dto.ErrorLogDto;
 import com.kamco.cd.kamcoback.log.dto.EventType;
 import com.kamco.cd.kamcoback.log.service.ErrorLogService;
-import com.kamco.cd.kamcoback.postgres.core.ErrorLogCoreService;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import java.time.LocalDate;

src/main/java/com/kamco/cd/kamcoback/log/dto/AuditLogDto.java

@@ -3,8 +3,6 @@ package com.kamco.cd.kamcoback.log.dto;
 import com.fasterxml.jackson.annotation.JsonIgnore;
 import com.kamco.cd.kamcoback.common.utils.interfaces.JsonFormatDttm;
 import io.swagger.v3.oas.annotations.media.Schema;
-import java.time.LocalDate;
-import java.time.LocalDateTime;
 import java.time.ZonedDateTime;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
@@ -72,7 +70,13 @@ public class AuditLogDto {
   public static class DailyAuditList extends AuditCommon {
     private final String baseDate;
 
-    public DailyAuditList(int readCount, int cudCount, int printCount, int downloadCount, Long totalCount, String baseDate) {
+    public DailyAuditList(
+        int readCount,
+        int cudCount,
+        int printCount,
+        int downloadCount,
+        Long totalCount,
+        String baseDate) {
       super(readCount, cudCount, printCount, downloadCount, totalCount);
       this.baseDate = baseDate;
     }
@@ -84,7 +88,14 @@ public class AuditLogDto {
     private final String menuId;
     private final String menuName;
 
-    public MenuAuditList(String menuId, String menuName, int readCount, int cudCount, int printCount, int downloadCount, Long totalCount) {
+    public MenuAuditList(
+        String menuId,
+        String menuName,
+        int readCount,
+        int cudCount,
+        int printCount,
+        int downloadCount,
+        Long totalCount) {
       super(readCount, cudCount, printCount, downloadCount, totalCount);
       this.menuId = menuId;
       this.menuName = menuName;
@@ -98,7 +109,15 @@ public class AuditLogDto {
     private final String loginId;
     private final String username;
 
-    public UserAuditList(Long accountId, String loginId, String username, int readCount, int cudCount, int printCount, int downloadCount, Long totalCount) {
+    public UserAuditList(
+        Long accountId,
+        String loginId,
+        String username,
+        int readCount,
+        int cudCount,
+        int printCount,
+        int downloadCount,
+        Long totalCount) {
       super(readCount, cudCount, printCount, downloadCount, totalCount);
       this.accountId = accountId;
       this.loginId = loginId;
@@ -122,13 +141,20 @@ public class AuditLogDto {
     private final String loginId;
     private final String menuName;
 
-    public DailyDetail(Long logId, String userName, String loginId, String menuName, EventType eventType, LogDetail detail){
+    public DailyDetail(
+        Long logId,
+        String userName,
+        String loginId,
+        String menuName,
+        EventType eventType,
+        LogDetail detail) {
       super(logId, eventType, detail);
       this.userName = userName;
       this.loginId = loginId;
       this.menuName = menuName;
     }
   }
+
   @Schema(name = "MenuDetail", description = "메뉴별 로그 상세")
   @Getter
   public static class MenuDetail extends AuditDetail {
@@ -136,20 +162,28 @@ public class AuditLogDto {
     private final String userName;
     private final String loginId;
 
-    public MenuDetail(Long logId, String logDateTime, String userName, String loginId, EventType eventType, LogDetail detail){
+    public MenuDetail(
+        Long logId,
+        String logDateTime,
+        String userName,
+        String loginId,
+        EventType eventType,
+        LogDetail detail) {
       super(logId, eventType, detail);
       this.logDateTime = logDateTime;
       this.userName = userName;
       this.loginId = loginId;
     }
   }
+
   @Schema(name = "UserDetail", description = "사용자별 로그 상세")
   @Getter
   public static class UserDetail extends AuditDetail {
     private final String logDateTime;
     private final String menuNm;
 
-    public UserDetail(Long logId, String logDateTime, String menuNm, EventType eventType, LogDetail detail){
+    public UserDetail(
+        Long logId, String logDateTime, String menuNm, EventType eventType, LogDetail detail) {
       super(logId, eventType, detail);
       this.logDateTime = logDateTime;
       this.menuNm = menuNm;

src/main/java/com/kamco/cd/kamcoback/log/service/AuditLogService.java

@@ -2,13 +2,12 @@ package com.kamco.cd.kamcoback.log.service;
 
 import com.kamco.cd.kamcoback.log.dto.AuditLogDto;
 import com.kamco.cd.kamcoback.postgres.core.AuditLogCoreService;
+import java.time.LocalDate;
 import lombok.RequiredArgsConstructor;
 import org.springframework.data.domain.Page;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
-import java.time.LocalDate;
-
 @Service
 @RequiredArgsConstructor
 @Transactional(readOnly = true)
@@ -44,6 +43,4 @@ public class AuditLogService {
       AuditLogDto.searchReq searchRange, Long accountId) {
     return auditLogCoreService.getLogByAccountResult(searchRange, accountId);
   }
-
-
 }

src/main/java/com/kamco/cd/kamcoback/model/ModelMngApiController.java

@@ -2,7 +2,6 @@ package com.kamco.cd.kamcoback.model;
 
 import com.kamco.cd.kamcoback.code.dto.CommonCodeDto;
 import com.kamco.cd.kamcoback.config.api.ApiResponseDto;
-import com.kamco.cd.kamcoback.log.dto.AuditLogDto;
 import com.kamco.cd.kamcoback.model.dto.ModelMngDto;
 import com.kamco.cd.kamcoback.model.dto.ModelVerDto;
 import com.kamco.cd.kamcoback.model.service.ModelMngService;
@@ -13,13 +12,12 @@ import io.swagger.v3.oas.annotations.responses.ApiResponse;
 import io.swagger.v3.oas.annotations.responses.ApiResponses;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import jakarta.transaction.Transactional;
-import lombok.RequiredArgsConstructor;
-import org.springframework.data.domain.Page;
-import org.springframework.web.bind.annotation.*;
-
 import java.time.LocalDate;
 import java.util.List;
 import java.util.Optional;
+import lombok.RequiredArgsConstructor;
+import org.springframework.data.domain.Page;
+import org.springframework.web.bind.annotation.*;
 
 @Tag(name = "모델 관리", description = "모델 관리 API")
 @RequiredArgsConstructor
@@ -50,6 +48,7 @@ public class ModelMngApiController {
 
   /**
    * 최종 등록 모델 정보
+   *
    * @return ModelMngDto.FinalModelDto
    */
   @Operation(summary = "최종 등록 모델 조회", description = "최종 등록 모델 조회")
@@ -60,6 +59,7 @@ public class ModelMngApiController {
 
   /**
    * 모델 등록 => 모델, 버전 동시 등록 (UI 상 따로 등록하는 곳 없음)
+   *
    * @param addReq 모델 입력 값
    * @return ModelVerDto.Basic
    */
@@ -71,7 +71,8 @@ public class ModelMngApiController {
 
   @Operation(summary = "모델 수정", description = "모델 수정")
   @PutMapping("/{id}")
-  public ApiResponseDto<Long> update(@PathVariable Long id, @RequestBody ModelMngDto.AddReq addReq) {
+  public ApiResponseDto<Long> update(
+      @PathVariable Long id, @RequestBody ModelMngDto.AddReq addReq) {
     return ApiResponseDto.ok(modelMngService.update(id, addReq));
   }
 
@@ -89,10 +90,10 @@ public class ModelMngApiController {
       @RequestParam int page,
       @RequestParam(defaultValue = "20") int size,
       @RequestParam(required = false) String searchVal,
-    @RequestParam(required = false) String searchColumn
+      @RequestParam(required = false) String searchColumn) {
-  ) {
     ModelMngDto.searchReq searchReq =
-      new ModelMngDto.searchReq(page, size, Optional.ofNullable(searchColumn).orElse("createdDate") + ",desc");
+        new ModelMngDto.searchReq(
+            page, size, Optional.ofNullable(searchColumn).orElse("createdDate") + ",desc");
     // searchColumn:: Entity 컬럼명칭으로 -> 기본값 = 등록일 createdDate, (선택) 배포일 deployDttm
 
     Page<ModelMngDto.ModelRegHistory> result =

src/main/java/com/kamco/cd/kamcoback/model/dto/ModelMngDto.java

@@ -3,6 +3,7 @@ package com.kamco.cd.kamcoback.model.dto;
 import com.kamco.cd.kamcoback.common.utils.interfaces.JsonFormatDttm;
 import io.swagger.v3.oas.annotations.media.Schema;
 import jakarta.validation.constraints.NotEmpty;
+import java.time.ZonedDateTime;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
@@ -11,8 +12,6 @@ import org.springframework.data.domain.PageRequest;
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.domain.Sort;
 
-import java.time.ZonedDateTime;
-
 public class ModelMngDto {
 
   @Schema(name = "ModelMng Basic", description = "모델관리 엔티티 기본 정보")
@@ -24,12 +23,10 @@ public class ModelMngDto {
     private final String modelCate;
     private final String modelPath;
 
-    @JsonFormatDttm
+    @JsonFormatDttm private final ZonedDateTime createdDttm;
-    private final ZonedDateTime createdDttm;
     private final Long createdUid;
 
-    @JsonFormatDttm
+    @JsonFormatDttm private final ZonedDateTime updatedDttm;
-    private final ZonedDateTime updatedDttm;
     private final Long updatedUid;
     private final String modelCntnt;
 
@@ -42,8 +39,7 @@ public class ModelMngDto {
         Long createdUid,
         ZonedDateTime updatedDttm,
         Long updatedUid,
-      String modelCntnt
+        String modelCntnt) {
-    ) {
       this.id = id;
       this.modelNm = modelNm;
       this.modelCate = modelCate;
@@ -70,8 +66,17 @@ public class ModelMngDto {
     private final String deployState;
     private final String modelPath;
 
-    public FinalModelDto(Long modelUid, String modelNm, String modelCate, Long modelVerUid, String modelVer,
+    public FinalModelDto(
-        String usedState, String modelState, Double qualityProb, String deployState, String modelPath) {
+        Long modelUid,
+        String modelNm,
+        String modelCate,
+        Long modelVerUid,
+        String modelVer,
+        String usedState,
+        String modelState,
+        Double qualityProb,
+        String deployState,
+        String modelPath) {
       this.modelUid = modelUid;
       this.modelNm = modelNm;
       this.modelCate = modelCate;

src/main/java/com/kamco/cd/kamcoback/model/dto/ModelVerDto.java

@@ -2,13 +2,8 @@ package com.kamco.cd.kamcoback.model.dto;
 
 import com.kamco.cd.kamcoback.common.utils.interfaces.JsonFormatDttm;
 import io.swagger.v3.oas.annotations.media.Schema;
-import jakarta.validation.constraints.NotEmpty;
-import lombok.AllArgsConstructor;
-import lombok.Getter;
-import lombok.NoArgsConstructor;
-import lombok.Setter;
-
 import java.time.ZonedDateTime;
+import lombok.Getter;
 
 public class ModelVerDto {
 
@@ -28,12 +23,10 @@ public class ModelVerDto {
     private final String deployState;
     private final String modelPath;
 
-    @JsonFormatDttm
+    @JsonFormatDttm private final ZonedDateTime createdDttm;
-    private final ZonedDateTime createdDttm;
     private final Long createdUid;
 
-    @JsonFormatDttm
+    @JsonFormatDttm private final ZonedDateTime updatedDttm;
-    private final ZonedDateTime updatedDttm;
     private final Long updatedUid;
 
     public Basic(
@@ -49,8 +42,7 @@ public class ModelVerDto {
         ZonedDateTime createdDttm,
         Long createdUid,
         ZonedDateTime updatedDttm,
-      Long updatedUid
+        Long updatedUid) {
-    ) {
       this.id = id;
       this.modelUid = modelUid;
       this.modelCate = modelCate;
@@ -66,5 +58,4 @@ public class ModelVerDto {
       this.updatedUid = updatedUid;
     }
   }
-
 }

src/main/java/com/kamco/cd/kamcoback/model/service/ModelMngService.java

@@ -1,18 +1,16 @@
 package com.kamco.cd.kamcoback.model.service;
 
-import com.kamco.cd.kamcoback.log.dto.AuditLogDto;
 import com.kamco.cd.kamcoback.model.dto.ModelMngDto;
 import com.kamco.cd.kamcoback.model.dto.ModelVerDto;
 import com.kamco.cd.kamcoback.postgres.core.ModelMngCoreService;
+import java.time.LocalDate;
+import java.util.List;
+import java.util.Optional;
 import lombok.RequiredArgsConstructor;
 import org.springframework.data.domain.Page;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
-import java.time.LocalDate;
-import java.util.List;
-import java.util.Optional;
-
 @Service
 @RequiredArgsConstructor
 @Transactional(readOnly = true)
@@ -40,7 +38,8 @@ public class ModelMngService {
     return modelMngCoreService.delete(id);
   }
 
-  public Page<ModelMngDto.ModelRegHistory> getRegHistoryList(ModelMngDto.searchReq searchReq, LocalDate startDate, LocalDate endDate, String searchVal) {
+  public Page<ModelMngDto.ModelRegHistory> getRegHistoryList(
+      ModelMngDto.searchReq searchReq, LocalDate startDate, LocalDate endDate, String searchVal) {
     return modelMngCoreService.getRegHistoryList(searchReq, startDate, endDate, searchVal);
   }
 }

src/main/java/com/kamco/cd/kamcoback/postgres/QuerydslOrderUtil.java

@@ -8,16 +8,18 @@ import org.springframework.data.domain.Pageable;
 public class QuerydslOrderUtil {
   /**
    * Pageable의 Sort 정보를 QueryDSL OrderSpecifier 배열로 변환
+   *
    * @param pageable Spring Pageable
    * @param entityClass 엔티티 클래스 (예: User.class)
    * @param alias Q 엔티티 alias (예: "user")
    */
-  public static <T> OrderSpecifier<?>[] getOrderSpecifiers(Pageable pageable, Class<T> entityClass, String alias) {
+  public static <T> OrderSpecifier<?>[] getOrderSpecifiers(
+      Pageable pageable, Class<T> entityClass, String alias) {
     PathBuilder<T> entityPath = new PathBuilder<>(entityClass, alias);
 
-    return pageable.getSort()
+    return pageable.getSort().stream()
-      .stream()
+        .map(
-      .map(sort -> {
+            sort -> {
               Order order = sort.isAscending() ? Order.ASC : Order.DESC;
               // PathBuilder.get()는 컬럼명(String)을 동적 Path로 반환
               return new OrderSpecifier<>(order, entityPath.get(sort.getProperty(), String.class));

src/main/java/com/kamco/cd/kamcoback/postgres/core/ChangeDetectionCoreService.java

@@ -1,17 +1,15 @@
 package com.kamco.cd.kamcoback.postgres.core;
 
-
 import com.kamco.cd.kamcoback.changedetection.dto.ChangeDetectionDto;
 import com.kamco.cd.kamcoback.postgres.entity.MapSheetAnalDataGeomEntity;
 import com.kamco.cd.kamcoback.postgres.repository.changedetection.ChangeDetectionRepository;
+import java.util.List;
+import java.util.stream.Collectors;
 import lombok.RequiredArgsConstructor;
 import org.locationtech.jts.geom.Geometry;
 import org.locationtech.jts.geom.Point;
 import org.springframework.stereotype.Service;
 
-import java.util.List;
-import java.util.stream.Collectors;
-
 @Service
 @RequiredArgsConstructor
 public class ChangeDetectionCoreService {
@@ -21,17 +19,14 @@ public class ChangeDetectionCoreService {
   public List<ChangeDetectionDto> getPolygonToPoint() {
     List<MapSheetAnalDataGeomEntity> list = changeDetectionRepository.findAll();
 
-    return list.stream().map(p -> {
+    return list.stream()
+        .map(
+            p -> {
               Geometry polygon = p.getGeom();
               // 중심 좌표 계산
               Point centroid = polygon.getCentroid();
 
-      return new ChangeDetectionDto(
+              return new ChangeDetectionDto(p.getId(), polygon, centroid.getX(), centroid.getY());
-        p.getId(),
-        polygon,
-        centroid.getX(),
-        centroid.getY()
-      );
             })
         .collect(Collectors.toList());
   }

src/main/java/com/kamco/cd/kamcoback/postgres/core/CommonCodeCoreService.java

@@ -75,6 +75,7 @@ public class CommonCodeCoreService
 
   /**
    * 공통코드 이름 조회
+   *
    * @param parentCodeCd
    * @param childCodeCd
    * @return

src/main/java/com/kamco/cd/kamcoback/postgres/core/InferenceResultCoreService.java

@@ -6,7 +6,6 @@ import com.kamco.cd.kamcoback.postgres.entity.MapSheetAnalSttcEntity;
 import com.kamco.cd.kamcoback.postgres.repository.Inference.InferenceResultRepository;
 import jakarta.persistence.EntityNotFoundException;
 import java.util.List;
-import java.util.stream.Collectors;
 import lombok.RequiredArgsConstructor;
 import org.springframework.data.domain.Page;
 import org.springframework.stereotype.Service;
@@ -19,41 +18,49 @@ public class InferenceResultCoreService {
 
   /**
    * 추론관리 > 분석결과 목록 조회
+   *
    * @param searchReq
    * @return
    */
-  public Page<InferenceResultDto.AnalResList> getInferenceResultList(InferenceResultDto.SearchReq searchReq) {
+  public Page<InferenceResultDto.AnalResList> getInferenceResultList(
+      InferenceResultDto.SearchReq searchReq) {
     return inferenceResultRepository.getInferenceResultList(searchReq);
   }
 
   /**
    * 분석결과 요약정보
+   *
    * @param id
    * @return
    */
   public InferenceResultDto.AnalResSummary getInferenceResultSummary(Long id) {
-    InferenceResultDto.AnalResSummary summary = inferenceResultRepository.getInferenceResultSummary(id).orElseThrow(() -> new EntityNotFoundException("요약정보를 찾을 수 없습니다. " + id));
+    InferenceResultDto.AnalResSummary summary =
+        inferenceResultRepository
+            .getInferenceResultSummary(id)
+            .orElseThrow(() -> new EntityNotFoundException("요약정보를 찾을 수 없습니다. " + id));
     return summary;
   }
 
   /**
    * 분석결과 대시보드 조회
+   *
    * @param id
    * @return
    */
   public List<Dashboard> getInferenceResultDashboard(Long id) {
-    return inferenceResultRepository.getInferenceResultDashboard(id)
+    return inferenceResultRepository.getInferenceResultDashboard(id).stream()
-      .stream()
         .map(MapSheetAnalSttcEntity::toDto)
         .toList();
   }
 
   /**
    * 분석결과 상세 목록
+   *
    * @param searchGeoReq
    * @return
    */
-  public Page<InferenceResultDto.Geom> getInferenceResultGeomList(InferenceResultDto.SearchGeoReq searchGeoReq) {
+  public Page<InferenceResultDto.Geom> getInferenceResultGeomList(
+      InferenceResultDto.SearchGeoReq searchGeoReq) {
     return inferenceResultRepository.getInferenceGeomList(searchGeoReq);
   }
 }

src/main/java/com/kamco/cd/kamcoback/postgres/core/ModelMngCoreService.java

@@ -7,13 +7,12 @@ import com.kamco.cd.kamcoback.postgres.entity.ModelVerEntity;
 import com.kamco.cd.kamcoback.postgres.repository.model.ModelMngRepository;
 import com.kamco.cd.kamcoback.postgres.repository.model.ModelVerRepository;
 import jakarta.persistence.EntityNotFoundException;
-import lombok.RequiredArgsConstructor;
-import org.springframework.data.domain.Page;
-import org.springframework.stereotype.Service;
-
 import java.time.LocalDate;
 import java.util.List;
 import java.util.Optional;
+import lombok.RequiredArgsConstructor;
+import org.springframework.data.domain.Page;
+import org.springframework.stereotype.Service;
 
 @Service
 @RequiredArgsConstructor
@@ -31,18 +30,36 @@ public class ModelMngCoreService {
   }
 
   public ModelVerDto.Basic save(ModelMngDto.AddReq addReq) {
-    ModelMngEntity modelMngEntity = new ModelMngEntity(addReq.getModelNm(), addReq.getModelCate(), addReq.getModelPath(),
+    ModelMngEntity modelMngEntity =
-          1L, 1L, addReq.getModelCntnt());    //TODO: 로그인 기능 붙이면 Uid 넣어야 함
+        new ModelMngEntity(
+            addReq.getModelNm(),
+            addReq.getModelCate(),
+            addReq.getModelPath(),
+            1L,
+            1L,
+            addReq.getModelCntnt()); // TODO: 로그인 기능 붙이면 Uid 넣어야 함
 
     ModelMngEntity saved = modelMngRepository.save(modelMngEntity);
-    ModelVerEntity modelVerEntity = new ModelVerEntity(saved.getId(), addReq.getModelCate(), addReq.getModelVer(), "NONE", "NONE",
+    ModelVerEntity modelVerEntity =
-      0.0, "NONE", addReq.getModelPath(), 1L, 1L);
+        new ModelVerEntity(
+            saved.getId(),
+            addReq.getModelCate(),
+            addReq.getModelVer(),
+            "NONE",
+            "NONE",
+            0.0,
+            "NONE",
+            addReq.getModelPath(),
+            1L,
+            1L);
     return modelVerRepository.save(modelVerEntity).toDto();
   }
 
   public Long update(Long id, ModelMngDto.AddReq addReq) {
     // 조회
-    ModelVerEntity existData = modelVerRepository.findModelVerById(id)
+    ModelVerEntity existData =
+        modelVerRepository
+            .findModelVerById(id)
             .orElseThrow(EntityNotFoundException::new); // 데이터 없는 경우 exception
     existData.update(addReq);
     // TODO: 추후 수정 단계에서 도커파일 업로드하면 버전 업데이트 하는 로직 필요
@@ -51,7 +68,9 @@ public class ModelMngCoreService {
 
   public Long delete(Long id) {
     // 조회
-    ModelVerEntity verEntity = modelVerRepository.findModelVerById(id)
+    ModelVerEntity verEntity =
+        modelVerRepository
+            .findModelVerById(id)
             .orElseThrow(() -> new EntityNotFoundException("버전 id 에 대한 정보를 찾을 수 없습니다. id : " + id));
 
     // usedState가 USED 이거나 이미 삭제된 상태이면 삭제 불가
@@ -64,7 +83,8 @@ public class ModelMngCoreService {
     return verEntity.getId();
   }
 
-  public Page<ModelMngDto.ModelRegHistory> getRegHistoryList(ModelMngDto.searchReq searchReq, LocalDate startDate, LocalDate endDate, String searchVal) {
+  public Page<ModelMngDto.ModelRegHistory> getRegHistoryList(
+      ModelMngDto.searchReq searchReq, LocalDate startDate, LocalDate endDate, String searchVal) {
     return modelMngRepository.getRegHistoryList(searchReq, startDate, endDate, searchVal);
   }
 }

src/main/java/com/kamco/cd/kamcoback/postgres/entity/MapSheetAnalDataEntity.java

@@ -8,8 +8,6 @@ import jakarta.persistence.Id;
 import jakarta.persistence.SequenceGenerator;
 import jakarta.persistence.Table;
 import jakarta.validation.constraints.Size;
-import java.time.Instant;
-import java.time.LocalTime;
 import java.time.ZonedDateTime;
 import java.util.Map;
 import lombok.Getter;
@@ -26,7 +24,10 @@ public class MapSheetAnalDataEntity {
 
   @Id
   @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "tb_map_sheet_anal_data_id_gen")
-  @SequenceGenerator(name = "tb_map_sheet_anal_data_id_gen", sequenceName = "tb_map_sheet_learn_data_data_uid", allocationSize = 1)
+  @SequenceGenerator(
+      name = "tb_map_sheet_anal_data_id_gen",
+      sequenceName = "tb_map_sheet_learn_data_data_uid",
+      allocationSize = 1)
   @Column(name = "data_uid", nullable = false)
   private Long id;
 
@@ -103,5 +104,4 @@ public class MapSheetAnalDataEntity {
 
   @Column(name = "detecting_cnt")
   private Long detectingCnt;
-
 }

src/main/java/com/kamco/cd/kamcoback/postgres/entity/MapSheetAnalDataGeomEntity.java

@@ -2,12 +2,11 @@ package com.kamco.cd.kamcoback.postgres.entity;
 
 import jakarta.persistence.*;
 import jakarta.validation.constraints.Size;
+import java.time.ZonedDateTime;
 import lombok.Getter;
 import lombok.Setter;
 import org.locationtech.jts.geom.Geometry;
 
-import java.time.ZonedDateTime;
-
 @Getter
 @Setter
 @Entity
@@ -15,8 +14,13 @@ import java.time.ZonedDateTime;
 public class MapSheetAnalDataGeomEntity {
 
   @Id
-  @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "tb_map_sheet_anal_data_geom_id_gen")
+  @GeneratedValue(
-  @SequenceGenerator(name = "tb_map_sheet_anal_data_geom_id_gen", sequenceName = "tb_map_sheet_learn_data_geom_geom_uid", allocationSize = 1)
+      strategy = GenerationType.SEQUENCE,
+      generator = "tb_map_sheet_anal_data_geom_id_gen")
+  @SequenceGenerator(
+      name = "tb_map_sheet_anal_data_geom_id_gen",
+      sequenceName = "tb_map_sheet_learn_data_geom_geom_uid",
+      allocationSize = 1)
   @Column(name = "geo_uid", nullable = false)
   private Long id;
 

src/main/java/com/kamco/cd/kamcoback/postgres/entity/MapSheetAnalEntity.java

@@ -2,16 +2,12 @@ package com.kamco.cd.kamcoback.postgres.entity;
 
 import jakarta.persistence.Column;
 import jakarta.persistence.Entity;
-import jakarta.persistence.FetchType;
 import jakarta.persistence.GeneratedValue;
 import jakarta.persistence.GenerationType;
 import jakarta.persistence.Id;
-import jakarta.persistence.JoinColumn;
-import jakarta.persistence.ManyToOne;
 import jakarta.persistence.SequenceGenerator;
 import jakarta.persistence.Table;
 import jakarta.validation.constraints.Size;
-import java.time.Instant;
 import java.time.ZonedDateTime;
 import lombok.Getter;
 import lombok.Setter;
@@ -25,7 +21,10 @@ public class MapSheetAnalEntity {
 
   @Id
   @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "tb_map_sheet_anal_id_gen")
-  @SequenceGenerator(name = "tb_map_sheet_anal_id_gen", sequenceName = "tb_map_sheet_anal_anal_uid", allocationSize = 1)
+  @SequenceGenerator(
+      name = "tb_map_sheet_anal_id_gen",
+      sequenceName = "tb_map_sheet_anal_anal_uid",
+      allocationSize = 1)
   @Column(name = "anal_uid", nullable = false)
   private Long id;
 
@@ -92,5 +91,4 @@ public class MapSheetAnalEntity {
 
   @Column(name = "detecting_cnt")
   private Long detectingCnt;
-
 }

src/main/java/com/kamco/cd/kamcoback/postgres/entity/MapSheetAnalSttcEntity.java

@@ -1,13 +1,11 @@
 package com.kamco.cd.kamcoback.postgres.entity;
 
-import com.kamco.cd.kamcoback.code.dto.CommonCodeDto;
 import com.kamco.cd.kamcoback.inference.dto.InferenceResultDto;
 import jakarta.persistence.Column;
 import jakarta.persistence.EmbeddedId;
 import jakarta.persistence.Entity;
 import jakarta.persistence.Table;
 import jakarta.validation.constraints.NotNull;
-import java.time.OffsetDateTime;
 import java.time.ZonedDateTime;
 import lombok.Getter;
 import lombok.Setter;
@@ -19,8 +17,7 @@ import org.hibernate.annotations.ColumnDefault;
 @Table(name = "tb_map_sheet_anal_sttc")
 public class MapSheetAnalSttcEntity {
 
-  @EmbeddedId
+  @EmbeddedId private MapSheetAnalSttcEntityId id;
-  private MapSheetAnalSttcEntityId id;
 
   @Column(name = "class_before_cnt")
   private Long classBeforeCnt;
@@ -64,7 +61,6 @@ public class MapSheetAnalSttcEntity {
         this.updatedDttm,
         this.updatedUid,
         this.refMapSheetNum,
-      this.dataUid
+        this.dataUid);
-    );
   }
 }

src/main/java/com/kamco/cd/kamcoback/postgres/entity/MapSheetAnalSttcEntityId.java

@@ -16,6 +16,7 @@ import org.hibernate.Hibernate;
 public class MapSheetAnalSttcEntityId implements Serializable {
 
   private static final long serialVersionUID = -8630519290255405042L;
+
   @NotNull
   @Column(name = "compare_yyyy", nullable = false)
   private Integer compareYyyy;
@@ -47,16 +48,15 @@ public class MapSheetAnalSttcEntityId implements Serializable {
       return false;
     }
     MapSheetAnalSttcEntityId entity = (MapSheetAnalSttcEntityId) o;
-    return Objects.equals(this.targetYyyy, entity.targetYyyy) &&
+    return Objects.equals(this.targetYyyy, entity.targetYyyy)
-      Objects.equals(this.classBeforeName, entity.classBeforeName) &&
+        && Objects.equals(this.classBeforeName, entity.classBeforeName)
-      Objects.equals(this.classAfterName, entity.classAfterName) &&
+        && Objects.equals(this.classAfterName, entity.classAfterName)
-      Objects.equals(this.compareYyyy, entity.compareYyyy) &&
+        && Objects.equals(this.compareYyyy, entity.compareYyyy)
-      Objects.equals(this.mapSheetNum, entity.mapSheetNum);
+        && Objects.equals(this.mapSheetNum, entity.mapSheetNum);
   }
 
   @Override
   public int hashCode() {
     return Objects.hash(targetYyyy, classBeforeName, classAfterName, compareYyyy, mapSheetNum);
   }
-
 }

src/main/java/com/kamco/cd/kamcoback/postgres/entity/MapSheetLearnDataEntity.java

@@ -5,8 +5,6 @@ import jakarta.persistence.Entity;
 import jakarta.persistence.Id;
 import jakarta.persistence.Table;
 import jakarta.validation.constraints.Size;
-import java.time.LocalTime;
-import java.time.OffsetDateTime;
 import java.time.ZonedDateTime;
 import java.util.Map;
 import lombok.Getter;
@@ -104,5 +102,4 @@ public class MapSheetLearnDataEntity {
 
   @Column(name = "updated_uid")
   private Long updatedUid;
-
 }

src/main/java/com/kamco/cd/kamcoback/postgres/entity/MapSheetLearnDataGeomEntity.java

@@ -2,18 +2,12 @@ package com.kamco.cd.kamcoback.postgres.entity;
 
 import jakarta.persistence.Column;
 import jakarta.persistence.Entity;
-import jakarta.persistence.FetchType;
 import jakarta.persistence.Id;
-import jakarta.persistence.JoinColumn;
-import jakarta.persistence.ManyToOne;
 import jakarta.persistence.Table;
 import jakarta.validation.constraints.Size;
-import java.time.OffsetDateTime;
 import java.time.ZonedDateTime;
 import lombok.Getter;
 import lombok.Setter;
-import org.hibernate.annotations.OnDelete;
-import org.hibernate.annotations.OnDeleteAction;
 import org.locationtech.jts.geom.Geometry;
 
 @Getter
@@ -75,5 +69,4 @@ public class MapSheetLearnDataGeomEntity {
 
   @Column(name = "updated_uid")
   private Long updatedUid;
-
 }

src/main/java/com/kamco/cd/kamcoback/postgres/entity/ModelDeployHstEntity.java

@@ -2,11 +2,10 @@ package com.kamco.cd.kamcoback.postgres.entity;
 
 import com.kamco.cd.kamcoback.postgres.CommonDateEntity;
 import jakarta.persistence.*;
+import java.time.ZonedDateTime;
 import lombok.Getter;
 import lombok.Setter;
 
-import java.time.ZonedDateTime;
-
 @Getter
 @Setter
 @Entity
@@ -14,7 +13,10 @@ import java.time.ZonedDateTime;
 public class ModelDeployHstEntity extends CommonDateEntity {
   @Id
   @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "tb_model_deploy_hst_id_gen")
-  @SequenceGenerator(name = "tb_model_deploy_hst_id_gen", sequenceName = "tb_model_deploy_hst_deploy_uid", allocationSize = 1)
+  @SequenceGenerator(
+      name = "tb_model_deploy_hst_id_gen",
+      sequenceName = "tb_model_deploy_hst_deploy_uid",
+      allocationSize = 1)
   @Column(name = "deploy_uid", nullable = false)
   private Long id;
 

src/main/java/com/kamco/cd/kamcoback/postgres/entity/ModelMngEntity.java

@@ -8,8 +8,6 @@ import lombok.Getter;
 import lombok.Setter;
 import org.hibernate.annotations.ColumnDefault;
 
-import java.time.ZonedDateTime;
-
 @Getter
 @Setter
 @Entity
@@ -18,7 +16,10 @@ public class ModelMngEntity extends CommonDateEntity {
 
   @Id
   @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "tb_model_mng_id_gen")
-  @SequenceGenerator(name = "tb_model_mng_id_gen", sequenceName = "tb_model_mng_model_uid", allocationSize = 1)
+  @SequenceGenerator(
+      name = "tb_model_mng_id_gen",
+      sequenceName = "tb_model_mng_model_uid",
+      allocationSize = 1)
   @Column(name = "model_uid", nullable = false)
   private Long id;
 
@@ -46,8 +47,13 @@ public class ModelMngEntity extends CommonDateEntity {
   @Column(name = "model_cntnt", columnDefinition = "TEXT")
   private String modelCntnt;
 
-  public ModelMngEntity(String modelNm, String modelCate, String modelPath,
+  public ModelMngEntity(
-                        Long createdUid, Long updatedUid, String modelCntnt) {
+      String modelNm,
+      String modelCate,
+      String modelPath,
+      Long createdUid,
+      Long updatedUid,
+      String modelCntnt) {
     this.modelNm = modelNm;
     this.modelCate = modelCate;
     this.modelPath = modelPath;

src/main/java/com/kamco/cd/kamcoback/postgres/entity/ModelVerEntity.java

@@ -19,7 +19,10 @@ public class ModelVerEntity extends CommonDateEntity {
 
   @Id
   @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "tb_model_ver_id_gen")
-  @SequenceGenerator(name = "tb_model_ver_id_gen", sequenceName = "tb_model_ver_model_ver_uid", allocationSize = 1)
+  @SequenceGenerator(
+      name = "tb_model_ver_id_gen",
+      sequenceName = "tb_model_ver_model_ver_uid",
+      allocationSize = 1)
   @Column(name = "model_ver_uid", nullable = false)
   private Long id;
 
@@ -62,8 +65,19 @@ public class ModelVerEntity extends CommonDateEntity {
 
   private Boolean deleted = false;
 
-  public ModelVerEntity(Long id, Long modelUid, String modelCate, String modelVer, String usedState, String modelState,
+  public ModelVerEntity(
-                        Double qualityProb, String deployState, String modelPath, Long createdUid, Long updatedUid, Boolean deleted) {
+      Long id,
+      Long modelUid,
+      String modelCate,
+      String modelVer,
+      String usedState,
+      String modelState,
+      Double qualityProb,
+      String deployState,
+      String modelPath,
+      Long createdUid,
+      Long updatedUid,
+      Boolean deleted) {
     this.id = id;
     this.modelUid = modelUid;
     this.modelCate = modelCate;
@@ -78,8 +92,17 @@ public class ModelVerEntity extends CommonDateEntity {
     this.deleted = deleted;
   }
 
-  public ModelVerEntity(Long modelUid, String modelCate, String modelVer, String usedState, String modelState,
+  public ModelVerEntity(
-                        Double qualityProb, String deployState, String modelPath, Long createdUid, Long updatedUid) {
+      Long modelUid,
+      String modelCate,
+      String modelVer,
+      String usedState,
+      String modelState,
+      Double qualityProb,
+      String deployState,
+      String modelPath,
+      Long createdUid,
+      Long updatedUid) {
     this.modelUid = modelUid;
     this.modelCate = modelCate;
     this.modelVer = modelVer;

src/main/java/com/kamco/cd/kamcoback/postgres/repository/Inference/InferenceResultRepository.java

@@ -3,6 +3,5 @@ package com.kamco.cd.kamcoback.postgres.repository.Inference;
 import com.kamco.cd.kamcoback.postgres.entity.MapSheetAnalEntity;
 import org.springframework.data.jpa.repository.JpaRepository;
 
-public interface InferenceResultRepository extends JpaRepository<MapSheetAnalEntity, Long>, InferenceResultRepositoryCustom {
+public interface InferenceResultRepository
-
+    extends JpaRepository<MapSheetAnalEntity, Long>, InferenceResultRepositoryCustom {}
-}

src/main/java/com/kamco/cd/kamcoback/postgres/repository/Inference/InferenceResultRepositoryCustom.java

@@ -1,17 +1,18 @@
 package com.kamco.cd.kamcoback.postgres.repository.Inference;
 
 import com.kamco.cd.kamcoback.inference.dto.InferenceResultDto;
-import com.kamco.cd.kamcoback.inference.dto.InferenceResultDto.Dashboard;
-import com.kamco.cd.kamcoback.postgres.entity.MapSheetAnalDataGeomEntity;
-import com.kamco.cd.kamcoback.postgres.entity.MapSheetAnalEntity;
 import com.kamco.cd.kamcoback.postgres.entity.MapSheetAnalSttcEntity;
 import java.util.List;
 import java.util.Optional;
 import org.springframework.data.domain.Page;
 
 public interface InferenceResultRepositoryCustom {
-  Page<InferenceResultDto.AnalResList> getInferenceResultList(InferenceResultDto.SearchReq searchReq);
+  Page<InferenceResultDto.AnalResList> getInferenceResultList(
+      InferenceResultDto.SearchReq searchReq);
+
   Optional<InferenceResultDto.AnalResSummary> getInferenceResultSummary(Long id);
+
   List<MapSheetAnalSttcEntity> getInferenceResultDashboard(Long id);
+
   Page<InferenceResultDto.Geom> getInferenceGeomList(InferenceResultDto.SearchGeoReq searchGeoReq);
 }

src/main/java/com/kamco/cd/kamcoback/postgres/repository/Inference/InferenceResultRepositoryImpl.java

@@ -2,13 +2,13 @@ package com.kamco.cd.kamcoback.postgres.repository.Inference;
 
 import com.kamco.cd.kamcoback.inference.dto.InferenceResultDto;
 import com.kamco.cd.kamcoback.inference.dto.InferenceResultDto.SearchGeoReq;
-import com.kamco.cd.kamcoback.postgres.entity.MapSheetAnalDataGeomEntity;
 import com.kamco.cd.kamcoback.postgres.entity.MapSheetAnalSttcEntity;
 import com.kamco.cd.kamcoback.postgres.entity.QMapSheetAnalDataGeomEntity;
 import com.kamco.cd.kamcoback.postgres.entity.QMapSheetAnalEntity;
 import com.kamco.cd.kamcoback.postgres.entity.QMapSheetAnalSttcEntity;
 import com.kamco.cd.kamcoback.postgres.entity.QModelMngEntity;
 import com.kamco.cd.kamcoback.postgres.entity.QModelVerEntity;
+import com.querydsl.core.BooleanBuilder;
 import com.querydsl.core.types.Projections;
 import com.querydsl.core.types.dsl.Expressions;
 import com.querydsl.jpa.JPAExpressions;
@@ -21,7 +21,6 @@ import org.springframework.data.domain.Page;
 import org.springframework.data.domain.PageImpl;
 import org.springframework.data.domain.Pageable;
 import org.springframework.stereotype.Repository;
-import com.querydsl.core.BooleanBuilder;
 
 @Repository
 @RequiredArgsConstructor
@@ -31,18 +30,20 @@ public class InferenceResultRepositoryImpl implements InferenceResultRepositoryC
   private final QMapSheetAnalEntity mapSheetAnal = QMapSheetAnalEntity.mapSheetAnalEntity;
   private final QModelMngEntity tmm = QModelMngEntity.modelMngEntity;
   private final QModelVerEntity tmv = QModelVerEntity.modelVerEntity;
-  private final QMapSheetAnalSttcEntity mapSheetAnalSttc = QMapSheetAnalSttcEntity.mapSheetAnalSttcEntity;
+  private final QMapSheetAnalSttcEntity mapSheetAnalSttc =
-  private final QMapSheetAnalDataGeomEntity mapSheetAnalDataGeom = QMapSheetAnalDataGeomEntity.mapSheetAnalDataGeomEntity;
+      QMapSheetAnalSttcEntity.mapSheetAnalSttcEntity;
-
+  private final QMapSheetAnalDataGeomEntity mapSheetAnalDataGeom =
-
+      QMapSheetAnalDataGeomEntity.mapSheetAnalDataGeomEntity;
 
   /**
    * 분석결과 목록 조회
+   *
    * @param searchReq
    * @return
    */
   @Override
-  public Page<InferenceResultDto.AnalResList> getInferenceResultList(InferenceResultDto.SearchReq searchReq) {
+  public Page<InferenceResultDto.AnalResList> getInferenceResultList(
+      InferenceResultDto.SearchReq searchReq) {
     Pageable pageable = searchReq.toPageable();
 
     // "0000" 전체조회
@@ -56,8 +57,11 @@ public class InferenceResultRepositoryImpl implements InferenceResultRepositoryC
       builder.and(mapSheetAnal.analTitle.like("%" + searchReq.getTitle() + "%"));
     }
 
-    List<InferenceResultDto.AnalResList> content = queryFactory
+    List<InferenceResultDto.AnalResList> content =
-      .select(Projections.constructor(InferenceResultDto.AnalResList.class,
+        queryFactory
+            .select(
+                Projections.constructor(
+                    InferenceResultDto.AnalResList.class,
                     mapSheetAnal.id,
                     mapSheetAnal.analTitle,
                     mapSheetAnal.analMapSheet,
@@ -67,33 +71,25 @@ public class InferenceResultRepositoryImpl implements InferenceResultRepositoryC
                     mapSheetAnal.analSec,
                     mapSheetAnal.analPredSec,
                     mapSheetAnal.analState,
-        Expressions.stringTemplate("fn_code_name({0}, {1})", "0002", mapSheetAnal.analState),
+                    Expressions.stringTemplate(
-        mapSheetAnal.gukyuinUsed
+                        "fn_code_name({0}, {1})", "0002", mapSheetAnal.analState),
-      ))
+                    mapSheetAnal.gukyuinUsed))
             .from(mapSheetAnal)
-      .where(
+            .where(builder)
-        builder
-      )
             .offset(pageable.getOffset())
             .limit(pageable.getPageSize())
             .orderBy(mapSheetAnal.createdDttm.desc())
             .fetch();
 
-    long total = queryFactory
+    long total =
-      .select(mapSheetAnal.id)
+        queryFactory.select(mapSheetAnal.id).from(mapSheetAnal).where(builder).fetchCount();
-      .from(mapSheetAnal)
-      .where(
-        builder
-      )
-      .fetchCount();
 
     return new PageImpl<>(content, pageable, total);
-
-
   }
 
   /**
    * 분석결과 요약정보
+   *
    * @param id
    * @return
    */
@@ -101,13 +97,15 @@ public class InferenceResultRepositoryImpl implements InferenceResultRepositoryC
   public Optional<InferenceResultDto.AnalResSummary> getInferenceResultSummary(Long id) {
 
     // 1. 최신 버전 UID를 가져오는 서브쿼리
-    JPQLQuery<Long> latestVerUidSub = JPAExpressions
+    JPQLQuery<Long> latestVerUidSub =
-      .select(tmv.id.max())
+        JPAExpressions.select(tmv.id.max()).from(tmv).where(tmv.modelUid.eq(tmm.id));
-      .from(tmv)
-      .where(tmv.modelUid.eq(tmm.id));
 
-    Optional<InferenceResultDto.AnalResSummary> content = Optional.ofNullable(queryFactory
+    Optional<InferenceResultDto.AnalResSummary> content =
-      .select(Projections.constructor(InferenceResultDto.AnalResSummary.class,
+        Optional.ofNullable(
+            queryFactory
+                .select(
+                    Projections.constructor(
+                        InferenceResultDto.AnalResSummary.class,
                         mapSheetAnal.id,
                         tmm.modelNm.concat(" ").concat(tmv.modelVer).as("modelInfo"),
                         mapSheetAnal.targetYyyy,
@@ -121,22 +119,21 @@ public class InferenceResultRepositoryImpl implements InferenceResultRepositoryC
                         mapSheetAnal.detectingCnt,
                         mapSheetAnal.accuracy,
                         mapSheetAnal.analState,
-        Expressions.stringTemplate("fn_code_name({0}, {1})", "0002", mapSheetAnal.analState)
+                        Expressions.stringTemplate(
-      ))
+                            "fn_code_name({0}, {1})", "0002", mapSheetAnal.analState)))
                 .from(mapSheetAnal)
-      .leftJoin(tmm).on(mapSheetAnal.modelUid.eq(tmm.id))
+                .leftJoin(tmm)
-      .leftJoin(tmv).on(
+                .on(mapSheetAnal.modelUid.eq(tmm.id))
-        tmv.modelUid.eq(tmm.id)
+                .leftJoin(tmv)
-          .and(tmv.id.eq(latestVerUidSub))
+                .on(tmv.modelUid.eq(tmm.id).and(tmv.id.eq(latestVerUidSub)))
-      )
                 .where(mapSheetAnal.id.eq(id))
-      .fetchOne()
+                .fetchOne());
-    );
     return content;
   }
 
   /**
    * 분석결과 상세 대시보드 조회
+   *
    * @param id
    * @return
    */
@@ -151,6 +148,7 @@ public class InferenceResultRepositoryImpl implements InferenceResultRepositoryC
 
   /**
    * 분석결과 상세 목록
+   *
    * @param searchGeoReq
    * @return
    */
@@ -162,7 +160,6 @@ public class InferenceResultRepositoryImpl implements InferenceResultRepositoryC
     // 기준년도 분류
     if (searchGeoReq.getTargetClass() != null && !searchGeoReq.getTargetClass().equals("")) {
       builder.and(mapSheetAnalDataGeom.classAfterCd.eq(searchGeoReq.getTargetClass()));
-
     }
 
     // 비교년도 분류
@@ -176,28 +173,31 @@ public class InferenceResultRepositoryImpl implements InferenceResultRepositoryC
       builder.and(mapSheetAnalDataGeom.mapSheetNum.in(mapSheetNum));
     }
 
-    List<InferenceResultDto.Geom> content = queryFactory
+    List<InferenceResultDto.Geom> content =
-      .select(Projections.constructor(InferenceResultDto.Geom.class,
+        queryFactory
+            .select(
+                Projections.constructor(
+                    InferenceResultDto.Geom.class,
                     mapSheetAnalDataGeom.compareYyyy,
                     mapSheetAnalDataGeom.targetYyyy,
                     mapSheetAnalDataGeom.classBeforeCd,
-        Expressions.stringTemplate("fn_code_name({0}, {1})", "0000", mapSheetAnalDataGeom.classBeforeCd),
+                    Expressions.stringTemplate(
+                        "fn_code_name({0}, {1})", "0000", mapSheetAnalDataGeom.classBeforeCd),
                     mapSheetAnalDataGeom.classBeforeProb,
                     mapSheetAnalDataGeom.classAfterCd,
-        Expressions.stringTemplate("fn_code_name({0}, {1})", "0000", mapSheetAnalDataGeom.classAfterCd),
+                    Expressions.stringTemplate(
+                        "fn_code_name({0}, {1})", "0000", mapSheetAnalDataGeom.classAfterCd),
                     mapSheetAnalDataGeom.classAfterProb,
                     mapSheetAnalDataGeom.mapSheetNum))
             .from(mapSheetAnalDataGeom)
             .where(builder)
-      .fetch()
+            .fetch();
-      ;
 
-    long total = queryFactory
+    long total =
+        queryFactory
             .select(mapSheetAnalDataGeom.id)
             .from(mapSheetAnalDataGeom)
-      .where(
+            .where(builder)
-        builder
-      )
             .fetchCount();
 
     return new PageImpl<>(content, pageable, total);

src/main/java/com/kamco/cd/kamcoback/postgres/repository/MapSheetLearnDataGeomRepository.java

@@ -1,36 +1,27 @@
 package com.kamco.cd.kamcoback.postgres.repository;
 
 import com.kamco.cd.kamcoback.postgres.entity.MapSheetLearnDataGeomEntity;
+import java.util.List;
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.stereotype.Repository;
 
-import java.util.List;
-
 @Repository
-public interface MapSheetLearnDataGeomRepository extends JpaRepository<MapSheetLearnDataGeomEntity, Long> {
+public interface MapSheetLearnDataGeomRepository
+    extends JpaRepository<MapSheetLearnDataGeomEntity, Long> {
 
-  /**
+  /** 데이터 UID로 지오메트리 정보 조회 */
-   * 데이터 UID로 지오메트리 정보 조회
-   */
   List<MapSheetLearnDataGeomEntity> findByDataUid(Long dataUid);
 
-  /**
+  /** 도엽 번호로 지오메트리 정보 조회 */
-   * 도엽 번호로 지오메트리 정보 조회
-   */
   List<MapSheetLearnDataGeomEntity> findByMapSheetNum(Long mapSheetNum);
 
-  /**
+  /** 연도 범위로 지오메트리 정보 조회 */
-   * 연도 범위로 지오메트리 정보 조회
+  List<MapSheetLearnDataGeomEntity> findByBeforeYyyyAndAfterYyyy(
-   */
+      Integer beforeYyyy, Integer afterYyyy);
-  List<MapSheetLearnDataGeomEntity> findByBeforeYyyyAndAfterYyyy(Integer beforeYyyy, Integer afterYyyy);
 
-  /**
+  /** 지오메트리 타입별 조회 */
-   * 지오메트리 타입별 조회
-   */
   List<MapSheetLearnDataGeomEntity> findByGeoType(String geoType);
 
-  /**
+  /** 데이터 UID로 기존 지오메트리 데이터 삭제 (재생성 전에 사용) */
-   * 데이터 UID로 기존 지오메트리 데이터 삭제 (재생성 전에 사용)
-   */
   void deleteByDataUid(Long dataUid);
 }

src/main/java/com/kamco/cd/kamcoback/postgres/repository/MapSheetLearnDataRepository.java

@@ -1,47 +1,32 @@
 package com.kamco.cd.kamcoback.postgres.repository;
 
 import com.kamco.cd.kamcoback.postgres.entity.MapSheetLearnDataEntity;
-import org.springframework.data.jpa.repository.JpaRepository;
-import org.springframework.stereotype.Repository;
-
 import java.util.List;
 import java.util.Optional;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
 
 @Repository
 public interface MapSheetLearnDataRepository extends JpaRepository<MapSheetLearnDataEntity, Long> {
 
-  /**
+  /** 데이터 이름으로 조회 */
-   * 데이터 이름으로 조회
-   */
   Optional<MapSheetLearnDataEntity> findByDataName(String dataName);
 
-  /**
+  /** 데이터 경로로 조회 */
-   * 데이터 경로로 조회
-   */
   Optional<MapSheetLearnDataEntity> findByDataPath(String dataPath);
 
-  /**
+  /** 처리 상태별 조회 */
-   * 처리 상태별 조회
-   */
   List<MapSheetLearnDataEntity> findByDataState(String dataState);
 
-  /**
+  /** 데이터 타입별 조회 */
-   * 데이터 타입별 조회
-   */
   List<MapSheetLearnDataEntity> findByDataType(String dataType);
 
-  /**
+  /** 분석 상태별 조회 */
-   * 분석 상태별 조회
-   */
   List<MapSheetLearnDataEntity> findByAnalState(String analState);
 
-  /**
+  /** 분석 상태별 개수 조회 */
-   * 분석 상태별 개수 조회
-   */
   long countByAnalState(String analState);
 
-  /**
+  /** 처리되지 않은 데이터 조회 (data_state가 'PENDING' 또는 null인 것들) */
-   * 처리되지 않은 데이터 조회 (data_state가 'PENDING' 또는 null인 것들)
-   */
   List<MapSheetLearnDataEntity> findByDataStateIsNullOrDataState(String dataState);
 }

src/main/java/com/kamco/cd/kamcoback/postgres/repository/changedetection/ChangeDetectionRepository.java

@@ -3,4 +3,5 @@ package com.kamco.cd.kamcoback.postgres.repository.changedetection;
 import com.kamco.cd.kamcoback.postgres.entity.MapSheetAnalDataGeomEntity;
 import org.springframework.data.jpa.repository.JpaRepository;
 
-public interface ChangeDetectionRepository extends JpaRepository<MapSheetAnalDataGeomEntity, Long>, ChangeDetectionRepositoryCustom {}
+public interface ChangeDetectionRepository
+    extends JpaRepository<MapSheetAnalDataGeomEntity, Long>, ChangeDetectionRepositoryCustom {}

src/main/java/com/kamco/cd/kamcoback/postgres/repository/changedetection/ChangeDetectionRepositoryCustom.java

@@ -1,9 +1,6 @@
 package com.kamco.cd.kamcoback.postgres.repository.changedetection;
 
-import com.kamco.cd.kamcoback.config.api.ApiResponseDto;
-
 public interface ChangeDetectionRepositoryCustom {
 
   String getPolygonToPoint();
-
 }

src/main/java/com/kamco/cd/kamcoback/postgres/repository/changedetection/ChangeDetectionRepositoryImpl.java

@@ -1,12 +1,11 @@
 package com.kamco.cd.kamcoback.postgres.repository.changedetection;
 
+import static com.kamco.cd.kamcoback.postgres.entity.QMapSheetAnalDataGeomEntity.mapSheetAnalDataGeomEntity;
+
 import com.kamco.cd.kamcoback.postgres.entity.MapSheetAnalDataGeomEntity;
 import com.querydsl.jpa.impl.JPAQueryFactory;
-import org.springframework.data.jpa.repository.support.QuerydslRepositorySupport;
-
 import java.util.List;
-
+import org.springframework.data.jpa.repository.support.QuerydslRepositorySupport;
-import static com.kamco.cd.kamcoback.postgres.entity.QMapSheetAnalDataGeomEntity.mapSheetAnalDataGeomEntity;
 
 public class ChangeDetectionRepositoryImpl extends QuerydslRepositorySupport
     implements ChangeDetectionRepositoryCustom {

src/main/java/com/kamco/cd/kamcoback/postgres/repository/code/CommonCodeRepositoryImpl.java

@@ -88,12 +88,12 @@ public class CommonCodeRepositoryImpl extends QuerydslRepositorySupport
     QCommonCodeEntity parent = QCommonCodeEntity.commonCodeEntity;
     QCommonCodeEntity child = new QCommonCodeEntity("child");
 
-    String result = queryFactory
+    String result =
+        queryFactory
             .select(child.name)
             .from(child)
             .join(child.parent, parent)
-      .where(parent.code.eq(parentCodeCd)
+            .where(parent.code.eq(parentCodeCd).and(child.code.eq(childCodeCd)))
-        .and(child.code.eq(childCodeCd)))
             .fetchFirst(); // 단일 결과만
 
     return Optional.ofNullable(result);

src/main/java/com/kamco/cd/kamcoback/postgres/repository/log/AuditLogRepositoryCustom.java

@@ -18,8 +18,7 @@ public interface AuditLogRepositoryCustom {
   Page<AuditLogDto.DailyDetail> findLogByDailyResult(
       AuditLogDto.searchReq searchReq, LocalDate logDate);
 
-  Page<AuditLogDto.MenuDetail> findLogByMenuResult(
+  Page<AuditLogDto.MenuDetail> findLogByMenuResult(AuditLogDto.searchReq searchReq, String menuId);
-      AuditLogDto.searchReq searchReq, String menuId);
 
   Page<AuditLogDto.UserDetail> findLogByAccountResult(
       AuditLogDto.searchReq searchReq, Long accountId);

src/main/java/com/kamco/cd/kamcoback/postgres/repository/log/AuditLogRepositoryImpl.java

@@ -52,9 +52,7 @@ public class AuditLogRepositoryImpl extends QuerydslRepositorySupport
                     printCount().as("printCount"),
                     downloadCount().as("downloadCount"),
                     auditLogEntity.count().as("totalCount"),
-                    groupDateTime.as("baseDate")
+                    groupDateTime.as("baseDate")))
-                  )
-            )
             .from(auditLogEntity)
             .where(eventEndedAtBetween(startDate, endDate))
             .groupBy(groupDateTime)
@@ -242,7 +240,9 @@ public class AuditLogRepositoryImpl extends QuerydslRepositorySupport
                 Projections.constructor(
                     AuditLogDto.MenuDetail.class,
                     auditLogEntity.id.as("logId"),
-                    Expressions.stringTemplate("to_char({0}, 'YYYY-MM-DD')", auditLogEntity.createdDate).as("logDateTime"),     //??
+                    Expressions.stringTemplate(
+                            "to_char({0}, 'YYYY-MM-DD')", auditLogEntity.createdDate)
+                        .as("logDateTime"), // ??
                     userEntity.userNm.as("userName"),
                     userEntity.userId.as("loginId"),
                     auditLogEntity.eventType.as("eventType"),
@@ -307,7 +307,9 @@ public class AuditLogRepositoryImpl extends QuerydslRepositorySupport
                 Projections.constructor(
                     AuditLogDto.UserDetail.class,
                     auditLogEntity.id.as("logId"),
-                    Expressions.stringTemplate("to_char({0}, 'YYYY-MM-DD')", auditLogEntity.createdDate).as("logDateTime"),
+                    Expressions.stringTemplate(
+                            "to_char({0}, 'YYYY-MM-DD')", auditLogEntity.createdDate)
+                        .as("logDateTime"),
                     menuEntity.menuNm.as("menuName"),
                     auditLogEntity.eventType.as("eventType"),
                     Projections.constructor(

src/main/java/com/kamco/cd/kamcoback/postgres/repository/model/ModelMngRepository.java

@@ -3,4 +3,5 @@ package com.kamco.cd.kamcoback.postgres.repository.model;
 import com.kamco.cd.kamcoback.postgres.entity.ModelMngEntity;
 import org.springframework.data.jpa.repository.JpaRepository;
 
-public interface ModelMngRepository extends JpaRepository<ModelMngEntity, Long>, ModelMngRepositoryCustom {}
+public interface ModelMngRepository
+    extends JpaRepository<ModelMngEntity, Long>, ModelMngRepositoryCustom {}

src/main/java/com/kamco/cd/kamcoback/postgres/repository/model/ModelMngRepositoryCustom.java

@@ -2,11 +2,10 @@ package com.kamco.cd.kamcoback.postgres.repository.model;
 
 import com.kamco.cd.kamcoback.model.dto.ModelMngDto;
 import com.kamco.cd.kamcoback.postgres.entity.ModelMngEntity;
-import org.springframework.data.domain.Page;
-
 import java.time.LocalDate;
 import java.util.List;
 import java.util.Optional;
+import org.springframework.data.domain.Page;
 
 public interface ModelMngRepositoryCustom {
 
@@ -14,5 +13,6 @@ public interface ModelMngRepositoryCustom {
 
   Optional<ModelMngDto.FinalModelDto> getFinalModelInfo();
 
-  Page<ModelMngDto.ModelRegHistory> getRegHistoryList(ModelMngDto.searchReq searchReq, LocalDate startDate, LocalDate endDate, String searchVal);
+  Page<ModelMngDto.ModelRegHistory> getRegHistoryList(
+      ModelMngDto.searchReq searchReq, LocalDate startDate, LocalDate endDate, String searchVal);
 }

src/main/java/com/kamco/cd/kamcoback/postgres/repository/model/ModelMngRepositoryImpl.java

@@ -1,5 +1,9 @@
 package com.kamco.cd.kamcoback.postgres.repository.model;
 
+import static com.kamco.cd.kamcoback.postgres.entity.QModelDeployHstEntity.modelDeployHstEntity;
+import static com.kamco.cd.kamcoback.postgres.entity.QModelMngEntity.modelMngEntity;
+import static com.kamco.cd.kamcoback.postgres.entity.QModelVerEntity.modelVerEntity;
+
 import com.kamco.cd.kamcoback.model.dto.ModelMngDto;
 import com.kamco.cd.kamcoback.postgres.QuerydslOrderUtil;
 import com.kamco.cd.kamcoback.postgres.entity.ModelMngEntity;
@@ -10,21 +14,16 @@ import com.querydsl.core.types.dsl.Expressions;
 import com.querydsl.core.types.dsl.StringExpression;
 import com.querydsl.jpa.impl.JPAQueryFactory;
 import io.micrometer.common.util.StringUtils;
-import org.springframework.data.domain.Page;
-import org.springframework.data.domain.PageImpl;
-import org.springframework.data.domain.Pageable;
-import org.springframework.data.jpa.repository.support.QuerydslRepositorySupport;
-
 import java.time.LocalDate;
 import java.time.LocalDateTime;
 import java.time.ZonedDateTime;
 import java.util.List;
 import java.util.Objects;
 import java.util.Optional;
-
+import org.springframework.data.domain.Page;
-import static com.kamco.cd.kamcoback.postgres.entity.QModelDeployHstEntity.modelDeployHstEntity;
+import org.springframework.data.domain.PageImpl;
-import static com.kamco.cd.kamcoback.postgres.entity.QModelMngEntity.modelMngEntity;
+import org.springframework.data.domain.Pageable;
-import static com.kamco.cd.kamcoback.postgres.entity.QModelVerEntity.modelVerEntity;
+import org.springframework.data.jpa.repository.support.QuerydslRepositorySupport;
 
 public class ModelMngRepositoryImpl extends QuerydslRepositorySupport
     implements ModelMngRepositoryCustom {
@@ -39,10 +38,7 @@ public class ModelMngRepositoryImpl extends QuerydslRepositorySupport
 
   @Override
   public List<ModelMngEntity> findModelMngAll() {
-    return queryFactory
+    return queryFactory.selectFrom(modelMngEntity).orderBy(modelMngEntity.id.desc()).fetch();
-            .selectFrom(modelMngEntity)
-            .orderBy(modelMngEntity.id.desc())
-            .fetch();
   }
 
   @Override
@@ -60,9 +56,7 @@ public class ModelMngRepositoryImpl extends QuerydslRepositorySupport
                 modelVerEntity.modelState,
                 modelVerEntity.qualityProb,
                 modelVerEntity.deployState,
-            modelVerEntity.modelPath
+                modelVerEntity.modelPath))
-          )
-        )
         .from(modelMngEntity)
         .innerJoin(modelVerEntity)
         .on(modelMngEntity.id.eq(modelVerEntity.modelUid))
@@ -73,7 +67,8 @@ public class ModelMngRepositoryImpl extends QuerydslRepositorySupport
   }
 
   @Override
-  public Page<ModelMngDto.ModelRegHistory> getRegHistoryList(ModelMngDto.searchReq searchReq, LocalDate startDate, LocalDate endDate, String searchVal) {
+  public Page<ModelMngDto.ModelRegHistory> getRegHistoryList(
+      ModelMngDto.searchReq searchReq, LocalDate startDate, LocalDate endDate, String searchVal) {
 
     Pageable pageable = searchReq.toPageable();
     List<ModelMngDto.ModelRegHistory> foundContent =
@@ -84,27 +79,30 @@ public class ModelMngRepositoryImpl extends QuerydslRepositorySupport
                     modelMngEntity.modelNm,
                     modelMngEntity.modelCate,
                     modelVerEntity.modelVer,
-                Expressions.stringTemplate("to_char({0}, 'YYYY-MM-DD')", modelVerEntity.createdDate).as("createdDttm"),
+                    Expressions.stringTemplate(
+                            "to_char({0}, 'YYYY-MM-DD')", modelVerEntity.createdDate)
+                        .as("createdDttm"),
                     modelVerEntity.usedState,
                     modelVerEntity.deployState,
-                Expressions.stringTemplate("to_char({0}, 'YYYY-MM-DD')", modelDeployHstEntity.deployDttm).as("deployDttm")
+                    Expressions.stringTemplate(
-              )
+                            "to_char({0}, 'YYYY-MM-DD')", modelDeployHstEntity.deployDttm)
-            )
+                        .as("deployDttm")))
             .from(modelMngEntity)
             .innerJoin(modelVerEntity)
             .on(modelMngEntity.id.eq(modelVerEntity.modelUid))
             .leftJoin(modelDeployHstEntity)
             .on(
-              modelVerEntity.id.eq(modelDeployHstEntity.modelVerUid)
+                modelVerEntity
+                    .id
+                    .eq(modelDeployHstEntity.modelVerUid)
                     .and(modelDeployHstEntity.serverId.eq(1L)) // 1건만 조회해야 하기에 1번 서버만 조회하기
                 )
-            .where(
+            .where(eventEndedAtBetween(startDate, endDate), searchModelVerLike(searchVal))
-              eventEndedAtBetween(startDate, endDate),
-              searchModelVerLike(searchVal)
-            )
             .offset(pageable.getOffset())
             .limit(pageable.getPageSize())
-            .orderBy(QuerydslOrderUtil.getOrderSpecifiers(pageable, ModelVerEntity.class, "modelVerEntity"))
+            .orderBy(
+                QuerydslOrderUtil.getOrderSpecifiers(
+                    pageable, ModelVerEntity.class, "modelVerEntity"))
             .fetch();
 
     Long countQuery =
@@ -113,10 +111,7 @@ public class ModelMngRepositoryImpl extends QuerydslRepositorySupport
             .from(modelMngEntity)
             .innerJoin(modelVerEntity)
             .on(modelMngEntity.id.eq(modelVerEntity.modelUid))
-        .where(
+            .where(eventEndedAtBetween(startDate, endDate), searchModelVerLike(searchVal))
-          eventEndedAtBetween(startDate, endDate),
-          searchModelVerLike(searchVal)
-        )
             .fetchOne();
 
     return new PageImpl<>(foundContent, pageable, countQuery);
@@ -128,7 +123,9 @@ public class ModelMngRepositoryImpl extends QuerydslRepositorySupport
     }
     LocalDateTime startDateTime = startDate.atStartOfDay();
     LocalDateTime endDateTime = endDate.plusDays(1).atStartOfDay();
-    return modelMngEntity.createdDate.goe(ZonedDateTime.from(startDateTime))
+    return modelMngEntity
+        .createdDate
+        .goe(ZonedDateTime.from(startDateTime))
         .and(modelMngEntity.modifiedDate.lt(ZonedDateTime.from(endDateTime)));
   }
 

src/main/java/com/kamco/cd/kamcoback/postgres/repository/model/ModelVerRepository.java

@@ -1,7 +1,7 @@
 package com.kamco.cd.kamcoback.postgres.repository.model;
 
-import com.kamco.cd.kamcoback.postgres.entity.ModelMngEntity;
 import com.kamco.cd.kamcoback.postgres.entity.ModelVerEntity;
 import org.springframework.data.jpa.repository.JpaRepository;
 
-public interface ModelVerRepository extends JpaRepository<ModelVerEntity, Long>, ModelVerRepositoryCustom {}
+public interface ModelVerRepository
+    extends JpaRepository<ModelVerEntity, Long>, ModelVerRepositoryCustom {}

src/main/java/com/kamco/cd/kamcoback/postgres/repository/model/ModelVerRepositoryCustom.java

@@ -1,10 +1,6 @@
 package com.kamco.cd.kamcoback.postgres.repository.model;
 
-import com.kamco.cd.kamcoback.model.dto.ModelMngDto;
-import com.kamco.cd.kamcoback.postgres.entity.ModelMngEntity;
 import com.kamco.cd.kamcoback.postgres.entity.ModelVerEntity;
-
-import java.util.List;
 import java.util.Optional;
 
 public interface ModelVerRepositoryCustom {

src/main/java/com/kamco/cd/kamcoback/postgres/repository/model/ModelVerRepositoryImpl.java

@@ -1,15 +1,14 @@
 package com.kamco.cd.kamcoback.postgres.repository.model;
 
+import static com.kamco.cd.kamcoback.postgres.entity.QModelVerEntity.modelVerEntity;
+
 import com.kamco.cd.kamcoback.postgres.entity.ModelMngEntity;
 import com.kamco.cd.kamcoback.postgres.entity.ModelVerEntity;
 import com.querydsl.core.types.dsl.Expressions;
 import com.querydsl.core.types.dsl.StringExpression;
 import com.querydsl.jpa.impl.JPAQueryFactory;
-import org.springframework.data.jpa.repository.support.QuerydslRepositorySupport;
-
 import java.util.Optional;
-
+import org.springframework.data.jpa.repository.support.QuerydslRepositorySupport;
-import static com.kamco.cd.kamcoback.postgres.entity.QModelVerEntity.modelVerEntity;
 
 public class ModelVerRepositoryImpl extends QuerydslRepositorySupport
     implements ModelVerRepositoryCustom {
@@ -24,10 +23,10 @@ public class ModelVerRepositoryImpl extends QuerydslRepositorySupport
 
   @Override
   public Optional<ModelVerEntity> findModelVerById(Long id) {
-    return Optional.ofNullable(queryFactory
+    return Optional.ofNullable(
+        queryFactory
             .selectFrom(modelVerEntity)
             .where(modelVerEntity.id.eq(id)) // model_ver_uid
-        .fetchOne()
+            .fetchOne());
-    );
   }
 }