MVPTeam/test
6
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

./gradlew :spotlessApply 실행

Browse Source
This commit is contained in:
teddy
2025-11-26 10:13:11 +09:00
parent 51a9f18af2
commit e96cff6ea5
54 changed files with 2095 additions and 2214 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
src/main/java/com/kamco/cd/kamcoback/changedetection/ChangeDetectionApiController.java
View File

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

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

@@ -2,9 +2,4 @@ package com.kamco.cd.kamcoback.changedetection.dto;
import org.locationtech.jts.geom.Geometry; 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
) {}

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

@@ -1,13 +1,11 @@
package com.kamco.cd.kamcoback.changedetection.service; package com.kamco.cd.kamcoback.changedetection.service;
import com.kamco.cd.kamcoback.changedetection.dto.ChangeDetectionDto; 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 com.kamco.cd.kamcoback.postgres.core.ChangeDetectionCoreService;
import java.util.List;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import java.util.List;
@Service @Service
@RequiredArgsConstructor @RequiredArgsConstructor
public class ChangeDetectionService { public class ChangeDetectionService {

2
src/main/java/com/kamco/cd/kamcoback/config/GlobalExceptionHandler.java
View File

@@ -291,7 +291,7 @@ public class GlobalExceptionHandler {
// TODO : stackTrace limit 20줄? 확인 필요 // TODO : stackTrace limit 20줄? 확인 필요
String stackTraceStr = String stackTraceStr =
Arrays.stream(stackTrace) Arrays.stream(stackTrace)
// .limit(20) // .limit(20)
.map(StackTraceElement::toString) .map(StackTraceElement::toString)
.collect(Collectors.joining("\n")) .collect(Collectors.joining("\n"))
.substring(0, Math.min(stackTrace.length, 255)); .substring(0, Math.min(stackTrace.length, 255));

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

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

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

@@ -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.entity.MapSheetLearnDataGeomEntity;
import com.kamco.cd.kamcoback.postgres.repository.MapSheetLearnDataGeomRepository; import com.kamco.cd.kamcoback.postgres.repository.MapSheetLearnDataGeomRepository;
import com.kamco.cd.kamcoback.postgres.repository.MapSheetLearnDataRepository; 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.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j; import lombok.extern.slf4j.Slf4j;
import org.springframework.data.domain.PageRequest; import org.springframework.data.domain.PageRequest;
import org.springframework.http.ResponseEntity; import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*; 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 @Slf4j
@RestController @RestController
@RequestMapping("/api/geojson/data") @RequestMapping("/api/geojson/data")
@@ -27,9 +24,7 @@ public class GeoJsonDataController {
private final MapSheetLearnDataRepository mapSheetLearnDataRepository; private final MapSheetLearnDataRepository mapSheetLearnDataRepository;
private final MapSheetLearnDataGeomRepository mapSheetLearnDataGeomRepository; private final MapSheetLearnDataGeomRepository mapSheetLearnDataGeomRepository;
/** /** 학습 데이터 목록 조회 */
* 학습 데이터 목록 조회
*/
@GetMapping("/learn-data") @GetMapping("/learn-data")
public ResponseEntity<Map<String, Object>> getLearnDataList( public ResponseEntity<Map<String, Object>> getLearnDataList(
@RequestParam(defaultValue = "0") int page, @RequestParam(defaultValue = "0") int page,
@@ -62,15 +57,12 @@ public class GeoJsonDataController {
} }
} }
/** /** 특정 학습 데이터 상세 조회 */
* 특정 학습 데이터 상세 조회
*/
@GetMapping("/learn-data/{id}") @GetMapping("/learn-data/{id}")
public ResponseEntity<Map<String, Object>> getLearnDataDetail(@PathVariable Long id) { public ResponseEntity<Map<String, Object>> getLearnDataDetail(@PathVariable Long id) {
try { try {
if (id == null) { 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); Optional<MapSheetLearnDataEntity> learnDataOpt = mapSheetLearnDataRepository.findById(id);
@@ -80,7 +72,8 @@ public class GeoJsonDataController {
} }
MapSheetLearnDataEntity learnData = learnDataOpt.get(); MapSheetLearnDataEntity learnData = learnDataOpt.get();
List<MapSheetLearnDataGeomEntity> geometryList = mapSheetLearnDataGeomRepository.findByDataUid(id); List<MapSheetLearnDataGeomEntity> geometryList =
mapSheetLearnDataGeomRepository.findByDataUid(id);
Map<String, Object> response = new HashMap<>(); Map<String, Object> response = new HashMap<>();
response.put("learnData", learnData); response.put("learnData", learnData);
@@ -95,9 +88,7 @@ public class GeoJsonDataController {
} }
} }
/** /** Geometry 데이터 목록 조회 */
* Geometry 데이터 목록 조회
*/
@GetMapping("/geometry") @GetMapping("/geometry")
public ResponseEntity<Map<String, Object>> getGeometryDataList( public ResponseEntity<Map<String, Object>> getGeometryDataList(
@RequestParam(defaultValue = "0") int page, @RequestParam(defaultValue = "0") int page,
@@ -130,19 +121,21 @@ public class GeoJsonDataController {
} }
} }
/** /** 시스템 통계 정보 조회 */
* 시스템 통계 정보 조회
*/
@GetMapping("/statistics") @GetMapping("/statistics")
public ResponseEntity<Map<String, Object>> getStatistics() { public ResponseEntity<Map<String, Object>> getStatistics() {
try { try {
long totalLearnData = mapSheetLearnDataRepository.count(); long totalLearnData = mapSheetLearnDataRepository.count();
long totalGeometryData = mapSheetLearnDataGeomRepository.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<>(); Map<String, Object> statistics = new HashMap<>();
statistics.put("totalLearnData", totalLearnData); statistics.put("totalLearnData", totalLearnData);
@@ -160,10 +153,8 @@ public class GeoJsonDataController {
statistics.put("completionRate", 0.0); 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) { } catch (Exception e) {
log.error("통계 정보 조회 실패", e); log.error("통계 정보 조회 실패", e);
return ResponseEntity.internalServerError() return ResponseEntity.internalServerError()
@@ -171,9 +162,7 @@ public class GeoJsonDataController {
} }
} }
/** /** 데이터 상태별 카운트 조회 */
* 데이터 상태별 카운트 조회
*/
@GetMapping("/status-counts") @GetMapping("/status-counts")
public ResponseEntity<Map<String, Object>> getStatusCounts() { public ResponseEntity<Map<String, Object>> getStatusCounts() {
try { try {
@@ -181,19 +170,25 @@ public class GeoJsonDataController {
Map<String, Long> analStateCounts = new HashMap<>(); 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, "dataStateCounts", dataStateCounts,
"analStateCounts", analStateCounts, "analStateCounts", analStateCounts,
"timestamp", java.time.Instant.now() "timestamp", java.time.Instant.now()));
));
} catch (Exception e) { } catch (Exception e) {
log.error("상태별 카운트 조회 실패", e); log.error("상태별 카운트 조회 실패", e);
return ResponseEntity.internalServerError() return ResponseEntity.internalServerError()

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

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

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

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

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

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

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

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

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

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

76
src/main/java/com/kamco/cd/kamcoback/inference/InferenceResultApiController.java
View File

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

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

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

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

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

28
src/main/java/com/kamco/cd/kamcoback/log/AuditLogApiController.java
View File

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

1
src/main/java/com/kamco/cd/kamcoback/log/ErrorLogApiController.java
View File

@@ -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.ErrorLogDto;
import com.kamco.cd.kamcoback.log.dto.EventType; import com.kamco.cd.kamcoback.log.dto.EventType;
import com.kamco.cd.kamcoback.log.service.ErrorLogService; 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.Operation;
import io.swagger.v3.oas.annotations.tags.Tag; import io.swagger.v3.oas.annotations.tags.Tag;
import java.time.LocalDate; import java.time.LocalDate;

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

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

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

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

21
src/main/java/com/kamco/cd/kamcoback/model/ModelMngApiController.java
View File

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

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

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

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

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

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

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

10
src/main/java/com/kamco/cd/kamcoback/postgres/QuerydslOrderUtil.java
View File

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

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

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

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

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

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

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

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

@@ -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.ModelMngRepository;
import com.kamco.cd.kamcoback.postgres.repository.model.ModelVerRepository; import com.kamco.cd.kamcoback.postgres.repository.model.ModelVerRepository;
import jakarta.persistence.EntityNotFoundException; import jakarta.persistence.EntityNotFoundException;
import lombok.RequiredArgsConstructor;
import org.springframework.data.domain.Page;
import org.springframework.stereotype.Service;
import java.time.LocalDate; import java.time.LocalDate;
import java.util.List; import java.util.List;
import java.util.Optional; import java.util.Optional;
import lombok.RequiredArgsConstructor;
import org.springframework.data.domain.Page;
import org.springframework.stereotype.Service;
@Service @Service
@RequiredArgsConstructor @RequiredArgsConstructor
@@ -26,37 +25,57 @@ public class ModelMngCoreService {
return modelMngRepository.findModelMngAll().stream().map(ModelMngEntity::toDto).toList(); return modelMngRepository.findModelMngAll().stream().map(ModelMngEntity::toDto).toList();
} }
public Optional<ModelMngDto.FinalModelDto> getFinalModelInfo(){ public Optional<ModelMngDto.FinalModelDto> getFinalModelInfo() {
return modelMngRepository.getFinalModelInfo(); return modelMngRepository.getFinalModelInfo();
} }
public ModelVerDto.Basic save(ModelMngDto.AddReq addReq) { 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); 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(); return modelVerRepository.save(modelVerEntity).toDto();
} }
public Long update(Long id, ModelMngDto.AddReq addReq) { public Long update(Long id, ModelMngDto.AddReq addReq) {
//조회 // 조회
ModelVerEntity existData = modelVerRepository.findModelVerById(id) ModelVerEntity existData =
.orElseThrow(EntityNotFoundException::new); //데이터 없는 경우 exception modelVerRepository
.findModelVerById(id)
.orElseThrow(EntityNotFoundException::new); // 데이터 없는 경우 exception
existData.update(addReq); existData.update(addReq);
//TODO: 추후 수정 단계에서 도커파일 업로드하면 버전 업데이트 하는 로직 필요 // TODO: 추후 수정 단계에서 도커파일 업로드하면 버전 업데이트 하는 로직 필요
return existData.getId(); return existData.getId();
} }
public Long delete(Long id) { public Long delete(Long id) {
//조회 // 조회
ModelVerEntity verEntity = modelVerRepository.findModelVerById(id) ModelVerEntity verEntity =
modelVerRepository
.findModelVerById(id)
.orElseThrow(() -> new EntityNotFoundException("버전 id 에 대한 정보를 찾을 수 없습니다. id : " + id)); .orElseThrow(() -> new EntityNotFoundException("버전 id 에 대한 정보를 찾을 수 없습니다. id : " + id));
//usedState가 USED 이거나 이미 삭제된 상태이면 삭제 불가 // usedState가 USED 이거나 이미 삭제된 상태이면 삭제 불가
if (verEntity.getUsedState().equals("USED") || verEntity.isDeleted().equals(true)) { if (verEntity.getUsedState().equals("USED") || verEntity.isDeleted().equals(true)) {
throw new IllegalStateException("해당 모델이 사용중이라 삭제 불가"); //TODO: 추후 규칙 정의되면 수정 필요 throw new IllegalStateException("해당 모델이 사용중이라 삭제 불가"); // TODO: 추후 규칙 정의되면 수정 필요
} }
// id 코드 deleted = true 업데이트 // id 코드 deleted = true 업데이트
@@ -64,7 +83,8 @@ public class ModelMngCoreService {
return verEntity.getId(); 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); return modelMngRepository.getRegHistoryList(searchReq, startDate, endDate, searchVal);
} }
} }

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

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

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

@@ -2,12 +2,11 @@ package com.kamco.cd.kamcoback.postgres.entity;
import jakarta.persistence.*; import jakarta.persistence.*;
import jakarta.validation.constraints.Size; import jakarta.validation.constraints.Size;
import java.time.ZonedDateTime;
import lombok.Getter; import lombok.Getter;
import lombok.Setter; import lombok.Setter;
import org.locationtech.jts.geom.Geometry; import org.locationtech.jts.geom.Geometry;
import java.time.ZonedDateTime;
@Getter @Getter
@Setter @Setter
@Entity @Entity
@@ -15,8 +14,13 @@ import java.time.ZonedDateTime;
public class MapSheetAnalDataGeomEntity { public class MapSheetAnalDataGeomEntity {
@Id @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) @Column(name = "geo_uid", nullable = false)
private Long id; private Long id;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -19,7 +19,10 @@ public class ModelVerEntity extends CommonDateEntity {
@Id @Id
@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "tb_model_ver_id_gen") @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) @Column(name = "model_ver_uid", nullable = false)
private Long id; private Long id;
@@ -62,8 +65,19 @@ public class ModelVerEntity extends CommonDateEntity {
private Boolean deleted = false; 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.id = id;
this.modelUid = modelUid; this.modelUid = modelUid;
this.modelCate = modelCate; this.modelCate = modelCate;
@@ -78,8 +92,17 @@ public class ModelVerEntity extends CommonDateEntity {
this.deleted = deleted; 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.modelUid = modelUid;
this.modelCate = modelCate; this.modelCate = modelCate;
this.modelVer = modelVer; this.modelVer = modelVer;
@@ -119,7 +142,7 @@ public class ModelVerEntity extends CommonDateEntity {
return deleted; return deleted;
} }
public void deleted(){ public void deleted() {
this.deleted = true; this.deleted = true;
} }
} }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,12 +1,11 @@
package com.kamco.cd.kamcoback.postgres.repository.changedetection; 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.kamco.cd.kamcoback.postgres.entity.MapSheetAnalDataGeomEntity;
import com.querydsl.jpa.impl.JPAQueryFactory; import com.querydsl.jpa.impl.JPAQueryFactory;
import org.springframework.data.jpa.repository.support.QuerydslRepositorySupport;
import java.util.List; 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 public class ChangeDetectionRepositoryImpl extends QuerydslRepositorySupport
implements ChangeDetectionRepositoryCustom { implements ChangeDetectionRepositoryCustom {

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

@@ -88,12 +88,12 @@ public class CommonCodeRepositoryImpl extends QuerydslRepositorySupport
QCommonCodeEntity parent = QCommonCodeEntity.commonCodeEntity; QCommonCodeEntity parent = QCommonCodeEntity.commonCodeEntity;
QCommonCodeEntity child = new QCommonCodeEntity("child"); QCommonCodeEntity child = new QCommonCodeEntity("child");
String result = queryFactory String result =
queryFactory
.select(child.name) .select(child.name)
.from(child) .from(child)
.join(child.parent, parent) .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(); // 단일 결과만 .fetchFirst(); // 단일 결과만
return Optional.ofNullable(result); return Optional.ofNullable(result);

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

@@ -18,8 +18,7 @@ public interface AuditLogRepositoryCustom {
Page<AuditLogDto.DailyDetail> findLogByDailyResult( Page<AuditLogDto.DailyDetail> findLogByDailyResult(
AuditLogDto.searchReq searchReq, LocalDate logDate); 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( Page<AuditLogDto.UserDetail> findLogByAccountResult(
AuditLogDto.searchReq searchReq, Long accountId); AuditLogDto.searchReq searchReq, Long accountId);

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

@@ -52,9 +52,7 @@ public class AuditLogRepositoryImpl extends QuerydslRepositorySupport
printCount().as("printCount"), printCount().as("printCount"),
downloadCount().as("downloadCount"), downloadCount().as("downloadCount"),
auditLogEntity.count().as("totalCount"), auditLogEntity.count().as("totalCount"),
groupDateTime.as("baseDate") groupDateTime.as("baseDate")))
)
)
.from(auditLogEntity) .from(auditLogEntity)
.where(eventEndedAtBetween(startDate, endDate)) .where(eventEndedAtBetween(startDate, endDate))
.groupBy(groupDateTime) .groupBy(groupDateTime)
@@ -242,7 +240,9 @@ public class AuditLogRepositoryImpl extends QuerydslRepositorySupport
Projections.constructor( Projections.constructor(
AuditLogDto.MenuDetail.class, AuditLogDto.MenuDetail.class,
auditLogEntity.id.as("logId"), 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.userNm.as("userName"),
userEntity.userId.as("loginId"), userEntity.userId.as("loginId"),
auditLogEntity.eventType.as("eventType"), auditLogEntity.eventType.as("eventType"),
@@ -307,7 +307,9 @@ public class AuditLogRepositoryImpl extends QuerydslRepositorySupport
Projections.constructor( Projections.constructor(
AuditLogDto.UserDetail.class, AuditLogDto.UserDetail.class,
auditLogEntity.id.as("logId"), 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"), menuEntity.menuNm.as("menuName"),
auditLogEntity.eventType.as("eventType"), auditLogEntity.eventType.as("eventType"),
Projections.constructor( Projections.constructor(

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

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

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

@@ -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.model.dto.ModelMngDto;
import com.kamco.cd.kamcoback.postgres.entity.ModelMngEntity; import com.kamco.cd.kamcoback.postgres.entity.ModelMngEntity;
import org.springframework.data.domain.Page;
import java.time.LocalDate; import java.time.LocalDate;
import java.util.List; import java.util.List;
import java.util.Optional; import java.util.Optional;
import org.springframework.data.domain.Page;
public interface ModelMngRepositoryCustom { public interface ModelMngRepositoryCustom {
@@ -14,5 +13,6 @@ public interface ModelMngRepositoryCustom {
Optional<ModelMngDto.FinalModelDto> getFinalModelInfo(); 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);
} }

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

@@ -1,5 +1,9 @@
package com.kamco.cd.kamcoback.postgres.repository.model; 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.model.dto.ModelMngDto;
import com.kamco.cd.kamcoback.postgres.QuerydslOrderUtil; import com.kamco.cd.kamcoback.postgres.QuerydslOrderUtil;
import com.kamco.cd.kamcoback.postgres.entity.ModelMngEntity; 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.core.types.dsl.StringExpression;
import com.querydsl.jpa.impl.JPAQueryFactory; import com.querydsl.jpa.impl.JPAQueryFactory;
import io.micrometer.common.util.StringUtils; 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.LocalDate;
import java.time.LocalDateTime; import java.time.LocalDateTime;
import java.time.ZonedDateTime; import java.time.ZonedDateTime;
import java.util.List; import java.util.List;
import java.util.Objects; import java.util.Objects;
import java.util.Optional; 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 public class ModelMngRepositoryImpl extends QuerydslRepositorySupport
implements ModelMngRepositoryCustom { implements ModelMngRepositoryCustom {
@@ -39,14 +38,11 @@ public class ModelMngRepositoryImpl extends QuerydslRepositorySupport
@Override @Override
public List<ModelMngEntity> findModelMngAll() { public List<ModelMngEntity> findModelMngAll() {
return queryFactory return queryFactory.selectFrom(modelMngEntity).orderBy(modelMngEntity.id.desc()).fetch();
.selectFrom(modelMngEntity)
.orderBy(modelMngEntity.id.desc())
.fetch();
} }
@Override @Override
public Optional<ModelMngDto.FinalModelDto> getFinalModelInfo(){ public Optional<ModelMngDto.FinalModelDto> getFinalModelInfo() {
return queryFactory return queryFactory
.select( .select(
Projections.constructor( Projections.constructor(
@@ -60,20 +56,19 @@ public class ModelMngRepositoryImpl extends QuerydslRepositorySupport
modelVerEntity.modelState, modelVerEntity.modelState,
modelVerEntity.qualityProb, modelVerEntity.qualityProb,
modelVerEntity.deployState, modelVerEntity.deployState,
modelVerEntity.modelPath modelVerEntity.modelPath))
)
)
.from(modelMngEntity) .from(modelMngEntity)
.innerJoin(modelVerEntity) .innerJoin(modelVerEntity)
.on(modelMngEntity.id.eq(modelVerEntity.modelUid)) .on(modelMngEntity.id.eq(modelVerEntity.modelUid))
.where(modelVerEntity.usedState.eq("USED")) //USED 인 것 중에 .where(modelVerEntity.usedState.eq("USED")) // USED 인 것 중에
.orderBy(modelVerEntity.modelVer.desc()) //Version 높은 것 기준 .orderBy(modelVerEntity.modelVer.desc()) // Version 높은 것 기준
.stream() .stream()
.findFirst(); .findFirst();
} }
@Override @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(); Pageable pageable = searchReq.toPageable();
List<ModelMngDto.ModelRegHistory> foundContent = List<ModelMngDto.ModelRegHistory> foundContent =
@@ -84,27 +79,30 @@ public class ModelMngRepositoryImpl extends QuerydslRepositorySupport
modelMngEntity.modelNm, modelMngEntity.modelNm,
modelMngEntity.modelCate, modelMngEntity.modelCate,
modelVerEntity.modelVer, 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.usedState,
modelVerEntity.deployState, 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) .from(modelMngEntity)
.innerJoin(modelVerEntity) .innerJoin(modelVerEntity)
.on(modelMngEntity.id.eq(modelVerEntity.modelUid)) .on(modelMngEntity.id.eq(modelVerEntity.modelUid))
.leftJoin(modelDeployHstEntity) .leftJoin(modelDeployHstEntity)
.on( .on(
modelVerEntity.id.eq(modelDeployHstEntity.modelVerUid) modelVerEntity
.and(modelDeployHstEntity.serverId.eq(1L)) //1건만 조회해야 하기에 1번 서버만 조회하기 .id
) .eq(modelDeployHstEntity.modelVerUid)
.where( .and(modelDeployHstEntity.serverId.eq(1L)) // 1건만 조회해야 하기에 1번 서버만 조회하기
eventEndedAtBetween(startDate, endDate),
searchModelVerLike(searchVal)
) )
.where(eventEndedAtBetween(startDate, endDate), searchModelVerLike(searchVal))
.offset(pageable.getOffset()) .offset(pageable.getOffset())
.limit(pageable.getPageSize()) .limit(pageable.getPageSize())
.orderBy(QuerydslOrderUtil.getOrderSpecifiers(pageable, ModelVerEntity.class, "modelVerEntity")) .orderBy(
QuerydslOrderUtil.getOrderSpecifiers(
pageable, ModelVerEntity.class, "modelVerEntity"))
.fetch(); .fetch();
Long countQuery = Long countQuery =
@@ -113,10 +111,7 @@ public class ModelMngRepositoryImpl extends QuerydslRepositorySupport
.from(modelMngEntity) .from(modelMngEntity)
.innerJoin(modelVerEntity) .innerJoin(modelVerEntity)
.on(modelMngEntity.id.eq(modelVerEntity.modelUid)) .on(modelMngEntity.id.eq(modelVerEntity.modelUid))
.where( .where(eventEndedAtBetween(startDate, endDate), searchModelVerLike(searchVal))
eventEndedAtBetween(startDate, endDate),
searchModelVerLike(searchVal)
)
.fetchOne(); .fetchOne();
return new PageImpl<>(foundContent, pageable, countQuery); return new PageImpl<>(foundContent, pageable, countQuery);
@@ -128,11 +123,13 @@ public class ModelMngRepositoryImpl extends QuerydslRepositorySupport
} }
LocalDateTime startDateTime = startDate.atStartOfDay(); LocalDateTime startDateTime = startDate.atStartOfDay();
LocalDateTime endDateTime = endDate.plusDays(1).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))); .and(modelMngEntity.modifiedDate.lt(ZonedDateTime.from(endDateTime)));
} }
private BooleanExpression searchModelVerLike(String searchVal){ private BooleanExpression searchModelVerLike(String searchVal) {
if (StringUtils.isBlank(searchVal)) { if (StringUtils.isBlank(searchVal)) {
return null; return null;
} }

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

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

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

@@ -1,10 +1,6 @@
package com.kamco.cd.kamcoback.postgres.repository.model; 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 com.kamco.cd.kamcoback.postgres.entity.ModelVerEntity;
import java.util.List;
import java.util.Optional; import java.util.Optional;
public interface ModelVerRepositoryCustom { public interface ModelVerRepositoryCustom {

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

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