Merge remote-tracking branch 'origin/feat/infer_dev_260211' into feat/infer_dev_260211

60초 long restTemplate 추가

src/main/java/com/kamco/cd/kamcoback/auth/JwtAuthenticationFilter.java

@@ -20,8 +20,7 @@ public class JwtAuthenticationFilter extends OncePerRequestFilter {
 
   private static final AntPathMatcher PATH_MATCHER = new AntPathMatcher();
   private static final String[] EXCLUDE_PATHS = {
-    //    "/api/auth/signin", "/api/auth/refresh", "/api/auth/logout", "/api/members/*/password"
-    "/api/auth/signin", "/api/auth/refresh", "/api/auth/logout"
+    "/api/auth/signin", "/api/auth/refresh", "/api/auth/logout", "/api/members/*/password"
   };
   private final JwtTokenProvider jwtTokenProvider;
   private final UserDetailsService userDetailsService;

src/main/java/com/kamco/cd/kamcoback/common/download/DownloadAuditEventListener.java

@@ -5,7 +5,9 @@ import com.kamco.cd.kamcoback.common.download.dto.DownloadAuditEvent;
 import com.kamco.cd.kamcoback.menu.dto.MenuDto;
 import com.kamco.cd.kamcoback.menu.service.MenuService;
 import com.kamco.cd.kamcoback.postgres.entity.AuditLogEntity;
+import com.kamco.cd.kamcoback.postgres.entity.MemberEntity;
 import com.kamco.cd.kamcoback.postgres.repository.log.AuditLogRepository;
+import com.kamco.cd.kamcoback.postgres.repository.members.MembersRepository;
 import java.util.Comparator;
 import java.util.LinkedHashMap;
 import java.util.List;
@@ -24,6 +26,7 @@ import org.springframework.transaction.annotation.Transactional;
 public class DownloadAuditEventListener {
 
   private final AuditLogRepository auditLogRepository;
+  private final MembersRepository membersRepository;
   private final MenuService menuService;
   private final ObjectMapper objectMapper;
 
@@ -42,9 +45,23 @@ public class DownloadAuditEventListener {
         return;
       }
 
+      Long userId = ev.userId();
+
+      if (userId == null) {
+        // a 링크로 들어온 download는 사번으로 파라미터가 전달 되므로 사번으로 user id 조회 하기
+        MemberEntity memberEntity =
+            membersRepository.findByEmployeeNo(ev.employeeNo()).orElse(null);
+
+        if (memberEntity == null) {
+          return; // 매핑 실패 시 로그 저장 안 함
+        }
+
+        userId = memberEntity.getId();
+      }
+
       AuditLogEntity logEntity =
           AuditLogEntity.forFileDownload(
-              ev.userId(), ev.requestUri(), menuUid, ev.ip(), ev.status(), ev.downloadUuid());
+              userId, ev.requestUri(), menuUid, ev.ip(), ev.status(), ev.downloadUuid());
 
       auditLogRepository.save(logEntity);
 

src/main/java/com/kamco/cd/kamcoback/common/download/RangeDownloadResponder.java

@@ -14,23 +14,56 @@ import org.springframework.http.MediaType;
 import org.springframework.http.ResponseEntity;
 import org.springframework.stereotype.Component;
 
+/**
+ * Range(부분 다운로드) 지원 파일 다운로드 응답 생성기.
+ *
+ * <p>브라우저/다운로드 매니저가 Range 헤더를 보내면 206 Partial Content로 일부 구간만 내려주고, Range 헤더가 없으면 200 OK로 전체 파일을
+ * 내려준다.
+ *
+ * <p>대용량 ZIP(또는 바이너리) 파일 다운로드 시: - 메모리에 파일 전체를 올리지 않고(Resource/FileSystemResource 스트리밍) -
+ * 이어받기(Resume) 및 병렬 다운로드(일부 클라이언트) 지원 - 잘못된 Range에 대해 416 Range Not Satisfiable 처리
+ */
 @Component
 public class RangeDownloadResponder {
 
+  /**
+   * ZIP(또는 바이너리) 파일 다운로드 응답을 생성한다.
+   *
+   * @param filePath 실제 서버 파일 경로
+   * @param downloadFileName 사용자에게 노출될 다운로드 파일명
+   * @param request Range 헤더 확인용 HttpServletRequest
+   * @return Range 유무에 따라 200(전체) 또는 206(부분) ResponseEntity 반환
+   * @throws IOException 파일 접근/조회 실패 시
+   */
   public ResponseEntity<?> buildZipResponse(
       Path filePath, String downloadFileName, HttpServletRequest request) throws IOException {
 
+    // 1) 파일 존재/정상 파일 여부 확인
+    // - 일반 파일(regular file)이 아니면 404 반환 (디렉토리/없는 파일/특수 파일 등 방지)
     if (!Files.isRegularFile(filePath)) {
       return ResponseEntity.notFound().build();
     }
 
+    // 2) 파일 전체 크기 및 Spring Resource 래핑
+    // - Files.size: 전체 파일 크기(Content-Range 계산/검증에 필요)
+    // - FileSystemResource: 스프링이 스트리밍 형태로 파일을 응답 바디로 내려줄 수 있게 함
     long totalSize = Files.size(filePath);
     Resource resource = new FileSystemResource(filePath);
 
+    // 3) 다운로드 강제(Content-Disposition)
+    // - attachment; filename="xxx.zip" 형태로 브라우저가 저장 대화상자/다운로드로 처리
     String disposition = "attachment; filename=\"" + downloadFileName + "\"";
+
+    // 4) Range 헤더 조회
+    // - Range: bytes=0-1023  (일부 구간 요청)
+    // - Range가 없으면 전체 다운로드로 처리
     String rangeHeader = request.getHeader(HttpHeaders.RANGE);
 
-    // 🔥 공통 헤더 (여기 고정)
+    // 5) 공통 헤더(전체/부분 다운로드 공통으로 넣을 것)
+    // - Content-Type: 바이너리(필요시 application/zip 으로 바꿔도 됨)
+    // - Content-Disposition: 다운로드 강제
+    // - Accept-Ranges: bytes -> 서버가 Range(이어받기/부분요청) 지원함을 알림
+    // - X-Accel-Buffering: no -> Nginx 사용 시 버퍼링 비활성화(스트리밍/대용량에 유리)
     ResponseEntity.BodyBuilder base =
         ResponseEntity.ok()
             .contentType(MediaType.APPLICATION_OCTET_STREAM)
@@ -38,10 +71,15 @@ public class RangeDownloadResponder {
             .header(HttpHeaders.ACCEPT_RANGES, "bytes")
             .header("X-Accel-Buffering", "no");
 
+    // 6) Range 헤더가 없으면 전체 파일 반환 (200 OK)
     if (rangeHeader == null || rangeHeader.isBlank()) {
+      // Content-Length를 전체 크기로 설정하고 Resource를 그대로 바디에 담아 스트리밍
       return base.contentLength(totalSize).body(resource);
     }
 
+    // 7) Range 헤더 파싱
+    // - 잘못된 Range 헤더 형식이면 parseRanges에서 IllegalArgumentException 발생 가능
+    // - RFC에 따라 416 응답 + Content-Range: bytes */{total} 형태로 알려줌
     List<HttpRange> ranges;
     try {
       ranges = HttpRange.parseRanges(rangeHeader);
@@ -52,11 +90,18 @@ public class RangeDownloadResponder {
           .build();
     }
 
+    // 8) 다중 Range 요청이 와도(예: bytes=0-99,200-299) 여기서는 첫 번째 Range만 처리
+    // - 대부분 브라우저는 단일 Range를 사용
+    // - 멀티파트/byteranges 처리를 하려면 별도 구현 필요
     HttpRange range = ranges.get(0);
 
+    // 9) 실제 시작/끝 범위 계산
+    // - bytes=500-  : end를 파일 끝으로 해석
+    // - bytes=-500  : 마지막 500바이트로 해석
     long start = range.getRangeStart(totalSize);
     long end = range.getRangeEnd(totalSize);
 
+    // 10) 시작점이 파일 크기 이상이면 만족 불가 -> 416
     if (start >= totalSize) {
       return ResponseEntity.status(416)
           .header(HttpHeaders.CONTENT_RANGE, "bytes */" + totalSize)
@@ -64,9 +109,18 @@ public class RangeDownloadResponder {
           .build();
     }
 
+    // 11) 요청 구간 길이 계산
+    // - end/start는 inclusive이므로 +1 필요
     long regionLength = end - start + 1;
+
+    // 12) ResourceRegion 생성
+    // - resource의 start부터 regionLength 만큼만 응답으로 내려줄 수 있게 함
+    // - 파일 전체를 메모리에 올리지 않고 필요한 부분만 스트리밍
     ResourceRegion region = new ResourceRegion(resource, start, regionLength);
 
+    // 13) 206 Partial Content로 응답 구성
+    // - Content-Range: bytes start-end/total
+    // - Content-Length: regionLength(부분 크기)
     return ResponseEntity.status(206)
         .contentType(MediaType.APPLICATION_OCTET_STREAM)
         .header(HttpHeaders.CONTENT_DISPOSITION, disposition)

src/main/java/com/kamco/cd/kamcoback/common/download/dto/DownloadAuditEvent.java

@@ -4,6 +4,7 @@ import java.util.UUID;
 
 public record DownloadAuditEvent(
     Long userId,
+    String employeeNo,
     String requestUri,
     String normalizedUri,
     String ip,

src/main/java/com/kamco/cd/kamcoback/common/inference/service/InferenceCommonService.java

@@ -0,0 +1,111 @@
+package com.kamco.cd.kamcoback.common.inference.service;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.kamco.cd.kamcoback.common.exception.CustomApiException;
+import com.kamco.cd.kamcoback.config.resttemplate.ExternalHttpClient;
+import com.kamco.cd.kamcoback.config.resttemplate.ExternalHttpClient.ExternalCallResult;
+import com.kamco.cd.kamcoback.inference.dto.InferenceSendDto;
+import java.util.List;
+import java.util.Map;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.log4j.Log4j2;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.MediaType;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+@Service
+@Log4j2
+@Transactional(readOnly = true)
+@RequiredArgsConstructor
+public class InferenceCommonService {
+
+  @Value("${spring.profiles.active}")
+  private String profile;
+
+  @Value("${inference.url}")
+  private String inferenceUrl;
+
+  private final ObjectMapper objectMapper;
+  private final ExternalHttpClient externalHttpClient;
+
+  /**
+   * 추론 AI API 호출 batch id를 리턴
+   *
+   * @param dto
+   * @return
+   */
+  public Long ensureAccepted(InferenceSendDto dto) {
+
+    if (dto == null) {
+      log.warn("not InferenceSendDto dto");
+      throw new CustomApiException("BAD_REQUEST", HttpStatus.BAD_REQUEST);
+    }
+
+    log.info("");
+    log.info("========================================================");
+    log.info("[SEND INFERENCE] Inference request dto= {}", dto);
+    log.info("========================================================");
+    log.info("");
+
+    // 1) 요청 로그
+    try {
+      log.debug("Inference request dto={}", objectMapper.writeValueAsString(dto));
+    } catch (JsonProcessingException e) {
+      log.warn("Failed to serialize inference dto", e);
+    }
+
+    // 2) local 환경 임시 처리
+    //    if ("local".equals(profile)) {
+    //      if (dto.getPred_requests_areas() == null) {
+    //        throw new IllegalStateException("pred_requests_areas is null");
+    //      }
+    //
+    // dto.getPred_requests_areas().setInput1_scene_path("/kamco-nfs/requests/2023_local.geojson");
+    //
+    // dto.getPred_requests_areas().setInput2_scene_path("/kamco-nfs/requests/2024_local.geojson");
+    //    }
+
+    // 3) HTTP 호출
+    HttpHeaders headers = new HttpHeaders();
+    headers.setContentType(MediaType.APPLICATION_JSON);
+    headers.setAccept(List.of(MediaType.APPLICATION_JSON));
+
+    // 4) 추론 실행 API 호출
+    ExternalCallResult<String> result =
+        externalHttpClient.callLong(inferenceUrl, HttpMethod.POST, dto, headers, String.class);
+
+    if (result.statusCode() < 200 || result.statusCode() >= 300) {
+      log.error("Inference API failed. status={}, body={}", result.statusCode(), result.body());
+      throw new CustomApiException("BAD_GATEWAY", HttpStatus.BAD_GATEWAY);
+    }
+
+    // 5) 응답 파싱
+    try {
+      List<Map<String, Object>> list =
+          objectMapper.readValue(result.body(), new TypeReference<>() {});
+
+      if (list.isEmpty()) {
+        throw new CustomApiException(
+            "NOT_FOUND", HttpStatus.NOT_FOUND, "Inference response is empty");
+      }
+
+      Object batchIdObj = list.get(0).get("batch_id");
+      if (batchIdObj == null) {
+        throw new CustomApiException(
+            "NOT_FOUND", HttpStatus.NOT_FOUND, "batch_id not found in response");
+      }
+
+      return Long.valueOf(batchIdObj.toString());
+
+    } catch (Exception e) {
+      log.error("Failed to parse inference response. body={}", result.body(), e);
+      throw new CustomApiException("INVALID_INFERENCE_RESPONSE", HttpStatus.BAD_GATEWAY);
+    }
+  }
+}

src/main/java/com/kamco/cd/kamcoback/common/inference/utils/GeoJsonValidator.java

@@ -0,0 +1,264 @@
+package com.kamco.cd.kamcoback.common.inference.utils;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.*;
+import java.util.stream.Collectors;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.springframework.http.HttpStatus;
+import org.springframework.web.server.ResponseStatusException;
+
+/**
+ * GeoJSON 파일의 "features[].properties.scene_id" 값들이 "요청한 도엽번호 목록(requestedMapSheetNums)"과 정확히 일치하는지
+ * 검증하는 유틸.
+ *
+ * <p>핵심 목적: - 요청한 도엽번호를 기반으로 GeoJSON을 생성했는데, 실제 결과 파일에 누락/추가/중복/빈값(scene_id 없음) 등이 발생했는지 빠르게 잡아내기.
+ *
+ * <p>검증 실패 시: - 404: 파일 자체가 없음 - 400: 파일이 비어있거나(0 byte), features 구조가 이상하거나, 요청 목록이 비어있음 - 500: 파일
+ * IO/파싱 자체가 실패(읽기 실패 등) - 422: 정합성(요청 vs 결과)이 맞지 않음 (누락/추가/중복/빈 scene_id 존재)
+ */
+public class GeoJsonValidator {
+
+  /** GeoJSON 파싱용 ObjectMapper (정적 1개로 재사용) */
+  private static final ObjectMapper om = new ObjectMapper();
+
+  /** 로그 출력용 */
+  private static final Logger log = LogManager.getLogger(GeoJsonValidator.class);
+
+  /**
+   * @param geojsonPath GeoJSON 파일 경로(문자열)
+   * @param requestedMapSheetNums "요청한 도엽번호" 리스트 (중복/공백/NULL 포함 가능)
+   *     <p>동작 개요: 1) 파일 존재/크기 검증 2) 요청 도엽번호 목록 정리(Trim + 공백 제거 + 중복 제거) 3) GeoJSON 파싱 후 features 배열
+   *     확보 4) features에서 scene_id 추출하여 유니크 set 구성 5) requested vs found 비교: - missing: requested -
+   *     found - extra : found - requested - duplicates: GeoJSON 내부에서 scene_id 중복 등장 - nullIdCount:
+   *     scene_id가 null/blank 인 feature 개수 6) 이상 있으면 422로 실패 처리
+   */
+  public static void validateWithRequested(String geojsonPath, List<String> requestedMapSheetNums) {
+
+    // 문자열 경로를 Path로 변환 (Files API 사용 목적)
+    Path path = Path.of(geojsonPath);
+
+    // =========================================================
+    // 1) 파일 기본 검증
+    //    - 파일이 존재하는지
+    //    - 파일 크기가 0인지(비어있으면 생성 실패/오류 가능성)
+    // =========================================================
+    try {
+      // 파일 존재 여부 체크 (없으면 404)
+      if (!Files.exists(path)) {
+        throw new ResponseStatusException(
+            HttpStatus.NOT_FOUND, "GeoJSON 파일이 존재하지 않습니다: " + geojsonPath);
+      }
+
+      // 파일 사이즈 체크 (0 byte면 400)
+      if (Files.size(path) == 0) {
+        throw new ResponseStatusException(
+            HttpStatus.BAD_REQUEST, "GeoJSON 파일이 비어있습니다: " + geojsonPath);
+      }
+    } catch (IOException e) {
+      // 파일 사이즈/상태 확인 중 IO 오류면 서버오류로 처리
+      log.error("GeoJSON 파일 상태 확인 실패: path={}", path, e);
+      throw new ResponseStatusException(
+          HttpStatus.INTERNAL_SERVER_ERROR, "GeoJSON 파일 상태 확인 실패: " + geojsonPath, e);
+    }
+
+    // =========================================================
+    // 2) 요청 도엽 리스트 유효성 검증
+    //    - 요청 목록 자체가 null/empty면 검증할 기준이 없으므로 400
+    // =========================================================
+    if (requestedMapSheetNums == null || requestedMapSheetNums.isEmpty()) {
+      throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "requestedMapSheetNums 가 비어있습니다.");
+    }
+
+    // =========================================================
+    // 2-1) 요청 도엽 Set 정리 (중복/공백/NULL 제거)
+    //    - null 제거
+    //    - trim 적용
+    //    - 빈 문자열 제거
+    //    - LinkedHashSet 사용: "중복 제거 + 원래 입력 순서 유지"
+    // =========================================================
+    Set<String> requested =
+        requestedMapSheetNums.stream()
+            .filter(Objects::nonNull) // null 제거
+            .map(String::trim) // 앞뒤 공백 제거
+            .filter(s -> !s.isEmpty()) // "" 제거
+            .collect(Collectors.toCollection(LinkedHashSet::new)); // 중복 제거 + 순서 유지
+
+    // 정리 결과가 비어있으면(전부 null/공백)이므로 400
+    if (requested.isEmpty()) {
+      throw new ResponseStatusException(
+          HttpStatus.BAD_REQUEST, "requestedMapSheetNums 가 공백/NULL만 포함합니다.");
+    }
+
+    // =========================================================
+    // 3) GeoJSON 파싱
+    //    기대 구조:
+    //    {
+    //      "type": "FeatureCollection",
+    //      "features": [ ... ]
+    //    }
+    //
+    //    - features가 없거나 배열이 아니면 "유효하지 않은 GeoJSON" (400)
+    //    - 파일 읽기/파싱 IO 문제는 500
+    //    - JSON 자체가 깨진 경우는 400
+    // =========================================================
+    final JsonNode features;
+    try {
+      // JSON 파일을 트리 형태로 파싱
+      JsonNode root = om.readTree(path.toFile());
+
+      // GeoJSON FeatureCollection의 핵심은 features 배열
+      features = root.get("features");
+
+      // features가 없거나 배열이 아니면 GeoJSON 구조가 이상한 것
+      if (features == null || !features.isArray()) {
+        throw new ResponseStatusException(
+            HttpStatus.BAD_REQUEST, "유효하지 않은 GeoJSON: features가 없거나 배열이 아닙니다.");
+      }
+    } catch (ResponseStatusException e) {
+      // 위에서 직접 던진 에러는 그대로 전달
+      throw e;
+    } catch (IOException e) {
+      // 읽기/파싱 과정에서 IO 문제가 터지면 서버오류
+      log.error("GeoJSON 파일 읽기/파싱 실패: path={}", path, e);
+      throw new ResponseStatusException(
+          HttpStatus.INTERNAL_SERVER_ERROR, "GeoJSON 파일 읽기/파싱 실패: " + geojsonPath, e);
+    } catch (Exception e) {
+      // JSON 문법 오류/예상치 못한 파싱 오류는 클라이언트 입력/파일 자체 문제로 400 처리
+      log.error("GeoJSON 파싱 오류(비정상 JSON): path={}", path, e);
+      throw new ResponseStatusException(
+          HttpStatus.BAD_REQUEST, "GeoJSON 파싱 오류(비정상 JSON): " + geojsonPath, e);
+    }
+
+    // =========================================================
+    // 4) 검증 로직
+    //    - featureCount: 전체 feature 수 (중복 포함)
+    //    - foundUnique: GeoJSON에 등장한 유니크 scene_id 집합
+    //    - duplicates: GeoJSON 내부에서 scene_id가 중복된 목록(샘플 출력용)
+    //    - nullIdCount: scene_id가 없거나 빈 값인 feature 개수
+    // =========================================================
+    int featureCount = features.size();
+
+    // 유니크 scene_id를 담는 Set (중복 판단을 위해 add 결과를 사용)
+    Set<String> foundUnique = new HashSet<>();
+
+    // 중복된 scene_id 목록 (샘플 로그 출력용이라 순서 유지 가능한 LinkedHashSet 사용)
+    Set<String> duplicates = new LinkedHashSet<>();
+
+    // scene_id가 null 또는 blank인 feature의 개수 (데이터 이상)
+    int nullIdCount = 0;
+
+    // ---------------------------------------------------------
+    // features를 돌면서 feature.properties.scene_id를 추출한다.
+    //
+    // 기대 구조(일반적):
+    // features[i] = {
+    //   "type": "Feature",
+    //   "properties": {
+    //      "scene_id": "도엽번호"
+    //   },
+    //   "geometry": {...}
+    // }
+    // ---------------------------------------------------------
+    for (JsonNode feature : features) {
+      JsonNode props = feature.get("properties");
+
+      // properties가 있고 scene_id가 null이 아니면 텍스트로 읽음
+      // 없으면 null 처리
+      String sceneId =
+          (props != null && props.hasNonNull("scene_id")) ? props.get("scene_id").asText() : null;
+
+      // scene_id가 없거나 빈값이면 "정상적으로 도엽번호가 들어오지 않은 feature"로 카운트
+      if (sceneId == null || sceneId.isBlank()) {
+        nullIdCount++; // 도엽번호가 없으면 증가
+        continue;
+      }
+
+      // foundUnique.add(sceneId)가 false면 "이미 같은 값이 있었다"는 뜻 => 중복
+      if (!foundUnique.add(sceneId)) {
+        duplicates.add(sceneId);
+      }
+    }
+
+    // =========================================================
+    // 4-1) requested vs found 비교(set 차집합)
+    //
+    // missing = requested - found
+    //   : 요청은 했는데 결과 GeoJSON에 없는 도엽번호
+    //
+    // extra = found - requested
+    //   : 요청하지 않았는데 결과 GeoJSON에 들어간 도엽번호
+    // =========================================================
+
+    // missing: requested를 복사한 뒤(foundUnique에 있는 값들을 제거) => 남은 것이 누락분
+    Set<String> missing = new LinkedHashSet<>(requested);
+    missing.removeAll(foundUnique);
+
+    // extra: foundUnique를 복사한 뒤(requested에 있는 값들을 제거) => 남은 것이 추가분
+    Set<String> extra = new LinkedHashSet<>(foundUnique);
+    extra.removeAll(requested);
+
+    // =========================================================
+    // 5) 로그 출력
+    //    - 운영에서 문제 생겼을 때 "요청 vs 생성 결과"를 한 눈에 보게
+    //    - sample 로그는 너무 길어질 수 있으므로 limit 걸어줌
+    // =========================================================
+    log.info(
+        """
+    ===== GeoJSON Validation =====
+    file: {}
+    features(total): {}
+    requested(unique): {}
+    found(unique scene_id): {}
+    scene_id null/blank: {}
+    duplicates(scene_id): {}
+    missing(requested - found): {}
+    extra(found - requested): {}
+    ==============================
+    """,
+        geojsonPath,
+        featureCount, // 중복 포함한 전체 feature 수
+        requested.size(), // 요청 도엽 유니크 수
+        foundUnique.size(), // GeoJSON에서 발견된 scene_id 유니크 수
+        nullIdCount, // scene_id가 비어있는 feature 수
+        duplicates.size(), // 중복 scene_id 종류 수
+        missing.size(), // 요청했지만 빠진 도엽 수
+        extra.size()); // 요청하지 않았는데 들어온 도엽 수
+
+    // 중복/누락/추가 항목은 전체를 다 찍으면 로그 폭발하므로 샘플만
+    if (!duplicates.isEmpty())
+      log.warn("duplicates sample: {}", duplicates.stream().limit(20).toList());
+
+    if (!missing.isEmpty()) log.warn("missing sample: {}", missing.stream().limit(50).toList());
+
+    if (!extra.isEmpty()) log.warn("extra sample: {}", extra.stream().limit(50).toList());
+
+    // =========================================================
+    // 6) 실패 조건 판정
+    //
+    // 아래 중 하나라도 있으면 "요청 대비 결과 정합성이 깨졌다"로 보고 실패 처리(422):
+    // - missing 존재: 요청했는데 결과에 없음
+    // - extra 존재  : 요청 안했는데 결과에 있음
+    // - duplicates 존재: 동일 도엽이 중복 생성됨
+    // - nullIdCount > 0: scene_id가 비어있는 feature가 있음(데이터 이상)
+    //
+    // 422(Unprocessable Entity):
+    // - 요청 문법은 맞지만(파일은 있고 JSON도 읽힘),
+    //   내용(정합성)이 요구사항을 만족하지 못하는 경우에 적합.
+    // =========================================================
+    if (!missing.isEmpty() || !extra.isEmpty() || !duplicates.isEmpty() || nullIdCount > 0) {
+      throw new ResponseStatusException(
+          HttpStatus.UNPROCESSABLE_ENTITY,
+          String.format(
+              "GeoJSON validation failed: missing=%d, extra=%d, duplicates=%d, nullId=%d",
+              missing.size(), extra.size(), duplicates.size(), nullIdCount));
+    }
+
+    // 모든 조건을 통과하면 정상
+    log.info("GeoJSON validation OK");
+  }
+}

src/main/java/com/kamco/cd/kamcoback/config/FileDownloadInteceptor.java

@@ -13,6 +13,7 @@ import org.springframework.context.ApplicationEventPublisher;
 import org.springframework.stereotype.Component;
 import org.springframework.web.servlet.HandlerInterceptor;
 
+/** 파일 다운로드 log 저장 */
 @Slf4j
 @Component
 @RequiredArgsConstructor
@@ -30,9 +31,17 @@ public class FileDownloadInteceptor implements HandlerInterceptor {
     if (request.getDispatcherType() != DispatcherType.REQUEST) return;
 
     Long userId;
+    String employeeNo = "";
+
     try {
+      // a 링크 다운로드일경우 userId가 없으므로 전달받은 사번을 넣는다
       userId = userUtil.getId();
-      if (userId == null) return; // userId null 불가면 스킵
+      if (userId == null) {
+        employeeNo = request.getParameter("employeeNo");
+        if (employeeNo == null) {
+          return;
+        }
+      }
     } catch (Exception e) {
       log.warn("Download audit userId resolve failed. uri={}, err={}", uri, e.toString());
       return;
@@ -48,8 +57,9 @@ public class FileDownloadInteceptor implements HandlerInterceptor {
       return; // downloadUuid null 불가 -> 스킵
     }
 
+    // log저장 DownloadAuditEventListener 클래스 호출
     publisher.publishEvent(
-        new DownloadAuditEvent(userId, uri, normalizedUri, ip, status, downloadUuid));
+        new DownloadAuditEvent(userId, employeeNo, uri, normalizedUri, ip, status, downloadUuid));
   }
 
   private UUID extractUuidFromUri(String uri) {

src/main/java/com/kamco/cd/kamcoback/config/SecurityConfig.java

@@ -77,7 +77,7 @@ public class SecurityConfig {
 
                     // 다운로드는 인증 필요
                     .requestMatchers(HttpMethod.GET, DownloadPaths.PATTERNS)
-                    .authenticated()
+                    .permitAll()
 
                     // 메뉴 등록 ADMIN만 가능
                     .requestMatchers(HttpMethod.POST, "/api/menu/auth")
@@ -102,11 +102,11 @@ public class SecurityConfig {
                         "/api/upload/file-chunk-upload",
                         "/api/upload/chunk-upload-complete",
                         "/api/change-detection/**",
+                        "/api/members/*/password",
                         "/api/layer/map/**",
                         "/api/layer/tile-url",
                         "/api/layer/tile-url-year",
-                        "/api/common-code/clazz",
-                        "/api/inference/download/**")
+                        "/api/common-code/clazz")
                     .permitAll()
                     // 로그인한 사용자만 가능 IAM
                     .requestMatchers(

src/main/java/com/kamco/cd/kamcoback/config/api/ApiResponseDto.java

@@ -173,8 +173,9 @@ public class ApiResponseDto<T> {
             + "To reset your password again, please submit a new request through \"Forgot"
             + " Password.\""),
     PAYLOAD_TOO_LARGE("업로드 용량 제한을 초과했습니다."),
-    NOT_FOUND_TARGET_YEAR("기준년도 도엽을 찾을 수 없습니다."),
-    NOT_FOUND_COMPARE_YEAR("비교년도 도엽을 찾을 수 없습니다."),
+    NOT_FOUND_TARGET_YEAR("기준연도 도엽을 찾을 수 없습니다."),
+    NOT_FOUND_COMPARE_YEAR("비교연도 도엽을 찾을 수 없습니다."),
+    NOT_FOUND_MAP_SHEET_NUM("추론 가능한 도엽이 없습니다."),
     FAIL_SAVE_MAP_SHEET("도엽 저장 중 오류가 발생했습니다."),
     FAIL_CREATE_MAP_SHEET_FILE("도엽 설정파일 생성 중 오류가 발생했습니다."),
     ;

src/main/java/com/kamco/cd/kamcoback/config/resttemplate/ExternalHttpClient.java

@@ -3,8 +3,8 @@ package com.kamco.cd.kamcoback.config.resttemplate;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import java.nio.charset.StandardCharsets;
 import java.util.List;
-import lombok.RequiredArgsConstructor;
 import lombok.extern.log4j.Log4j2;
+import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.http.HttpEntity;
 import org.springframework.http.HttpHeaders;
 import org.springframework.http.HttpMethod;
@@ -14,54 +14,86 @@ import org.springframework.stereotype.Component;
 import org.springframework.web.client.HttpStatusCodeException;
 import org.springframework.web.client.RestTemplate;
 
-@RequiredArgsConstructor
 @Component
 @Log4j2
 public class ExternalHttpClient {
 
-  private final RestTemplate restTemplate;
+  private final RestTemplate restTemplate; // short (@Primary)
+  private final RestTemplate restTemplateLong; // long
   private final ObjectMapper objectMapper;
 
+  public ExternalHttpClient(
+      RestTemplate restTemplate,
+      @Qualifier("restTemplateLong") RestTemplate restTemplateLong,
+      ObjectMapper objectMapper) {
+    this.restTemplate = restTemplate;
+    this.restTemplateLong = restTemplateLong;
+    this.objectMapper = objectMapper;
+  }
+
+  /** 기본(짧은 timeout) 호출 */
   public <T> ExternalCallResult<T> call(
       String url, HttpMethod method, Object body, HttpHeaders headers, Class<T> responseType) {
 
-    // responseType 기반으로 Accept 동적 세팅
+    return doCall(restTemplate, url, method, body, headers, responseType);
+  }
+
+  /** 추론/대용량 전용 (긴 timeout) */
+  public <T> ExternalCallResult<T> callLong(
+      String url, HttpMethod method, Object body, HttpHeaders headers, Class<T> responseType) {
+
+    return doCall(restTemplateLong, url, method, body, headers, responseType);
+  }
+
+  private <T> ExternalCallResult<T> doCall(
+      RestTemplate rt,
+      String url,
+      HttpMethod method,
+      Object body,
+      HttpHeaders headers,
+      Class<T> responseType) {
+
     HttpHeaders resolvedHeaders = resolveHeaders(headers, responseType);
     logRequestBody(body);
 
     HttpEntity<Object> entity = new HttpEntity<>(body, resolvedHeaders);
 
     try {
-      // String: raw bytes -> UTF-8 string
+
+      // String 응답은 raw byte로 받아 UTF-8 변환
       if (responseType == String.class) {
-        ResponseEntity<byte[]> res = restTemplate.exchange(url, method, entity, byte[].class);
+        ResponseEntity<byte[]> res = rt.exchange(url, method, entity, byte[].class);
         String raw =
             (res.getBody() == null) ? null : new String(res.getBody(), StandardCharsets.UTF_8);
 
         @SuppressWarnings("unchecked")
         T casted = (T) raw;
+
         return new ExternalCallResult<>(res.getStatusCodeValue(), true, casted, null);
       }
 
-      // byte[]: raw bytes로 받고, JSON이면 에러로 처리
+      // byte[] 응답 처리
       if (responseType == byte[].class) {
-        ResponseEntity<byte[]> res = restTemplate.exchange(url, method, entity, byte[].class);
+        ResponseEntity<byte[]> res = rt.exchange(url, method, entity, byte[].class);
 
         MediaType ct = res.getHeaders().getContentType();
         byte[] bytes = res.getBody();
 
+        // JSON이면 에러로 간주
         if (isJsonLike(ct)) {
           String err = (bytes == null) ? null : new String(bytes, StandardCharsets.UTF_8);
+
           return new ExternalCallResult<>(res.getStatusCodeValue(), false, null, err);
         }
 
         @SuppressWarnings("unchecked")
         T casted = (T) bytes;
+
         return new ExternalCallResult<>(res.getStatusCodeValue(), true, casted, null);
       }
 
-      // DTO 등: 일반 역직렬화
-      ResponseEntity<T> res = restTemplate.exchange(url, method, entity, responseType);
+      // DTO 응답
+      ResponseEntity<T> res = rt.exchange(url, method, entity, responseType);
       return new ExternalCallResult<>(res.getStatusCodeValue(), true, res.getBody(), null);
 
     } catch (HttpStatusCodeException e) {
@@ -70,29 +102,28 @@ public class ExternalHttpClient {
     }
   }
 
-  // 기존 resolveJsonHeaders를 "동적"으로 교체
+  /** Accept / Content-Type 자동 처리 */
   private HttpHeaders resolveHeaders(HttpHeaders headers, Class<?> responseType) {
-    // 원본 headers를 그대로 쓰면 외부에서 재사용할 때 사이드이펙트 날 수 있어서 복사 권장
+
     HttpHeaders h = (headers == null) ? new HttpHeaders() : new HttpHeaders(headers);
 
-    // 요청 바디 기본은 JSON이라고 가정 (필요하면 호출부에서 덮어쓰기)
+    // 기본 Content-Type
     if (h.getContentType() == null) {
       h.setContentType(MediaType.APPLICATION_JSON);
     }
 
-    // 호출부에서 Accept를 명시했으면 존중
+    // Accept 이미 있으면 존중
     if (h.getAccept() != null && !h.getAccept().isEmpty()) {
       return h;
     }
 
-    // responseType 기반 Accept 자동 지정
+    // 응답 타입 기준 Accept 자동 지정
     if (responseType == byte[].class) {
       h.setAccept(
           List.of(
               MediaType.APPLICATION_OCTET_STREAM,
               MediaType.valueOf("application/zip"),
-              MediaType.APPLICATION_JSON // 실패(JSON 에러 바디) 대비
-              ));
+              MediaType.APPLICATION_JSON));
     } else {
       h.setAccept(List.of(MediaType.APPLICATION_JSON));
     }
@@ -100,12 +131,15 @@ public class ExternalHttpClient {
     return h;
   }
 
+  /** JSON 응답 여부 체크 */
   private boolean isJsonLike(MediaType ct) {
     if (ct == null) return false;
+
     return ct.includes(MediaType.APPLICATION_JSON)
         || "application/problem+json".equalsIgnoreCase(ct.toString());
   }
 
+  /** 요청 바디 로그 */
   private void logRequestBody(Object body) {
     try {
       if (body != null) {

src/main/java/com/kamco/cd/kamcoback/config/resttemplate/RestTemplateConfig.java

@@ -4,6 +4,7 @@ import lombok.extern.log4j.Log4j2;
 import org.springframework.boot.web.client.RestTemplateBuilder;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Primary;
 import org.springframework.http.client.BufferingClientHttpRequestFactory;
 import org.springframework.http.client.SimpleClientHttpRequestFactory;
 import org.springframework.web.client.RestTemplate;
@@ -13,10 +14,20 @@ import org.springframework.web.client.RestTemplate;
 public class RestTemplateConfig {
 
   @Bean
+  @Primary
   public RestTemplate restTemplate(RestTemplateBuilder builder) {
+    return build(builder, 2000, 3000);
+  }
+
+  @Bean("restTemplateLong")
+  public RestTemplate restTemplateLong(RestTemplateBuilder builder) {
+    return build(builder, 2000, 60000);
+  }
+
+  private RestTemplate build(RestTemplateBuilder builder, int connectTimeoutMs, int readTimeoutMs) {
     SimpleClientHttpRequestFactory baseFactory = new SimpleClientHttpRequestFactory();
-    baseFactory.setConnectTimeout(2000);
-    baseFactory.setReadTimeout(3000);
+    baseFactory.setConnectTimeout(connectTimeoutMs);
+    baseFactory.setReadTimeout(readTimeoutMs);
 
     RestTemplate rt =
         builder
@@ -24,10 +35,8 @@ public class RestTemplateConfig {
             .additionalInterceptors(new RetryInterceptor())
             .build();
 
-    // byte[] 응답은 무조건 raw로 읽게 강제 (Jackson이 끼어들 여지 제거)
     rt.getMessageConverters()
         .add(0, new org.springframework.http.converter.ByteArrayHttpMessageConverter());
-
     return rt;
   }
 }

src/main/java/com/kamco/cd/kamcoback/gukyuin/service/GukYuinApiService.java

@@ -246,9 +246,9 @@ public class GukYuinApiService {
       return GukYuinLinkFailCode.NOT_FOUND;
     }
 
-    if (f.isPartScope()) {
-      return GukYuinLinkFailCode.SCOPE_PART_NOT_ALLOWED;
-    }
+    //    if (f.isPartScope()) {
+    //      return GukYuinLinkFailCode.SCOPE_PART_NOT_ALLOWED;
+    //    }
 
     if (f.hasRunningInference()) {
       return GukYuinLinkFailCode.HAS_RUNNING_INFERENCE;

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

@@ -1,4 +1,4 @@
-package com.kamco.cd.kamcoback.inference.service;
+package com.kamco.cd.kamcoback.inference;
 
 import lombok.RequiredArgsConstructor;
 import org.springframework.web.bind.annotation.RequestMapping;

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

@@ -18,7 +18,6 @@ import com.kamco.cd.kamcoback.model.dto.ModelMngDto;
 import com.kamco.cd.kamcoback.model.service.ModelMngService;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.Parameter;
-import io.swagger.v3.oas.annotations.enums.ParameterIn;
 import io.swagger.v3.oas.annotations.media.ArraySchema;
 import io.swagger.v3.oas.annotations.media.Content;
 import io.swagger.v3.oas.annotations.media.Schema;
@@ -58,7 +57,8 @@ public class InferenceResultApiController {
   private final ModelMngService modelMngService;
   private final RangeDownloadResponder rangeDownloadResponder;
 
-  @Operation(summary = "추론관리 목록", description = "어드민 홈 > 추론관리 > 추론관리 > 추론관리 목록")
+  /** 추론관리 목록 화면에서 호출 */
+  @Operation(summary = "추론관리 목록", description = "추론관리 > 추론관리 목록 ")
   @ApiResponses(
       value = {
         @ApiResponse(
@@ -90,7 +90,8 @@ public class InferenceResultApiController {
     return ApiResponseDto.ok(analResList);
   }
 
-  @Operation(summary = "추론 진행 여부 확인", description = "어드민 홈 > 추론관리 > 추론관리 > 추론관리 목록")
+  /** 추론관리 목록 화면에서 호출 */
+  @Operation(summary = "추론 진행 여부 확인", description = "추론관리 > 추론관리 목록")
   @ApiResponses(
       value = {
         @ApiResponse(
@@ -112,7 +113,8 @@ public class InferenceResultApiController {
     return ApiResponseDto.ok(inferenceResultService.getProcessing());
   }
 
-  @Operation(summary = "년도 목록 조회", description = "어드민 홈 > 추론관리 > 추론목록 > 변화탐지 실행 정보 입력 > 년도 목록 조회")
+  /** 추론관리 목록 화면에서 호출 */
+  @Operation(summary = "년도 목록 조회", description = "추론관리 > 추론목록 > 변화탐지 실행 정보 입력 > 년도 목록 조회")
   @ApiResponses(
       value = {
         @ApiResponse(
@@ -130,7 +132,8 @@ public class InferenceResultApiController {
     return ApiResponseDto.ok(mapSheetMngService.findMapSheetMngDoneYyyyList());
   }
 
-  @Operation(summary = "변화탐지 실행 정보 입력", description = "어드민 홈 > 추론관리 > 추론목록 > 변화탐지 실행 정보 입력")
+  /** 변화탐지 실행 정보 입력화면에서 호출 */
+  @Operation(summary = "변화탐지 실행 정보 입력, 추론실행", description = "추론관리 > 추론목록 > 변화탐지 실행 정보 입력")
   @ApiResponses(
       value = {
         @ApiResponse(
@@ -155,7 +158,8 @@ public class InferenceResultApiController {
     return ApiResponseDto.ok(uuid);
   }
 
-  @Operation(summary = "추론 종료", description = "추론 종료")
+  /** 추론진행 현황 화면에서 호출 */
+  @Operation(summary = "추론 종료", description = "추론관리 > 추론목록 > 추론진행 현황")
   @ApiResponses(
       value = {
         @ApiResponse(
@@ -174,7 +178,8 @@ public class InferenceResultApiController {
     return ApiResponseDto.ok(uuid);
   }
 
-  @Operation(summary = "분석 모델 선택 조회", description = "변화탐지 실행 정보 입력 모델선택 팝업 ")
+  /** 변화탐지 실행 정보 입력화면에서 호출 */
+  @Operation(summary = "분석 모델 선택 조회", description = "추론관리 > 추론목록 > 변화탐지 실행 정보 입력 > 모델선택 팝업 ")
   @ApiResponses(
       value = {
         @ApiResponse(
@@ -205,7 +210,8 @@ public class InferenceResultApiController {
     return ApiResponseDto.ok(result);
   }
 
-  @Operation(summary = "추론관리 추론진행 서버 현황", description = "추론관리 추론진행 서버 현황")
+  /** 추론진행 현황 화면에서 호출 */
+  @Operation(summary = "추론관리 추론진행 서버 현황", description = "추론관리 > 추론목록 > 추론진행 현황")
   @ApiResponses(
       value = {
         @ApiResponse(
@@ -224,7 +230,8 @@ public class InferenceResultApiController {
     return ApiResponseDto.ok(inferenceResultService.getInferenceServerStatusList());
   }
 
-  @Operation(summary = "추론관리 진행현황 상세", description = "어드민 홈 > 추론관리 > 추론관리 > 진행현황 상세")
+  /** 추론진행 현황 화면에서 호출 */
+  @Operation(summary = "추론관리 진행현황 상세", description = "추론관리 > 추론진행 현황")
   @ApiResponses(
       value = {
         @ApiResponse(
@@ -248,7 +255,8 @@ public class InferenceResultApiController {
     return ApiResponseDto.ok(inferenceResultService.getInferenceStatus(uuid));
   }
 
-  @Operation(summary = "추론결과 기본정보", description = "추론결과 기본정보")
+  /** 추론결과 화면에서 호출 */
+  @Operation(summary = "추론결과 기본정보", description = "추론관리 > 추론결과")
   @ApiResponses(
       value = {
         @ApiResponse(
@@ -269,7 +277,8 @@ public class InferenceResultApiController {
     return ApiResponseDto.ok(inferenceResultService.getInferenceResultInfo(uuid));
   }
 
-  @Operation(summary = "추론결과 분류별 탐지 건수", description = "추론결과 분류별 탐지 건수")
+  /** 추론결과 화면에서 호출 */
+  @Operation(summary = "추론결과 분류별 탐지 건수", description = "추론관리 > 추론결과")
   @ApiResponses(
       value = {
         @ApiResponse(
@@ -290,6 +299,7 @@ public class InferenceResultApiController {
     return ApiResponseDto.ok(inferenceResultService.getInferenceClassCountList(uuid));
   }
 
+  /** 추론결과 화면에서 호출 */
   @Operation(summary = "추론관리 분석결과 상세 목록", description = "추론관리 분석결과 상세 목록 geojson 데이터 조회")
   @ApiResponses(
       value = {
@@ -329,26 +339,14 @@ public class InferenceResultApiController {
     return ApiResponseDto.ok(geomList);
   }
 
-  @Operation(
-      summary = "shp 파일 다운로드",
-      description = "추론관리 분석결과 shp 파일 다운로드",
-      parameters = {
-        @Parameter(
-            name = "kamco-download-uuid",
-            in = ParameterIn.HEADER,
-            required = true,
-            description = "다운로드 요청 UUID",
-            schema =
-                @Schema(
-                    type = "string",
-                    format = "uuid",
-                    example = "69c4e56c-e0bf-4742-9225-bba9aae39052"))
-      })
+  /** 추론결과 화면에서 호출 */
+  /** 다운로드는 a 링크로 받는걸로 변경되어 사번을 파라미터로 받아서 로그에 저장하는걸로 변경함 */
+  @Operation(summary = "shp 파일 다운로드", description = "추론관리 분석결과 shp 파일 다운로드")
   @ApiResponses(
       value = {
         @ApiResponse(
             responseCode = "200",
-            description = "shp zip파일 다운로드",
+            description = "shp 파일 다운로드",
             content =
                 @Content(
                     mediaType = "application/octet-stream",
@@ -357,13 +355,16 @@ public class InferenceResultApiController {
         @ApiResponse(responseCode = "500", description = "서버 오류", content = @Content)
       })
   @GetMapping("/download/{uuid}")
-  public ResponseEntity<?> download(@PathVariable UUID uuid, HttpServletRequest request)
+  public ResponseEntity<?> download(
+      @PathVariable UUID uuid,
+      @Parameter(description = "사번", example = "123456") @RequestParam String employeeNo,
+      HttpServletRequest request)
       throws IOException {
-
     String path;
     String uid;
 
     try {
+      // 추론결과 shp zip 파일 확인하여 다운로드 경로 생성
       Map<String, Object> map = inferenceResultService.shpDownloadPath(uuid);
       path = String.valueOf(map.get("path"));
       uid = String.valueOf(map.get("uid"));
@@ -373,10 +374,10 @@ public class InferenceResultApiController {
 
     Path zipPath = Path.of(path);
 
-    // Range + 200/206/416 공통 처리 (추가 헤더 포함)
     return rangeDownloadResponder.buildZipResponse(zipPath, uid + ".zip", request);
   }
 
+  /** 추론결과 화면에서 호출 */
   @Operation(summary = "shp 파일 다운로드 이력 조회", description = "추론관리 분석결과 shp 파일 다운로드 이력 조회")
   @GetMapping(value = "/download-audit/{uuid}")
   @ApiResponses(
@@ -419,7 +420,8 @@ public class InferenceResultApiController {
     return ApiResponseDto.ok(inferenceResultService.getDownloadAudit(searchReq, downloadReq));
   }
 
-  @Operation(summary = "추론 실행중인 도엽 목록", description = "추론관리 실행중인 도엽명 5k 목록")
+  /** 추론진행 현황 화면에서 호출, 분석도엽 부분 옵션일때 분석중인 도엽 확인용 */
+  @Operation(summary = "추론관리 분석중인 도엽명 5k 목록", description = "추론관리 분석중인 도엽명 50k 목록")
   @ApiResponses({
     @ApiResponse(
         responseCode = "200",

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

@@ -1,7 +1,5 @@
 package com.kamco.cd.kamcoback.inference;
 
-import com.kamco.cd.kamcoback.common.exception.CustomApiException;
-import com.kamco.cd.kamcoback.common.geometry.GeoJsonFileWriter.Scene;
 import com.kamco.cd.kamcoback.config.api.ApiResponseDto;
 import com.kamco.cd.kamcoback.inference.dto.InferenceResultShpDto;
 import com.kamco.cd.kamcoback.inference.service.InferenceResultShpService;
@@ -12,15 +10,11 @@ import io.swagger.v3.oas.annotations.media.Schema;
 import io.swagger.v3.oas.annotations.responses.ApiResponse;
 import io.swagger.v3.oas.annotations.responses.ApiResponses;
 import io.swagger.v3.oas.annotations.tags.Tag;
-import java.util.List;
-import java.util.Map;
 import java.util.UUID;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.log4j.Log4j2;
-import org.springframework.http.HttpStatus;
 import org.springframework.web.bind.annotation.PathVariable;
 import org.springframework.web.bind.annotation.PostMapping;
-import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;
 
@@ -62,29 +56,4 @@ public class InferenceResultShpApiController {
     inferenceResultShpService.createShp(uuid);
     return ApiResponseDto.createOK(null);
   }
-
-  @Operation(summary = "추론실행에 필요한 geojson 파일 생성", description = "추론실행에 필요한 geojson 파일 생성")
-  @PostMapping("/geojson/{yyyy}/{mapSheetScope}/{detectOption}")
-  public ApiResponseDto<Scene> createGeojson(
-      @Schema(description = "년도") @PathVariable String yyyy,
-      @Schema(description = "전체(ALL),부분(PART)", example = "PART") @PathVariable
-          String mapSheetScope,
-      @Schema(description = "추론제외(EXCL),이전 년도 도엽 사용(PREV)", example = "EXCL") @PathVariable
-          String detectOption,
-      @Schema(description = "5k도엽번호", example = MAP_ID) @RequestBody Map<String, Object> body) {
-
-    Object raw = body.get("mapIds");
-
-    if (raw == null) {
-      throw new CustomApiException("BAD_REQUEST", HttpStatus.BAD_REQUEST);
-    }
-
-    @SuppressWarnings("unchecked")
-    List<String> mapIds = (List<String>) raw;
-
-    Scene scene =
-        inferenceResultShpService.createGeojson(yyyy, mapSheetScope, detectOption, mapIds);
-
-    return ApiResponseDto.createOK(scene);
-  }
 }

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

@@ -1,11 +1,11 @@
 package com.kamco.cd.kamcoback.inference.service;
 
-import com.fasterxml.jackson.core.JsonProcessingException;
-import com.fasterxml.jackson.core.type.TypeReference;
-import com.fasterxml.jackson.databind.ObjectMapper;
 import com.kamco.cd.kamcoback.common.exception.CustomApiException;
+import com.kamco.cd.kamcoback.common.geometry.GeoJsonFileWriter;
 import com.kamco.cd.kamcoback.common.geometry.GeoJsonFileWriter.ImageFeature;
 import com.kamco.cd.kamcoback.common.geometry.GeoJsonFileWriter.Scene;
+import com.kamco.cd.kamcoback.common.inference.service.InferenceCommonService;
+import com.kamco.cd.kamcoback.common.inference.utils.GeoJsonValidator;
 import com.kamco.cd.kamcoback.common.utils.UserUtil;
 import com.kamco.cd.kamcoback.config.resttemplate.ExternalHttpClient;
 import com.kamco.cd.kamcoback.config.resttemplate.ExternalHttpClient.ExternalCallResult;
@@ -21,8 +21,7 @@ import com.kamco.cd.kamcoback.inference.dto.InferenceResultDto.DetectOption;
 import com.kamco.cd.kamcoback.inference.dto.InferenceResultDto.InferenceLearnDto;
 import com.kamco.cd.kamcoback.inference.dto.InferenceResultDto.InferenceServerStatusDto;
 import com.kamco.cd.kamcoback.inference.dto.InferenceResultDto.InferenceStatusDetailDto;
-import com.kamco.cd.kamcoback.inference.dto.InferenceResultDto.MapSheetFallbackYearDto;
-import com.kamco.cd.kamcoback.inference.dto.InferenceResultDto.MapSheetNumDto;
+import com.kamco.cd.kamcoback.inference.dto.InferenceResultDto.MapSheetScope;
 import com.kamco.cd.kamcoback.inference.dto.InferenceResultDto.ResultList;
 import com.kamco.cd.kamcoback.inference.dto.InferenceResultDto.SaveInferenceAiDto;
 import com.kamco.cd.kamcoback.inference.dto.InferenceResultDto.Status;
@@ -40,6 +39,8 @@ import com.kamco.cd.kamcoback.postgres.core.InferenceResultCoreService;
 import com.kamco.cd.kamcoback.postgres.core.MapSheetMngCoreService;
 import com.kamco.cd.kamcoback.postgres.core.ModelMngCoreService;
 import jakarta.validation.constraints.NotNull;
+import java.io.IOException;
+import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.time.ZonedDateTime;
@@ -76,14 +77,11 @@ public class InferenceResultService {
   private final MapSheetMngCoreService mapSheetMngCoreService;
   private final ModelMngCoreService modelMngCoreService;
   private final AuditLogCoreService auditLogCoreService;
+  private final InferenceCommonService inferenceCommonService;
 
   private final ExternalHttpClient externalHttpClient;
-  private final ObjectMapper objectMapper;
   private final UserUtil userUtil;
 
-  @Value("${inference.url}")
-  private String inferenceUrl;
-
   @Value("${inference.batch-url}")
   private String batchUrl;
 
@@ -94,7 +92,10 @@ public class InferenceResultService {
   private String datasetDir;
 
   @Value("${spring.profiles.active}")
-  private String profile;
+  private String activeEnv;
+
+  @Value("${inference.geojson-dir}")
+  private String inferenceDir;
 
   /**
    * 추론관리 목록
@@ -107,7 +108,7 @@ public class InferenceResultService {
   }
 
   /**
-   * 추론 진행중인지 확인
+   * 추론 진행중인지 확인, 변화탐지 설정 등록 버튼 활성화 여부에 필요함
    *
    * @return
    */
@@ -120,7 +121,7 @@ public class InferenceResultService {
   }
 
   /**
-   * 추론 실행 - 추론제외, 이전년도 도엽 사용 분기
+   * 추론 실행 - 추론제외, 이전연도 도엽 사용 분기
    *
    * @param req
    * @return
@@ -128,8 +129,11 @@ public class InferenceResultService {
   @Transactional
   public UUID run(InferenceResultDto.RegReq req) {
     if (req.getDetectOption().equals(DetectOption.EXCL.getId())) {
+      // 추론 제외 일때 EXCL
       return runExcl(req);
     }
+
+    // 이전연도 도엽 사용 일때 PREV
     return runPrev(req);
   }
 
@@ -140,38 +144,96 @@ public class InferenceResultService {
    * @return
    */
   public UUID runExcl(InferenceResultDto.RegReq req) {
-    // target 도엽  조회
-    List<MngListDto> targetDtoList = mapSheetMngCoreService.getHstMapSheetList(req);
+    // TODO 쿼리로 한번에 할수 있게 수정해야하나..
+    // 기준연도 실행가능 도엽 조회
+    List<MngListDto> targetMngList =
+        mapSheetMngCoreService.getMapSheetMngHst(
+            req.getTargetYyyy(), req.getMapSheetScope(), req.getMapSheetNum());
 
-    // target  리스트 추출 (null 제거 + 중복 제거)
-    List<String> targetList =
-        targetDtoList.stream()
+    //    List<MngListDto> mngList =
+    //        mapSheetMngCoreService.findExecutableSheets(
+    //            req.getCompareYyyy(),
+    //            req.getTargetYyyy(),
+    //            req.getMapSheetScope(),
+    //            req.getMapSheetNum());
+
+    if (targetMngList == null || targetMngList.isEmpty()) {
+      throw new CustomApiException("NOT_FOUND_MAP_SHEET_NUM", HttpStatus.NOT_FOUND);
+    }
+
+    // 비교연도 실행가능 도엽 조회
+    List<MngListDto> compareMngList =
+        mapSheetMngCoreService.getMapSheetMngHst(
+            req.getCompareYyyy(), req.getMapSheetScope(), req.getMapSheetNum());
+
+    if (compareMngList == null || compareMngList.isEmpty()) {
+      throw new CustomApiException("NOT_FOUND_COMPARE_YEAR", HttpStatus.NOT_FOUND);
+    }
+
+    // compare 도엽번호 Set 구성
+    Set<String> compareSet =
+        compareMngList.stream()
+            .map(MngListDto::getMapSheetNum)
+            .filter(Objects::nonNull)
+            .collect(Collectors.toSet());
+
+    // 기준년도 비교년도 동일한 도엽번호만 담기
+    List<MngListDto> intersectionList =
+        targetMngList.stream()
+            .filter(dto -> dto.getMapSheetNum() != null)
+            .filter(dto -> compareSet.contains(dto.getMapSheetNum()))
+            .toList();
+
+    log.info("target size = {}", targetMngList.size());
+    log.info("compare size = {}", compareMngList.size());
+    log.info("intersection size = {}", intersectionList.size());
+
+    // 비교 연도 도엽번호를 꺼내와서 최종 추론 대상 도엽번호를 담기
+    List<String> mapSheetNums =
+        intersectionList.stream()
             .map(MngListDto::getMapSheetNum)
             .filter(Objects::nonNull)
             .distinct()
             .toList();
 
-    // compare 도엽번호 리스트 조회 (null 제거 + 중복 제거)
-    List<String> compareList =
-        mapSheetMngCoreService.getMapSheetNumByHst(req.getCompareYyyy()).stream()
-            .filter(Objects::nonNull)
-            .distinct()
-            .toList();
+    int targetTotal = targetMngList.size();
+    int compareTotal = compareMngList.size();
+    int intersection = intersectionList.size();
 
-    // compare 기준
-    Set<String> compareSet = new HashSet<>(compareList);
+    // ===== MapSheet Year Comparison =====
+    // target Total               : 기준연도 실행가능 전체 도엽 수
+    // compare Total              : 비교연도 실행가능 전체 도엽 수
+    // Intersection               : 양 연도에 모두 존재하는 도엽 수 (최종 추론 대상)
+    // target Only (Excluded)     : 기준연도에만 존재하고 비교연도에는 없는 도엽 수
+    // compare Only               : 비교연도에만 존재하고 기준연도에는 없는 도엽 수
+    // ====================================
 
-    // target 기준으로 compare에 존재하는 도엽만 필터링
-    List<String> filteredTargetList = targetList.stream().filter(compareSet::contains).toList();
+    log.info(
+        """
+    ===== MapSheet Year Comparison =====
+    target Total: {}
+    compare Total: {}
+    Intersection: {}
+    target Only (Excluded): {}
+    compare Only: {}
+    ====================================
+    """,
+        targetTotal,
+        compareTotal,
+        intersection,
+        targetTotal - intersection,
+        compareTotal - intersection);
 
-    // 도엽 비교 로그 출력
-    logYearComparison(targetList, compareList, filteredTargetList);
+    if (mapSheetNums.isEmpty()) {
+      // 추론 가능한 도엽이 없습니다.
+      throw new CustomApiException("NOT_FOUND_MAP_SHEET_NUM", HttpStatus.NOT_FOUND);
+    }
 
     // compare geojson 파일 생성
     Scene compareScene =
         getSceneInference(
             req.getCompareYyyy().toString(), // 기준년도
-            filteredTargetList, // 교집합 도엽
+            mapSheetNums, // 최종 추론 대상
             req.getMapSheetScope(), // ALL / 부분
             req.getDetectOption()); // EXCL / PREV
 
@@ -179,15 +241,20 @@ public class InferenceResultService {
     Scene targetScene =
         getSceneInference(
             req.getTargetYyyy().toString(), // 대상년도
-            filteredTargetList, // 교집합 도엽
+            mapSheetNums, // 최종 추론 대상
             req.getMapSheetScope(),
             req.getDetectOption());
 
+    log.info("비교년도 geojson 파일 validation ===== {}", compareScene.getFilePath());
+    GeoJsonValidator.validateWithRequested(compareScene.getFilePath(), mapSheetNums);
+    log.info("기준년도 geojson 파일 validation ===== {}", targetScene.getFilePath());
+    GeoJsonValidator.validateWithRequested(targetScene.getFilePath(), mapSheetNums);
+
     // 추론 실행
     return executeInference(
         req,
-        targetDtoList, // 전체 target 목록
-        filteredTargetList, // 최종 추론 대상
+        intersectionList, // 전체 target 목록
+        mapSheetNums, // 최종 추론 대상
         compareScene, // compare geojson
         targetScene // target geojson
         );
@@ -201,91 +268,123 @@ public class InferenceResultService {
    */
   @Transactional
   public UUID runPrev(InferenceResultDto.RegReq req) {
-    // target 목록 조회
-    List<MngListDto> targetDtoList = mapSheetMngCoreService.getHstMapSheetList(req);
+    // TODO 쿼리로 한번에 할수 있게 수정해야하나..
+    // 기준연도 실행가능 도엽 조회
+    List<MngListDto> targetMngList =
+        mapSheetMngCoreService.getMapSheetMngHst(
+            req.getTargetYyyy(), req.getMapSheetScope(), req.getMapSheetNum());
 
-    // target 도엽번호 리스트 추출 중복 제거
-    List<String> targetList =
-        targetDtoList.stream()
+    if (targetMngList == null || targetMngList.isEmpty()) {
+      throw new CustomApiException("NOT_FOUND_TARGET_YEAR", HttpStatus.NOT_FOUND);
+    }
+
+    // 비교연도 실행가능 도엽 조회
+    List<MngListDto> compareMngList =
+        mapSheetMngCoreService.getMapSheetMngHst(
+            req.getCompareYyyy(), req.getMapSheetScope(), req.getMapSheetNum());
+
+    if (compareMngList == null || compareMngList.isEmpty()) {
+      throw new CustomApiException("NOT_FOUND_COMPARE_YEAR", HttpStatus.NOT_FOUND);
+    }
+
+    log.info("targetMngList size = {}", targetMngList.size());
+    log.info("compareMngList size = {}", compareMngList.size());
+    log.info("Difference in count = {}", targetMngList.size() - compareMngList.size());
+
+    // 로그용 원본 카운트 (이전도엽 추가 전)
+    int targetTotal = targetMngList.size();
+    int compareTotalBeforeFallback = compareMngList.size();
+
+    // 기준연도 기준 비교연도 구해서 이전년도로 compare 보완 하기위해서 도엽번호만 정리
+    Set<String> compareSet0 =
+        compareMngList.stream()
             .map(MngListDto::getMapSheetNum)
             .filter(Objects::nonNull)
-            .distinct()
-            .toList();
-
-    // compare 목록 조회
-    List<MapSheetFallbackYearDto> compareDtoList =
-        new ArrayList<>(mapSheetMngCoreService.getMapSheetNumDtoByHst(req.getCompareYyyy()));
-
-    // compare 도엽번호 Set 구성
-    Set<String> compareSet =
-        compareDtoList.stream()
-            .map(MapSheetFallbackYearDto::getMapSheetNum)
-            .filter(Objects::nonNull)
             .collect(Collectors.toSet());
 
-    // target에는 있으나 compare에는 없는 도엽 추출
-    List<String> remainingTargetList =
-        targetList.stream().filter(s -> !compareSet.contains(s)).toList();
+    // 기준연도 기준 비교연도에 도협번호가 없으면 이전연도 조회해서 compare 보완, 없는거 담기
+    List<String> targetOnlyMapSheetNums =
+        targetMngList.stream()
+            .map(MngListDto::getMapSheetNum)
+            .filter(Objects::nonNull)
+            .filter(num -> !compareSet0.contains(num))
+            .toList();
 
-    // compare에 없을때 이전 년도 사용 가능여부 조회
-    List<MapSheetFallbackYearDto> fallbackYearDtoList =
+    log.info("targetOnlyMapSheetNums in count = {}", targetOnlyMapSheetNums.size());
+
+    // 이전연도 초회 추가
+    compareMngList.addAll(
         mapSheetMngCoreService.findFallbackCompareYearByMapSheets(
-            req.getTargetYyyy(), // 대상년도 기준
-            remainingTargetList // compare에 없는 도엽들
-            );
+            req.getCompareYyyy(), targetOnlyMapSheetNums));
 
-    // 기존 compare , 사용가능 이전년도 정보 합치기
-    compareDtoList.addAll(fallbackYearDtoList);
+    log.info("fallback compare size= {}", compareMngList.size());
 
-    // 중복제거하여 사용할 compare 도엽 목록
-    Set<String> availableCompareSheets =
-        compareDtoList.stream()
-            .map(MapSheetFallbackYearDto::getMapSheetNum)
+    // 이전연도 추가 후 compare 총 개수
+    int compareTotalAfterFallback = compareMngList.size();
+
+    // 이전연도 추가한 기준연도 값 도협번호만 담기
+    Set<String> compareSet1 =
+        compareMngList.stream()
+            .map(MngListDto::getMapSheetNum)
             .filter(Objects::nonNull)
             .collect(Collectors.toSet());
 
-    // 최종 추론 대상 도엽
-    // target 기준으로 compare 에 존재하는 도엽만 추출
-    List<String> filteredTargetList =
-        targetList.stream().filter(availableCompareSheets::contains).toList();
-
-    // compareDtoList도 최종 기준으로 필터
-    Set<String> filteredTargetSet = new HashSet<>(filteredTargetList);
-
-    List<MapSheetFallbackYearDto> filteredCompareDtoList =
-        compareDtoList.stream()
-            .filter(d -> d.getMapSheetNum() != null)
-            .filter(d -> filteredTargetSet.contains(d.getMapSheetNum()))
+    // 기준연도 기준으로 비교연도에 있는것만 담기 (도협번호) 결국 비교년도와 개수가 같아짐
+    List<String> mapSheetNums =
+        targetMngList.stream()
+            .map(MngListDto::getMapSheetNum)
+            .filter(Objects::nonNull)
+            .filter(compareSet1::contains)
             .toList();
 
-    // compare only 계산 (target에는 없는 compare 도엽 수) log 용
-    long compareOnlyCount =
-        compareDtoList.stream()
-            .map(MapSheetFallbackYearDto::getMapSheetNum)
-            .filter(s -> s != null && !targetList.contains(s))
-            .count();
+    int intersection = mapSheetNums.size();
+
+    Set<String> intersectionSet = new HashSet<>(mapSheetNums);
+
+    // 비교연도 같은거 담기(dto list)
+    compareMngList =
+        compareMngList.stream()
+            .filter(c -> c.getMapSheetNum() != null)
+            .filter(c -> intersectionSet.contains(c.getMapSheetNum()))
+            .toList();
+
+    // 기준연도 같은거 담기(dto list)
+    List<MngListDto> filteredTargetMngList =
+        targetMngList.stream()
+            .filter(t -> t.getMapSheetNum() != null)
+            .filter(t -> intersectionSet.contains(t.getMapSheetNum()))
+            .toList();
+
+    // 로그
+    int targetOnlyExcluded = targetTotal - intersection;
+    int compareOnly = compareTotalAfterFallback - intersection;
 
-    // 연도별 도엽 비교 로그 출력
     log.info(
         """
     ===== MapSheet Year Comparison =====
     target Total: {}
-    compare Total: {}
+    compare Total(before fallback): {}
+    compare Total(after fallback): {}
     Intersection: {}
     target Only (Excluded): {}
     compare Only: {}
     ====================================
     """,
-        targetList.size(), // target count
-        compareDtoList.size(), // compare count
-        filteredTargetList.size(), // target 기준으로 compare 비교하여 최종 추론할 도엽 count
-        targetList.size() - filteredTargetList.size(), // compare에 존재하지 않는 target 도엽 수
-        compareOnlyCount); // target 에 존재하지 않는 compare 도엽수
+        targetTotal,
+        compareTotalBeforeFallback,
+        compareTotalAfterFallback,
+        intersection,
+        targetOnlyExcluded,
+        compareOnly);
 
-    // compare 기준 geojson 생성 (년도 fallback 반영)
+    if (mapSheetNums.isEmpty()) {
+      throw new CustomApiException("NOT_FOUND_MAP_SHEET_NUM", HttpStatus.NOT_FOUND);
+    }
+
+    // compare 기준 geojson 생성
     Scene compareScene =
         getSceneInference(
-            filteredCompareDtoList,
+            compareMngList,
             req.getCompareYyyy().toString(),
             req.getMapSheetScope(),
             req.getDetectOption());
@@ -294,12 +393,18 @@ public class InferenceResultService {
     Scene targetScene =
         getSceneInference(
             req.getTargetYyyy().toString(),
-            filteredTargetList,
+            mapSheetNums,
             req.getMapSheetScope(),
             req.getDetectOption());
 
-    // AI 추론 실행
-    return executeInference(req, targetDtoList, filteredTargetList, compareScene, targetScene);
+    log.info("비교년도 geojson 파일 validation ===== {}", compareScene.getFilePath());
+    GeoJsonValidator.validateWithRequested(compareScene.getFilePath(), mapSheetNums);
+
+    log.info("기준년도 geojson 파일 validation ===== {}", targetScene.getFilePath());
+    GeoJsonValidator.validateWithRequested(targetScene.getFilePath(), mapSheetNums);
+
+    // 추론 실행
+    return executeInference(req, filteredTargetMngList, mapSheetNums, compareScene, targetScene);
   }
 
   /**
@@ -326,20 +431,24 @@ public class InferenceResultService {
             .filter(m -> filteredSet.contains(m.getMapSheetNum()))
             .toList();
 
+    // 추론 실행 목록 테이블 저장, 도엽목록별 상태 체크 테이블 저장
     UUID uuid = inferenceResultCoreService.saveInferenceInfo(req, newTargetList);
 
+    // 추론 AI 전달 파라미터 생성
     pred_requests_areas predRequestsAreas = new pred_requests_areas();
     predRequestsAreas.setInput1_year(req.getCompareYyyy());
     predRequestsAreas.setInput2_year(req.getTargetYyyy());
     predRequestsAreas.setInput1_scene_path(modelComparePath.getFilePath());
     predRequestsAreas.setInput2_scene_path(modelTargetPath.getFilePath());
 
+    // 모델정보 조회 dto 생성 후 반환
     InferenceSendDto m1 = this.getModelInfo(req.getModel1Uuid());
     m1.setPred_requests_areas(predRequestsAreas);
 
     log.info("[INFERENCE] Start m1 = {}", m1);
 
-    Long batchId = ensureAccepted(m1);
+    // AI 호출
+    Long batchId = inferenceCommonService.ensureAccepted(m1);
 
     SaveInferenceAiDto saveInferenceAiDto = new SaveInferenceAiDto();
     saveInferenceAiDto.setUuid(uuid);
@@ -351,43 +460,14 @@ public class InferenceResultService {
     saveInferenceAiDto.setModelTargetPath(modelTargetPath.getFilePath());
     saveInferenceAiDto.setModelStartDttm(ZonedDateTime.now());
 
+    // AI 호출 하고 리턴 받은 정보 추론 실행 목록 테이블에 업데이트
     inferenceResultCoreService.update(saveInferenceAiDto);
 
     return uuid;
   }
 
   /**
-   * EXCL 로그
-   *
-   * @param targetList
-   * @param compareList
-   * @param filteredTargetList
-   */
-  private void logYearComparison(
-      List<String> targetList, List<String> compareList, List<String> filteredTargetList) {
-    Set<String> targetSet = new HashSet<>(targetList);
-
-    long compareOnlyCount = compareList.stream().filter(s -> !targetSet.contains(s)).count();
-
-    log.info(
-        """
-    ===== MapSheet Year Comparison =====
-    target Total: {}
-    compare Total: {}
-    Intersection: {}
-    target Only (Excluded): {}
-    compare Only: {}
-    ====================================
-    """,
-        targetList.size(), // target count
-        compareList.size(), // compare count
-        filteredTargetList.size(), // target 기준으로 compare 비교하여 최종 추론할 도엽 count
-        targetList.size() - filteredTargetList.size(), // compare에 존재하지 않는 target 도엽 수
-        compareOnlyCount); // target 에 존재하지 않는 compare 도엽수
-  }
-
-  /**
-   * 변화탐지 실행 정보 생성
+   * 변화탐지 실행 정보 생성 TODO 미사용, 새로운 추론실행 로직 테스트후 삭제 해야합니다.
    *
    * @param req
    */
@@ -395,7 +475,7 @@ public class InferenceResultService {
   public UUID saveInferenceInfo(InferenceResultDto.RegReq req) {
 
     // 변화탐지 실행 가능 기준 년도 조회
-    List<MngListDto> targetList = mapSheetMngCoreService.getHstMapSheetList(req);
+    List<MngListDto> targetList = null; // mapSheetMngCoreService.getHstMapSheetList(req);
 
     if (targetList.isEmpty()) {
       throw new CustomApiException("NOT_FOUND_TARGET_YEAR", HttpStatus.NOT_FOUND);
@@ -513,7 +593,7 @@ public class InferenceResultService {
     m1.setPred_requests_areas(predRequestsAreas);
 
     // ai 추론 실행 api 호출
-    Long batchId = ensureAccepted(m1);
+    Long batchId = inferenceCommonService.ensureAccepted(m1);
 
     // ai 추론 실행후 응답값 update
     SaveInferenceAiDto saveInferenceAiDto = new SaveInferenceAiDto();
@@ -530,145 +610,6 @@ public class InferenceResultService {
     return uuid;
   }
 
-  // 비교년도 탐지 제이터 옵션 별로 조회하여 req에 적용
-  private List<MapSheetNumDto> createdMngDto(
-      InferenceResultDto.RegReq req, List<MngListDto> targetList) {
-    List<String> mapTargetIds = new ArrayList<>();
-
-    targetList.forEach(
-        hstMapSheet -> {
-          // 비교년도는 target 년도 기준으로 가져옴 파라미터 만들기
-          mapTargetIds.add(hstMapSheet.getMapSheetNum());
-        });
-
-    // 비교년도 조회
-    List<String> mapCompareIds = new ArrayList<>();
-    List<MngListCompareDto> compareList =
-        mapSheetMngCoreService.getByHstMapSheetCompareList(req.getCompareYyyy(), mapTargetIds);
-
-    for (MngListCompareDto dto : compareList) {
-      // 추론 제외일때 이전년도 파일이 없으면 제외
-      if (req.getDetectOption().equals(DetectOption.EXCL.getId())) {
-        int targetYear = req.getTargetYyyy() - 1;
-        if (dto.getBeforeYear() != targetYear) {
-          continue;
-        }
-      }
-      // 비교년도는 target 년도 기준으로 가져옴
-      mapCompareIds.add(dto.getMapSheetNum());
-    }
-
-    Set<String> compareSet =
-        mapCompareIds.stream()
-            .filter(Objects::nonNull)
-            .map(String::trim) // 공백/개행 방지
-            .collect(Collectors.toSet());
-
-    // target 기준 compare 비교하여 서로 있는것만 저장
-    List<String> commonIds =
-        mapTargetIds.stream()
-            .filter(Objects::nonNull)
-            .map(String::trim)
-            .filter(compareSet::contains)
-            .toList();
-
-    Set<String> commonIdSet =
-        commonIds.stream().filter(Objects::nonNull).map(String::trim).collect(Collectors.toSet());
-
-    // 저장하기위해 파라미터 다시 구성
-    List<MapSheetNumDto> mapSheetNum =
-        targetList.stream()
-            .filter(dto -> dto.getMapSheetNum() != null)
-            .filter(dto -> commonIdSet.contains(dto.getMapSheetNum().trim()))
-            .map(
-                dto -> {
-                  MapSheetNumDto mapSheetNumDto = new MapSheetNumDto();
-                  mapSheetNumDto.setMapSheetNum(dto.getMapSheetNum());
-                  mapSheetNumDto.setMapSheetName(dto.getMapSheetName());
-                  return mapSheetNumDto;
-                })
-            .toList();
-
-    return mapSheetNum;
-  }
-
-  /**
-   * 추론 AI API 호출 batch id를 리턴
-   *
-   * @param dto
-   */
-  // 같은함수가 왜 두개지
-  private Long ensureAccepted(InferenceSendDto dto) {
-
-    if (dto == null) {
-      log.warn("not InferenceSendDto dto");
-      throw new CustomApiException("BAD_REQUEST", HttpStatus.BAD_REQUEST);
-    }
-
-    // [중복]운영환경일때 경로수정 dean 260226
-    if (profile != null && profile.equals("prod")) {
-      log.info("========================================================");
-      log.info("[CHANGE INFERENCE] profile = {}  Inforence req", profile);
-      log.info("========================================================");
-      log.info("");
-    }
-
-    // 1) 요청 로그
-    try {
-      log.debug("Inference request dto={}", objectMapper.writeValueAsString(dto));
-    } catch (JsonProcessingException e) {
-      log.warn("Failed to serialize inference dto", e);
-    }
-
-    // 2) local 환경 임시 처리
-    //    if ("local".equals(profile)) {
-    //      if (dto.getPred_requests_areas() == null) {
-    //        throw new IllegalStateException("pred_requests_areas is null");
-    //      }
-    //
-    // dto.getPred_requests_areas().setInput1_scene_path("/kamco-nfs/requests/2023_local.geojson");
-    //
-    // dto.getPred_requests_areas().setInput2_scene_path("/kamco-nfs/requests/2024_local.geojson");
-    //    }
-
-    // 3) HTTP 호출
-    HttpHeaders headers = new HttpHeaders();
-    headers.setContentType(MediaType.APPLICATION_JSON);
-    headers.setAccept(List.of(MediaType.APPLICATION_JSON));
-
-    // 추론 실행 API 호출
-    ExternalCallResult<String> result =
-        externalHttpClient.call(inferenceUrl, HttpMethod.POST, dto, headers, String.class);
-
-    if (result.statusCode() < 200 || result.statusCode() >= 300) {
-      log.error("Inference API failed. status={}, body={}", result.statusCode(), result.body());
-      throw new CustomApiException("BAD_GATEWAY", HttpStatus.BAD_GATEWAY);
-    }
-
-    // 4) 응답 파싱
-    try {
-      List<Map<String, Object>> list =
-          objectMapper.readValue(result.body(), new TypeReference<>() {});
-
-      if (list.isEmpty()) {
-        throw new CustomApiException(
-            "NOT_FOUND", HttpStatus.NOT_FOUND, "Inference response is empty");
-      }
-
-      Object batchIdObj = list.get(0).get("batch_id");
-      if (batchIdObj == null) {
-        throw new CustomApiException(
-            "NOT_FOUND", HttpStatus.NOT_FOUND, "batch_id not found in response");
-      }
-
-      return Long.valueOf(batchIdObj.toString());
-
-    } catch (Exception e) {
-      log.error("Failed to parse inference response. body={}", result.body(), e);
-      throw new CustomApiException("INVALID_INFERENCE_RESPONSE", HttpStatus.BAD_GATEWAY);
-    }
-  }
-
   /**
    * 모델정보 조회 dto 생성 후 반환
    *
@@ -731,25 +672,36 @@ public class InferenceResultService {
    */
   private Scene getSceneInference(
       String yyyy, List<String> mapSheetNums, String mapSheetScope, String detectOption) {
-    return mapSheetMngCoreService.getSceneInference(
-        yyyy, mapSheetNums, mapSheetScope, detectOption);
+
+    // geojson 생성시 필요한 영상파일 정보 조회
+    List<ImageFeature> features =
+        mapSheetMngCoreService.loadSceneInferenceBySheets(yyyy, mapSheetNums);
+
+    if (features == null || features.isEmpty()) {
+      log.warn(
+          "NOT_FOUND_MAP_SHEET_NUM : yyyy={}, scenesSize={}",
+          yyyy,
+          mapSheetNums == null ? 0 : mapSheetNums.size());
+      throw new CustomApiException("NOT_FOUND_MAP_SHEET_NUM", HttpStatus.NOT_FOUND);
+    }
+    return writeSceneGeoJson(yyyy, mapSheetScope, detectOption, features);
   }
 
   /**
    * 년도 별로 조회하여 geojson 파일 생성
    *
    * @param yearDtos
-   * @param year
+   * @param yyyy
    * @param mapSheetScope
    * @param detectOption
    * @return
    */
   private Scene getSceneInference(
-      List<MapSheetFallbackYearDto> yearDtos,
-      String year,
-      String mapSheetScope,
-      String detectOption) {
-    return mapSheetMngCoreService.getSceneInference(yearDtos, year, mapSheetScope, detectOption);
+      List<MngListDto> yearDtos, String yyyy, String mapSheetScope, String detectOption) {
+
+    List<ImageFeature> features =
+        mapSheetMngCoreService.loadSceneInferenceByFallbackYears(yearDtos);
+    return writeSceneGeoJson(yyyy, mapSheetScope, detectOption, features);
   }
 
   /**
@@ -828,11 +780,17 @@ public class InferenceResultService {
     return inferenceResultCoreService.listGetScenes5k(id);
   }
 
+  /**
+   * 추론 서버 현황 cpu, gpu 확인
+   *
+   * @return 서버 정보
+   */
   public List<InferenceServerStatusDto> getInferenceServerStatusList() {
 
     String[] serverNames = inferenceServerName.split(",");
     int serveCnt = serverNames.length;
 
+    // 서버정보 조회
     List<InferenceServerStatusDto> dtoList =
         inferenceResultCoreService.getInferenceServerStatusList();
     int size = dtoList.size();
@@ -842,6 +800,7 @@ public class InferenceResultService {
     System.out.println("size =" + size);
 
     if (size == 0) {
+      // 서버 정보가 없을때
       for (int k = 0; k < serveCnt; k++) {
         InferenceServerStatusDto dto = new InferenceServerStatusDto();
         dto.setServerName(serverNames[k]);
@@ -909,17 +868,35 @@ public class InferenceResultService {
     return inferenceResultCoreService.getInferenceResultInfo(uuid);
   }
 
+  /**
+   * 분류별 탐지건수 조회
+   *
+   * @param uuid 추론 uuid
+   * @return 분류별 탐지건수 정보
+   */
   public List<Dashboard> getInferenceClassCountList(UUID uuid) {
     return inferenceResultCoreService.getInferenceClassCountList(uuid);
   }
 
+  /**
+   * 추론결과 geom 목록 조회
+   *
+   * @param uuid 추론 uuid
+   * @param searchGeoReq 추론 결과 상세화면 geom 조회 조건
+   * @return geom 목록 정보
+   */
   public Page<Geom> getInferenceGeomList(UUID uuid, SearchGeoReq searchGeoReq) {
     return inferenceResultCoreService.getInferenceGeomList(uuid, searchGeoReq);
   }
 
-  /** 추론 종료 */
+  /**
+   * 추론 종료
+   *
+   * @return 호출한 uuid
+   */
   @Transactional
   public UUID deleteInferenceEnd() {
+    // 추론 진행중인지 확인
     SaveInferenceAiDto dto = inferenceResultCoreService.getProcessing();
     if (dto == null) {
       throw new CustomApiException("NOT_FOUND", HttpStatus.NOT_FOUND);
@@ -931,13 +908,15 @@ public class InferenceResultService {
     headers.setContentType(MediaType.APPLICATION_JSON);
     headers.setAccept(List.of(MediaType.APPLICATION_JSON));
 
+    // 종료 api 호출
     ExternalCallResult<String> result =
-        externalHttpClient.call(url, HttpMethod.DELETE, dto, headers, String.class);
+        externalHttpClient.callLong(url, HttpMethod.DELETE, dto, headers, String.class);
 
     if (!result.success()) {
       throw new CustomApiException("BAD_GATEWAY", HttpStatus.BAD_GATEWAY);
     }
 
+    // 추론 정보 테이블 update
     SaveInferenceAiDto request = new SaveInferenceAiDto();
     request.setStatus(Status.FORCED_END.getId());
     request.setUuid(dto.getUuid());
@@ -952,14 +931,17 @@ public class InferenceResultService {
   }
 
   /**
-   * 추론결과 shp zip 파일 다운로드 경로 생성
+   * 추론결과 shp zip 파일 확인하여 다운로드 경로 생성
    *
-   * @param uuid
-   * @return
+   * @param uuid 추론 uuid
+   * @return 32자 추론 uid, shp 파일 경로
    */
   public Map<String, Object> shpDownloadPath(UUID uuid) {
+    // 추론정보 조회
     InferenceLearnDto dto = inferenceResultCoreService.getInferenceUid(uuid);
     String uid = dto.getUid();
+
+    // 파일 경로 생성
     Path path = Path.of(datasetDir).resolve(uid).resolve("merge").resolve(uid + ".zip");
 
     Map<String, Object> downloadMap = new HashMap<>();
@@ -981,7 +963,7 @@ public class InferenceResultService {
   }
 
   /**
-   * 실행중인 추론 도엽명 목록
+   * 분석중인 추론 도엽명 목록
    *
    * @param uuid uuid
    * @return
@@ -989,4 +971,69 @@ public class InferenceResultService {
   public List<String> getInferenceRunMapId(UUID uuid) {
     return inferenceResultCoreService.getInferenceRunMapId(uuid);
   }
+
+  /**
+   * 파일 경로/이름 , 파일 생성 , 도엽번호 반환
+   *
+   * @param yyyy
+   * @param mapSheetScope
+   * @param detectOption
+   * @param sceneInference
+   * @return Scene
+   */
+  private Scene writeSceneGeoJson(
+      String yyyy, String mapSheetScope, String detectOption, List<ImageFeature> sceneInference) {
+
+    boolean isAll = MapSheetScope.ALL.getId().equals(mapSheetScope);
+    String optionSuffix = buildOptionSuffix(detectOption);
+
+    String targetDir =
+        "local".equals(activeEnv) ? System.getProperty("user.home") + "/geojson" : inferenceDir;
+
+    // 파일명 생성
+    String filename =
+        isAll
+            ? String.format("%s_%s_ALL%s.geojson", yyyy, activeEnv, optionSuffix)
+            : String.format("%s_%s%s.geojson", yyyy, activeEnv, optionSuffix);
+
+    Path outputPath = Paths.get(targetDir, filename);
+
+    try {
+      log.info("create Directories outputPath: {}", outputPath);
+      log.info(
+          "activeEnv={}, inferenceDir={}, targetDir={}, filename={}",
+          activeEnv,
+          inferenceDir,
+          targetDir,
+          filename);
+      log.info("outputPath={}, parent={}", outputPath.toAbsolutePath(), outputPath.getParent());
+
+      Files.createDirectories(outputPath.getParent());
+
+      new GeoJsonFileWriter()
+          .exportToFile(sceneInference, "scene_inference_" + yyyy, 5186, outputPath.toString());
+
+      Scene scene = new Scene();
+      scene.setFeatures(sceneInference);
+      scene.setFilePath(outputPath.toString());
+      return scene;
+
+    } catch (IOException e) {
+      log.error(
+          "FAIL_CREATE_MAP_SHEET_FILE: yyyy={}, isAll={}, path={}", yyyy, isAll, outputPath, e);
+      throw new CustomApiException("INTERNAL_SERVER_ERROR", HttpStatus.INTERNAL_SERVER_ERROR, e);
+    }
+  }
+
+  /**
+   * geojson 파일명 Suffix
+   *
+   * @param detectOption
+   * @return
+   */
+  private String buildOptionSuffix(String detectOption) {
+    if (DetectOption.EXCL.getId().equals(detectOption)) return "_EXCL";
+    if (DetectOption.PREV.getId().equals(detectOption)) return "_PREV";
+    return "";
+  }
 }

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

@@ -1,13 +1,11 @@
 package com.kamco.cd.kamcoback.inference.service;
 
-import com.kamco.cd.kamcoback.common.geometry.GeoJsonFileWriter.Scene;
 import com.kamco.cd.kamcoback.inference.dto.InferenceResultDto.InferenceLearnDto;
 import com.kamco.cd.kamcoback.inference.dto.InferenceResultShpDto;
 import com.kamco.cd.kamcoback.postgres.core.InferenceResultCoreService;
 import com.kamco.cd.kamcoback.postgres.core.InferenceResultShpCoreService;
 import com.kamco.cd.kamcoback.postgres.core.MapSheetMngCoreService;
 import com.kamco.cd.kamcoback.scheduler.service.ShpPipelineService;
-import java.util.List;
 import java.util.Objects;
 import java.util.UUID;
 import java.util.stream.Collectors;
@@ -66,21 +64,4 @@ public class InferenceResultShpService {
     // shp 파일 비동기 생성
     shpPipelineService.runPipeline(jarPath, datasetDir, batchId, dto.getUid());
   }
-
-  /**
-   * 추론 실행전 geojson 파일 생성
-   *
-   * @param yyyy
-   * @param mapSheetScope
-   * @param detectOption
-   * @param mapIds
-   * @return
-   */
-  public Scene createGeojson(
-      String yyyy, String mapSheetScope, String detectOption, List<String> mapIds) {
-    Scene getSceneInference =
-        mapSheetMngCoreService.getSceneInference(yyyy, mapIds, mapSheetScope, detectOption);
-    log.info("getSceneInference: {}", getSceneInference);
-    return getSceneInference;
-  }
 }

src/main/java/com/kamco/cd/kamcoback/mapsheet/service/MapSheetMngService.java

@@ -381,6 +381,11 @@ public class MapSheetMngService {
     mapSheetMngCoreService.getSceneInference(yyyy);
   }
 
+  /**
+   * 연도 목록 조회
+   *
+   * @return
+   */
   public List<MngYyyyDto> findMapSheetMngDoneYyyyList() {
 
     List<MngDto> mngList = mapSheetMngCoreService.findMapSheetMngList();

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

@@ -41,6 +41,16 @@ public class ModelMngService {
   @Value("${file.pt-FileName}")
   private String ptFileName;
 
+  /**
+   * 모델조회
+   *
+   * @param searchReq 페이징
+   * @param startDate 시작날짜
+   * @param endDate 종료날짜
+   * @param modelType 모델 타입 G1, G2, G3
+   * @param searchVal 모델 ver
+   * @return 모델 목록
+   */
   public Page<ModelMngDto.ModelList> findModelMgmtList(
       ModelMngDto.searchReq searchReq,
       LocalDate startDate,

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

@@ -46,6 +46,13 @@ public class AuditLogCoreService
     return auditLogRepository.findLogByAccount(searchRange, searchValue);
   }
 
+  /**
+   * 다운로드 이력 조회
+   *
+   * @param searchReq 페이징 파라미터
+   * @param downloadReq 다운로드 이력 팝업 검색 조건
+   * @return 다운로드 이력 정보 목록
+   */
   public Page<AuditLogDto.DownloadRes> findLogByAccount(
       AuditLogDto.searchReq searchReq, DownloadReq downloadReq) {
     return auditLogRepository.findDownloadLog(searchReq, downloadReq);

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

@@ -79,12 +79,13 @@ public class InferenceResultCoreService {
   }
 
   /**
-   * 변화탐지 실행 정보 생성
+   * 변화탐지 실행 정보 생성 - 추론 실행 목록 테이블 저장, 도엽목록별 상태 체크 테이블 저장
    *
-   * @param req
+   * @param req 추론 실행 목록 uuid
    */
   public UUID saveInferenceInfo(InferenceResultDto.RegReq req, List<MngListDto> targetList) {
 
+    // 대표 도엽명 외 N 건 실행 문구 만들기 위해 Null, 중복 제거
     List<MngListDto> distinctList =
         targetList.stream()
             .filter(dto -> dto.getMapSheetName() != null && !dto.getMapSheetName().isBlank())
@@ -124,17 +125,13 @@ public class InferenceResultCoreService {
     mapSheetLearnEntity.setDetectingCnt(0L);
     mapSheetLearnEntity.setTotalJobs((long) targetList.size());
 
-    // 회차는 국유인 반영할때 update로 변경됨
-    //    mapSheetLearnEntity.setStage(
-    //        mapSheetLearnRepository.getLearnStage(req.getCompareYyyy(), req.getTargetYyyy()));
-
     // learn 테이블 저장
     MapSheetLearnEntity savedLearn = mapSheetLearnRepository.save(mapSheetLearnEntity);
 
     final int CHUNK = 1000;
     List<MapSheetLearn5kEntity> buffer = new ArrayList<>(CHUNK);
 
-    // learn 도엽별 저장
+    // learn 도엽별 저장, 도엽수가 많으므로 1000개 씩 저장함
     for (MngListDto mngDto : targetList) {
       MapSheetLearn5kEntity entity = new MapSheetLearn5kEntity();
       entity.setLearn(savedLearn);
@@ -145,12 +142,15 @@ public class InferenceResultCoreService {
 
       buffer.add(entity);
       if (buffer.size() == CHUNK) {
+        // 도엽별 저장 learn 5k 테이블
         flushChunk(buffer);
         buffer.clear();
       }
     }
 
+    // chunk 남은거 처리
     if (!buffer.isEmpty()) {
+      // 도엽별 저장 learn 5k 테이블
       flushChunk(buffer);
       buffer.clear();
     }
@@ -159,9 +159,9 @@ public class InferenceResultCoreService {
   }
 
   /**
-   * 도엽별 저장
+   * 도엽별 저장 learn 5k 테이블
    *
-   * @param buffer
+   * @param buffer 저장 정보
    */
   private void flushChunk(List<MapSheetLearn5kEntity> buffer) {
 
@@ -283,7 +283,7 @@ public class InferenceResultCoreService {
             .distinct() // 중복 방지 (선택)
             .toList();
 
-    // testing 추론결과 테이블 조회하여 탐지 개수 업데이트
+    // testing 테이블 추론결과 테이블 조회하여 탐지 개수 업데이트
     Long testing = getInferenceResultCnt(batchIds);
 
     // 공통 영역 업데이트
@@ -422,7 +422,7 @@ public class InferenceResultCoreService {
   /**
    * 추론 진행중인지 확인
    *
-   * @return
+   * @return 추론 실행중인 추론 uuid, batch id
    */
   public SaveInferenceAiDto getProcessing() {
     MapSheetLearnEntity entity = mapSheetLearnRepository.getProcessing();
@@ -453,17 +453,30 @@ public class InferenceResultCoreService {
    * @return
    */
   public AnalResultInfo getInferenceResultInfo(UUID uuid) {
+    // 추론 결과 정보조회
     AnalResultInfo resultInfo = mapSheetLearnRepository.getInferenceResultInfo(uuid);
+    // bbox, point 조회
     BboxPointDto bboxPointDto = mapSheetLearnRepository.getBboxPoint(uuid);
     resultInfo.setBboxGeom(bboxPointDto.getBboxGeom());
     resultInfo.setBboxCenterPoint(bboxPointDto.getBboxCenterPoint());
     return resultInfo;
   }
 
+  /**
+   * 분류별 탐지건수 조회
+   *
+   * @param uuid 추론 uuid
+   * @return 분류별 탐지건수 정보
+   */
   public List<Dashboard> getInferenceClassCountList(UUID uuid) {
     return mapSheetLearnRepository.getInferenceClassCountList(uuid);
   }
 
+  /**
+   * @param uuid 추론 uuid
+   * @param searchGeoReq 추론 결과 상세화면 geom 조회 조건
+   * @return geom 목록 정보
+   */
   public Page<Geom> getInferenceGeomList(UUID uuid, SearchGeoReq searchGeoReq) {
     return mapSheetLearnRepository.getInferenceGeomList(uuid, searchGeoReq);
   }
@@ -522,15 +535,21 @@ public class InferenceResultCoreService {
     return list.stream().map(InferenceResultsTestingEntity::toDto).toList();
   }
 
+  /**
+   * 테스팅 테이블 조회하여 탐지건수 조회
+   *
+   * @param batchIds batchIds
+   * @return batchIds 조회 count 수
+   */
   public Long getInferenceResultCnt(List<Long> batchIds) {
     return inferenceResultsTestingRepository.getInferenceResultCnt(batchIds);
   }
 
   /**
-   * uid 조회
+   * 추론 정보 조회 하여 batch id, 32자 uid 리턴
    *
-   * @param uuid
-   * @return
+   * @param uuid 추론 uuid
+   * @return 추론정보
    */
   public InferenceLearnDto getInferenceUid(UUID uuid) {
     MapSheetLearnEntity entity = inferenceResultRepository.getInferenceUid(uuid).orElse(null);
@@ -547,7 +566,7 @@ public class InferenceResultCoreService {
   }
 
   /**
-   * 실행중인 추론 도엽명 목록
+   * 분석중인 추론 도엽명 목록
    *
    * @param uuid 추론 실행중인 uuid
    * @return

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

@@ -1,14 +1,8 @@
 package com.kamco.cd.kamcoback.postgres.core;
 
 import com.kamco.cd.kamcoback.common.enums.MngStateType;
-import com.kamco.cd.kamcoback.common.exception.CustomApiException;
 import com.kamco.cd.kamcoback.common.geometry.GeoJsonFileWriter;
 import com.kamco.cd.kamcoback.common.geometry.GeoJsonFileWriter.ImageFeature;
-import com.kamco.cd.kamcoback.common.geometry.GeoJsonFileWriter.Scene;
-import com.kamco.cd.kamcoback.inference.dto.InferenceResultDto;
-import com.kamco.cd.kamcoback.inference.dto.InferenceResultDto.DetectOption;
-import com.kamco.cd.kamcoback.inference.dto.InferenceResultDto.MapSheetFallbackYearDto;
-import com.kamco.cd.kamcoback.inference.dto.InferenceResultDto.MapSheetScope;
 import com.kamco.cd.kamcoback.mapsheet.dto.MapSheetMngDto;
 import com.kamco.cd.kamcoback.mapsheet.dto.MapSheetMngDto.MngListCompareDto;
 import com.kamco.cd.kamcoback.mapsheet.dto.MapSheetMngDto.MngListDto;
@@ -22,11 +16,11 @@ import jakarta.persistence.EntityNotFoundException;
 import jakarta.validation.Valid;
 import java.io.IOException;
 import java.nio.file.Files;
-import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.time.ZonedDateTime;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
@@ -37,7 +31,6 @@ import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.data.domain.Page;
-import org.springframework.http.HttpStatus;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
@@ -55,9 +48,6 @@ public class MapSheetMngCoreService {
   @Value("${file.sync-root-dir}")
   private String syncRootDir;
 
-  @Value("${inference.geojson-dir}")
-  private String inferenceDir;
-
   public List<MapSheetMngDto.MngDto> findMapSheetMngList() {
     return mapSheetMngRepository.findMapSheetMngList();
   }
@@ -235,124 +225,29 @@ public class MapSheetMngCoreService {
   }
 
   /**
-   * geojson 생성
+   * geojson 생성시 필요한 영상파일 정보 조회
    *
    * @param yyyy
-   * @param scenes
-   * @param mapSheetScope
-   * @param detectOption
-   * @return
-   */
-  public Scene getSceneInference(
-      String yyyy, List<String> scenes, String mapSheetScope, String detectOption) {
-    List<ImageFeature> features = loadSceneInferenceBySheets(yyyy, scenes);
-    return writeSceneGeoJson(yyyy, mapSheetScope, detectOption, features);
-  }
-
-  /**
-   * geojson 생성
-   *
-   * @param yearDtos
-   * @param yyyy
-   * @param mapSheetScope
-   * @param detectOption
-   * @return
-   */
-  public Scene getSceneInference(
-      List<MapSheetFallbackYearDto> yearDtos,
-      String yyyy,
-      String mapSheetScope,
-      String detectOption) {
-    List<ImageFeature> features = loadSceneInferenceByFallbackYears(yearDtos);
-    return writeSceneGeoJson(yyyy, mapSheetScope, detectOption, features);
-  }
-
-  /**
-   * 파일 경로/이름 , 파일 생성 , 도엽번호 반환
-   *
-   * @param yyyy
-   * @param mapSheetScope
-   * @param detectOption
-   * @param sceneInference
-   * @return Scene
-   */
-  private Scene writeSceneGeoJson(
-      String yyyy, String mapSheetScope, String detectOption, List<ImageFeature> sceneInference) {
-    boolean isAll = MapSheetScope.ALL.getId().equals(mapSheetScope);
-    String optionSuffix = buildOptionSuffix(detectOption);
-
-    String targetDir =
-        "local".equals(activeEnv) ? System.getProperty("user.home") + "/geojson" : inferenceDir;
-
-    String filename =
-        isAll
-            ? String.format("%s_%s_ALL%s.geojson", yyyy, activeEnv, optionSuffix)
-            : String.format("%s_%s%s.geojson", yyyy, activeEnv, optionSuffix);
-
-    Path outputPath = Paths.get(targetDir, filename);
-
-    if (sceneInference == null || sceneInference.isEmpty()) {
-      log.warn("NOT_FOUND_TARGET_YEAR: yyyy={}, isAll={}, featuresSize={}", yyyy, isAll, 0);
-      throw new CustomApiException("NOT_FOUND_TARGET_YEAR", HttpStatus.NOT_FOUND);
-    }
-
-    try {
-      log.info("create Directories outputPath: {}", outputPath);
-      log.info(
-          "activeEnv={}, inferenceDir={}, targetDir={}, filename={}",
-          activeEnv,
-          inferenceDir,
-          targetDir,
-          filename);
-      log.info("outputPath={}, parent={}", outputPath.toAbsolutePath(), outputPath.getParent());
-
-      Files.createDirectories(outputPath.getParent());
-
-      new GeoJsonFileWriter()
-          .exportToFile(sceneInference, "scene_inference_" + yyyy, 5186, outputPath.toString());
-
-      Scene scene = new Scene();
-      scene.setFeatures(sceneInference);
-      scene.setFilePath(outputPath.toString());
-      return scene;
-
-    } catch (IOException e) {
-      log.error(
-          "FAIL_CREATE_MAP_SHEET_FILE: yyyy={}, isAll={}, path={}", yyyy, isAll, outputPath, e);
-      throw new CustomApiException("INTERNAL_SERVER_ERROR", HttpStatus.INTERNAL_SERVER_ERROR, e);
-    }
-  }
-
-  /**
-   * geojson 파일명 Suffix
-   *
-   * @param detectOption
-   * @return
-   */
-  private String buildOptionSuffix(String detectOption) {
-    if (DetectOption.EXCL.getId().equals(detectOption)) return "_EXCL";
-    if (DetectOption.PREV.getId().equals(detectOption)) return "_PREV";
-    return "";
-  }
-
-  /**
-   * 년도, 도엽번호로 조회
-   *
-   * @param yyyy
-   * @param scenes
+   * @param mapSheetNums
    * @return ImageFeature
    */
-  private List<ImageFeature> loadSceneInferenceBySheets(String yyyy, List<String> scenes) {
-    List<ImageFeature> sceneInference = mapSheetMngRepository.getSceneInference(yyyy, scenes);
+  public List<ImageFeature> loadSceneInferenceBySheets(String yyyy, List<String> mapSheetNums) {
 
-    if (sceneInference == null || sceneInference.isEmpty()) {
-      log.warn(
-          "NOT_FOUND_TARGET_YEAR: yyyy={}, scenesSize={}",
-          yyyy,
-          scenes == null ? 0 : scenes.size());
-      throw new CustomApiException("NOT_FOUND_TARGET_YEAR", HttpStatus.NOT_FOUND);
+    if (mapSheetNums == null || mapSheetNums.isEmpty()) {
+      return List.of();
     }
-    return sceneInference;
+
+    // CHUNK_SIZE 단위로 나누어 여러 번 조회한다.
+    final int CHUNK_SIZE = 1000;
+    List<ImageFeature> features = new ArrayList<>();
+
+    // i부터 CHUNK_SIZE만큼 잘라서 조회
+    // 마지막 구간은 남은 개수만큼만 처리하기 위해 Math.min 사용
+    for (int i = 0; i < mapSheetNums.size(); i += CHUNK_SIZE) {
+      List<String> chunk = mapSheetNums.subList(i, Math.min(i + CHUNK_SIZE, mapSheetNums.size()));
+      features.addAll(mapSheetMngRepository.getSceneInference(yyyy, chunk));
+    }
+    return features;
   }
 
   /**
@@ -361,33 +256,32 @@ public class MapSheetMngCoreService {
    * @param yearDtos
    * @return ImageFeature
    */
-  private List<ImageFeature> loadSceneInferenceByFallbackYears(
-      List<MapSheetFallbackYearDto> yearDtos) {
+  public List<ImageFeature> loadSceneInferenceByFallbackYears(List<MngListDto> yearDtos) {
     if (yearDtos == null || yearDtos.isEmpty()) {
       return List.of();
     }
 
     // 년도 별로 루프를 돌리기위해 년도별 정리
-    Map<Integer, List<MapSheetFallbackYearDto>> groupedByYear =
+    Map<Integer, List<MngListDto>> groupedByYear =
         yearDtos.stream()
-            .filter(d -> d.getMngYyyy() != null && d.getMapSheetNum() != null)
-            .collect(Collectors.groupingBy(MapSheetFallbackYearDto::getMngYyyy));
+            .filter(d -> d.getMngYyyy() != 0 && d.getMapSheetNum() != null)
+            .collect(Collectors.groupingBy(MngListDto::getMngYyyy));
 
     List<ImageFeature> sceneInference = new ArrayList<>();
 
-    for (Map.Entry<Integer, List<MapSheetFallbackYearDto>> entry : groupedByYear.entrySet()) {
+    for (Map.Entry<Integer, List<MngListDto>> entry : groupedByYear.entrySet()) {
       Integer year = entry.getKey();
 
       // 년도별 mapSheetNum 만들기
       List<String> sheetNums =
           entry.getValue().stream()
-              .map(MapSheetFallbackYearDto::getMapSheetNum)
+              .map(MngListDto::getMapSheetNum)
               .filter(Objects::nonNull)
               .distinct()
               .toList();
 
       // tif파일 정보 조회
-      List<ImageFeature> temp = mapSheetMngRepository.getSceneInference(year.toString(), sheetNums);
+      List<ImageFeature> temp = loadSceneInferenceBySheets(year.toString(), sheetNums);
 
       if (temp != null && !temp.isEmpty()) {
         sceneInference.addAll(temp);
@@ -397,20 +291,6 @@ public class MapSheetMngCoreService {
     return sceneInference;
   }
 
-  /**
-   * 변화탐지 실행 가능 기준 년도 조회
-   *
-   * @param req
-   * @return
-   */
-  public List<MngListDto> getHstMapSheetList(InferenceResultDto.RegReq req) {
-    return mapSheetMngRepository.findByHstMapSheetTargetList(req);
-  }
-
-  public List<MngListDto> getHstMapSheetList(int mngYyyy, List<String> mapIds) {
-    return mapSheetMngRepository.findByHstMapSheetTargetList(mngYyyy, mapIds);
-  }
-
   public void updateMapSheetMngHstUploadId(Long hstUid, UUID uuid, String uploadId) {
     mapSheetMngRepository.updateMapSheetMngHstUploadId(hstUid, uuid, uploadId);
   }
@@ -431,30 +311,32 @@ public class MapSheetMngCoreService {
     return mapSheetMngYearRepository.findByHstMapSheetCompareList(mngYyyy, mapId);
   }
 
-  public List<String> getMapSheetNumByHst(Integer year) {
-    List<MapSheetMngHstEntity> entity = mapSheetMngRepository.getMapSheetMngHst(year);
-    return entity.stream().map(MapSheetMngHstEntity::getMapSheetNum).toList();
+  public List<MngListDto> getMapSheetMngHst(
+      Integer year, String mapSheetScope, List<String> mapSheetNum) {
+    return mapSheetMngRepository.getMapSheetMngHst(year, mapSheetScope, mapSheetNum);
   }
 
   /**
-   * 특정 연도의 도엽 이력 데이터를 조회
+   * 이전 년도 도엽 조회 조건이 많을 수 있으므로 chunk 줘서 끊어서 조회
    *
    * @param year
+   * @param mapIds
    * @return
    */
-  public List<MapSheetFallbackYearDto> getMapSheetNumDtoByHst(Integer year) {
-    List<MapSheetMngHstEntity> entity = mapSheetMngRepository.getMapSheetMngHst(year);
-    return entity.stream()
-        .map(
-            e ->
-                new MapSheetFallbackYearDto(
-                    e.getMapSheetNum(), e.getMngYyyy() // 조회 기준 연도
-                    ))
-        .toList();
-  }
+  public List<MngListDto> findFallbackCompareYearByMapSheets(Integer year, List<String> mapIds) {
+    if (mapIds == null || mapIds.isEmpty()) {
+      return Collections.emptyList();
+    }
 
-  public List<MapSheetFallbackYearDto> findFallbackCompareYearByMapSheets(
-      Integer year, List<String> mapIds) {
-    return mapSheetMngRepository.findFallbackCompareYearByMapSheets(year, mapIds);
+    int chunkSize = 1000;
+    List<MngListDto> result = new ArrayList<>();
+
+    for (int i = 0; i < mapIds.size(); i += chunkSize) {
+      List<String> chunk = mapIds.subList(i, Math.min(i + chunkSize, mapIds.size()));
+
+      result.addAll(mapSheetMngRepository.findFallbackCompareYearByMapSheets(year, chunk));
+    }
+
+    return result;
   }
 }

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

@@ -17,6 +17,16 @@ public class ModelMngCoreService {
 
   private final ModelMngRepository modelMngRepository;
 
+  /**
+   * 모델조회
+   *
+   * @param searchReq 페이징
+   * @param startDate 시작날짜
+   * @param endDate 종료날짜
+   * @param modelType 모델 타입 G1, G2, G3
+   * @param searchVal 모델 ver
+   * @return 모델 목록
+   */
   public Page<ModelMngDto.ModelList> findModelMgmtList(
       ModelMngDto.searchReq searchReq,
       LocalDate startDate,

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

@@ -16,5 +16,11 @@ public interface InferenceResultRepositoryCustom {
 
   Long getInferenceLearnIdByUuid(UUID uuid);
 
+  /**
+   * 추론 정보 조회
+   *
+   * @param uuid 추론 uuid
+   * @return 추론 정보
+   */
   Optional<MapSheetLearnEntity> getInferenceUid(UUID uuid);
 }

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

@@ -7,5 +7,11 @@ public interface InferenceResultsTestingRepositoryCustom {
 
   List<InferenceResultsTestingEntity> getInferenceResultList(List<Long> batchIds);
 
+  /**
+   * 테스팅 테이블 조회하여 탐지건수 조회
+   *
+   * @param batchIds batchIds
+   * @return batchIds 조회 count 수
+   */
   Long getInferenceResultCnt(List<Long> batchIds);
 }

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

@@ -14,5 +14,11 @@ public interface MapSheetLearn5kRepositoryCustom {
 
   List<Long> findCompleted5kList(UUID uuid, List<Long> completedIds, String type);
 
+  /**
+   * 추론 실행중일때 분석중인 도엽명 목록 조회
+   *
+   * @param uuid 추론 uuid
+   * @return 도엽명+50K 도엽번호
+   */
   List<String> getInferenceRunMapId(UUID uuid);
 }

src/main/java/com/kamco/cd/kamcoback/postgres/repository/mapsheet/MapSheetMngRepositoryCustom.java

@@ -1,8 +1,6 @@
 package com.kamco.cd.kamcoback.postgres.repository.mapsheet;
 
 import com.kamco.cd.kamcoback.common.geometry.GeoJsonFileWriter.ImageFeature;
-import com.kamco.cd.kamcoback.inference.dto.InferenceResultDto;
-import com.kamco.cd.kamcoback.inference.dto.InferenceResultDto.MapSheetFallbackYearDto;
 import com.kamco.cd.kamcoback.mapsheet.dto.MapSheetMngDto;
 import com.kamco.cd.kamcoback.mapsheet.dto.MapSheetMngDto.AddReq;
 import com.kamco.cd.kamcoback.mapsheet.dto.MapSheetMngDto.MngListDto;
@@ -64,16 +62,6 @@ public interface MapSheetMngRepositoryCustom {
 
   List<MapSheetMngDto.MngFilesDto> findByHstUidMapSheetFileList(Long hstUid);
 
-  /**
-   * 변화탐지 실행 가능 기준 연도 조회
-   *
-   * @param req 조회 연도, 도엽번호 목록,
-   * @return
-   */
-  List<MngListDto> findByHstMapSheetTargetList(InferenceResultDto.RegReq req);
-
-  List<MngListDto> findByHstMapSheetTargetList(int mngYyyy, List<String> mapIds);
-
   MapSheetMngDto.MngFilesDto findByFileUidMapSheetFile(Long fileUid);
 
   void updateHstFileSizes(Long hstUid, long tifSizeBytes, long tfwSizeBytes, long totalSizeBytes);
@@ -82,14 +70,33 @@ public interface MapSheetMngRepositoryCustom {
 
   Page<YearEntity> getYears(YearSearchReq req);
 
+  /**
+   * 도엽 영상파일 정보 조회
+   *
+   * @param yyyy 연도
+   * @param mapSheetNums 도엽목록
+   * @return 도엽 영상파일 정보
+   */
   List<ImageFeature> getSceneInference(String yyyy, List<String> mapSheetNums);
 
   void updateMapSheetMngHstUploadId(Long hstUid, UUID uuid, String uploadId);
 
   void insertMapSheetMngTile(@Valid AddReq addReq);
 
-  List<MapSheetMngHstEntity> getMapSheetMngHst(Integer year);
+  /**
+   * 연도 조건으로 도엽번호 조회
+   *
+   * @param year 연도
+   * @return 추론 가능한 도엽 정보
+   */
+  List<MngListDto> getMapSheetMngHst(Integer year, String mapSheetScope, List<String> mapSheetNum);
 
-  List<MapSheetFallbackYearDto> findFallbackCompareYearByMapSheets(
-      Integer year, List<String> mapIds);
+  /**
+   * 비교연도 사용 가능한 이전도엽을 조회한다.
+   *
+   * @param year 연도
+   * @param mapIds 도엽목록
+   * @return 사용 가능한 이전도엽목록
+   */
+  List<MngListDto> findFallbackCompareYearByMapSheets(Integer year, List<String> mapIds);
 }

src/main/java/com/kamco/cd/kamcoback/postgres/repository/mapsheet/MapSheetMngRepositoryImpl.java

@@ -5,20 +5,20 @@ import static com.kamco.cd.kamcoback.postgres.entity.QMapSheetMngEntity.mapSheet
 import static com.kamco.cd.kamcoback.postgres.entity.QMapSheetMngFileEntity.mapSheetMngFileEntity;
 import static com.kamco.cd.kamcoback.postgres.entity.QMapSheetMngHstEntity.mapSheetMngHstEntity;
 import static com.kamco.cd.kamcoback.postgres.entity.QMapSheetMngTileEntity.mapSheetMngTileEntity;
-import static com.kamco.cd.kamcoback.postgres.entity.QMapSheetMngYearYnEntity.mapSheetMngYearYnEntity;
 import static com.kamco.cd.kamcoback.postgres.entity.QYearEntity.yearEntity;
 import static com.querydsl.core.types.dsl.Expressions.nullExpression;
 
 import com.kamco.cd.kamcoback.common.enums.CommonUseStatus;
 import com.kamco.cd.kamcoback.common.geometry.GeoJsonFileWriter.ImageFeature;
-import com.kamco.cd.kamcoback.inference.dto.InferenceResultDto;
-import com.kamco.cd.kamcoback.inference.dto.InferenceResultDto.MapSheetFallbackYearDto;
 import com.kamco.cd.kamcoback.inference.dto.InferenceResultDto.MapSheetScope;
 import com.kamco.cd.kamcoback.mapsheet.dto.MapSheetMngDto;
 import com.kamco.cd.kamcoback.mapsheet.dto.MapSheetMngDto.AddReq;
 import com.kamco.cd.kamcoback.mapsheet.dto.MapSheetMngDto.MngListDto;
 import com.kamco.cd.kamcoback.mapsheet.dto.MapSheetMngDto.YearSearchReq;
 import com.kamco.cd.kamcoback.postgres.entity.MapSheetMngHstEntity;
+import com.kamco.cd.kamcoback.postgres.entity.QMapInkx5kEntity;
+import com.kamco.cd.kamcoback.postgres.entity.QMapSheetMngFileEntity;
+import com.kamco.cd.kamcoback.postgres.entity.QMapSheetMngHstEntity;
 import com.kamco.cd.kamcoback.postgres.entity.QYearEntity;
 import com.kamco.cd.kamcoback.postgres.entity.YearEntity;
 import com.querydsl.core.BooleanBuilder;
@@ -28,6 +28,7 @@ import com.querydsl.core.types.dsl.CaseBuilder;
 import com.querydsl.core.types.dsl.Expressions;
 import com.querydsl.core.types.dsl.NumberExpression;
 import com.querydsl.core.types.dsl.StringExpression;
+import com.querydsl.jpa.JPAExpressions;
 import com.querydsl.jpa.impl.JPAQueryFactory;
 import jakarta.persistence.EntityManager;
 import jakarta.persistence.PersistenceContext;
@@ -572,87 +573,6 @@ public class MapSheetMngRepositoryImpl extends QuerydslRepositorySupport
     return foundContent;
   }
 
-  /**
-   * 기준년도 추론 실행 가능 도엽 조회
-   *
-   * @param req
-   * @return
-   */
-  @Override
-  public List<MngListDto> findByHstMapSheetTargetList(InferenceResultDto.RegReq req) {
-    BooleanBuilder whereBuilder = new BooleanBuilder();
-
-    whereBuilder.and(mapSheetMngHstEntity.dataState.eq("DONE"));
-    whereBuilder.and(
-        mapSheetMngHstEntity
-            .syncState
-            .eq("DONE")
-            .or(mapSheetMngHstEntity.syncCheckState.eq("DONE")));
-    whereBuilder.and(mapSheetMngHstEntity.useInference.eq("USE"));
-
-    whereBuilder.and(mapSheetMngHstEntity.mngYyyy.eq(req.getTargetYyyy()));
-
-    BooleanBuilder likeBuilder = new BooleanBuilder();
-
-    if (MapSheetScope.PART.getId().equals(req.getMapSheetScope())) {
-      List<String> list = req.getMapSheetNum();
-      if (list == null || list.isEmpty()) {
-        return List.of();
-      }
-
-      for (String prefix : list) {
-        if (prefix == null || prefix.isBlank()) {
-          continue;
-        }
-        likeBuilder.or(mapSheetMngHstEntity.mapSheetNum.like(prefix.trim() + "%"));
-      }
-    }
-
-    if (likeBuilder.hasValue()) {
-      whereBuilder.and(likeBuilder);
-    }
-
-    return queryFactory
-        .select(
-            Projections.constructor(
-                MngListDto.class,
-                mapSheetMngHstEntity.mngYyyy,
-                mapSheetMngHstEntity.mapSheetNum,
-                mapSheetMngHstEntity.mapSheetName,
-                nullExpression(Integer.class),
-                nullExpression(Boolean.class)))
-        .from(mapSheetMngHstEntity)
-        .innerJoin(mapInkx5kEntity)
-        .on(
-            mapInkx5kEntity
-                .mapidcdNo
-                .eq(mapSheetMngHstEntity.mapSheetNum)
-                .and(mapInkx5kEntity.useInference.eq(CommonUseStatus.USE)))
-        .where(whereBuilder)
-        .fetch();
-  }
-
-  @Override
-  public List<MngListDto> findByHstMapSheetTargetList(int mngYyyy, List<String> mapIds) {
-    BooleanBuilder whereBuilder = new BooleanBuilder();
-    whereBuilder.and(mapSheetMngHstEntity.mngYyyy.eq(mngYyyy));
-    whereBuilder.and(mapSheetMngHstEntity.mapSheetNum.in(mapIds));
-    whereBuilder.and(mapSheetMngHstEntity.dataState.eq("DONE"));
-    whereBuilder.and(mapSheetMngHstEntity.syncState.eq("DONE")); // TODO 싱크체크 or조건 추가
-    whereBuilder.and(mapSheetMngHstEntity.useInference.eq("USE"));
-
-    return queryFactory
-        .select(
-            Projections.constructor(
-                MngListDto.class,
-                mapSheetMngHstEntity.mngYyyy,
-                mapSheetMngHstEntity.mapSheetNum,
-                mapSheetMngHstEntity.mapSheetName))
-        .from(mapSheetMngHstEntity)
-        .where(whereBuilder)
-        .fetch();
-  }
-
   @Override
   public List<MapSheetMngDto.MngFilesDto> findHstUidToMapSheetFileList(Long hstUid) {
     BooleanBuilder whereBuilder = new BooleanBuilder();
@@ -1103,42 +1023,119 @@ public class MapSheetMngRepositoryImpl extends QuerydslRepositorySupport
   }
 
   @Override
-  public List<MapSheetMngHstEntity> getMapSheetMngHst(Integer year) {
-    return queryFactory
-        .select(mapSheetMngHstEntity)
-        .from(mapSheetMngHstEntity)
-        .innerJoin(mapSheetMngFileEntity)
-        .on(mapSheetMngFileEntity.hstUid.eq(mapSheetMngHstEntity.hstUid))
-        .where(
-            mapSheetMngHstEntity
-                .mngYyyy
-                .eq(year)
-                .and(
-                    mapSheetMngHstEntity
-                        .syncState
-                        .eq("DONE")
-                        .or(mapSheetMngHstEntity.syncCheckState.eq("DONE")))
-                .and(mapSheetMngFileEntity.fileExt.eq("tif")))
-        .fetch();
-  }
+  public List<MngListDto> getMapSheetMngHst(
+      Integer year, String mapSheetScope, List<String> mapSheetNum) {
+    BooleanBuilder whereBuilder = new BooleanBuilder();
 
-  @Override
-  public List<MapSheetFallbackYearDto> findFallbackCompareYearByMapSheets(
-      Integer year, List<String> mapIds) {
-    BooleanBuilder builder = new BooleanBuilder();
-    builder.and(mapSheetMngYearYnEntity.id.mapSheetNum.in(mapIds));
-    builder.and(mapSheetMngYearYnEntity.id.mngYyyy.lt(year));
-    builder.and(mapSheetMngYearYnEntity.yn.eq("Y"));
+    whereBuilder.and(mapSheetMngHstEntity.dataState.eq("DONE"));
+    whereBuilder.and(
+        mapSheetMngHstEntity
+            .syncState
+            .eq("DONE")
+            .or(mapSheetMngHstEntity.syncCheckState.eq("DONE")));
+    whereBuilder.and(mapSheetMngHstEntity.useInference.eq("USE"));
+
+    whereBuilder.and(mapSheetMngHstEntity.mngYyyy.eq(year));
+
+    whereBuilder.and(
+        JPAExpressions.selectOne()
+            .from(mapSheetMngFileEntity)
+            .where(
+                mapSheetMngFileEntity
+                    .hstUid
+                    .eq(mapSheetMngHstEntity.hstUid) // FK 관계에 맞게 유지
+                    .and(mapSheetMngFileEntity.fileExt.eq("tif"))
+                    .and(mapSheetMngFileEntity.fileState.eq("DONE")))
+            .exists());
+
+    BooleanBuilder likeBuilder = new BooleanBuilder();
+
+    if (MapSheetScope.PART.getId().equals(mapSheetScope)) {
+      List<String> list = mapSheetNum;
+      if (list == null || list.isEmpty()) {
+        return List.of();
+      }
+
+      for (String prefix : list) {
+        if (prefix == null || prefix.isBlank()) {
+          continue;
+        }
+        likeBuilder.or(mapSheetMngHstEntity.mapSheetNum.like(prefix.trim() + "%"));
+      }
+    }
+
+    if (likeBuilder.hasValue()) {
+      whereBuilder.and(likeBuilder);
+    }
 
     return queryFactory
         .select(
             Projections.constructor(
-                MapSheetFallbackYearDto.class,
-                mapSheetMngYearYnEntity.id.mapSheetNum,
-                mapSheetMngYearYnEntity.id.mngYyyy.max()))
-        .from(mapSheetMngYearYnEntity)
-        .where(builder)
-        .groupBy(mapSheetMngYearYnEntity.id.mapSheetNum)
+                MngListDto.class,
+                mapSheetMngHstEntity.mngYyyy,
+                mapSheetMngHstEntity.mapSheetNum,
+                mapSheetMngHstEntity.mapSheetName,
+                nullExpression(Integer.class),
+                nullExpression(Boolean.class)))
+        .from(mapSheetMngHstEntity)
+        .innerJoin(mapInkx5kEntity)
+        .on(
+            mapInkx5kEntity
+                .mapidcdNo
+                .eq(mapSheetMngHstEntity.mapSheetNum)
+                .and(mapInkx5kEntity.useInference.eq(CommonUseStatus.USE)))
+        .where(whereBuilder)
+        .fetch();
+  }
+
+  @Override
+  public List<MngListDto> findFallbackCompareYearByMapSheets(Integer year, List<String> mapIds) {
+    QMapSheetMngHstEntity h = QMapSheetMngHstEntity.mapSheetMngHstEntity;
+    QMapSheetMngHstEntity h2 = new QMapSheetMngHstEntity("h2");
+    QMapSheetMngFileEntity f = QMapSheetMngFileEntity.mapSheetMngFileEntity;
+    QMapSheetMngFileEntity f2 = new QMapSheetMngFileEntity("f2");
+    QMapInkx5kEntity inkk = QMapInkx5kEntity.mapInkx5kEntity;
+
+    return queryFactory
+        .select(
+            Projections.constructor(
+                MngListDto.class,
+                h.mngYyyy,
+                h.mapSheetNum,
+                h.mapSheetName,
+                nullExpression(Integer.class),
+                nullExpression(Boolean.class)))
+        .from(h)
+        .innerJoin(inkk)
+        .on(inkk.mapidcdNo.eq(h.mapSheetNum).and(inkk.useInference.eq(CommonUseStatus.USE)))
+        .where(
+            h.mapSheetNum.in(mapIds),
+            h.mngYyyy.lt(year),
+            h.dataState.eq("DONE"),
+            h.useInference.eq("USE"),
+            h.syncState.eq("DONE").or(h.syncCheckState.eq("DONE")),
+            JPAExpressions.selectOne()
+                .from(f)
+                .where(f.hstUid.eq(h.hstUid), f.fileExt.eq("tif"), f.fileState.eq("DONE"))
+                .exists(),
+
+            // mapSheetNum별 최대 mngYyyy인 행만 남김
+            h.mngYyyy.eq(
+                JPAExpressions.select(h2.mngYyyy.max())
+                    .from(h2)
+                    .where(
+                        h2.mapSheetNum.eq(h.mapSheetNum),
+                        h2.mngYyyy.lt(year),
+                        h2.dataState.eq("DONE"),
+                        h2.useInference.eq("USE"),
+                        h2.syncState.eq("DONE").or(h2.syncCheckState.eq("DONE")),
+                        JPAExpressions.selectOne()
+                            .from(f2)
+                            .where(
+                                f2.hstUid.eq(h2.hstUid),
+                                f2.fileExt.eq("tif"),
+                                f2.fileState.eq("DONE"))
+                            .exists())))
         .fetch();
   }
 }

src/main/java/com/kamco/cd/kamcoback/postgres/repository/members/MembersRepositoryCustom.java

@@ -13,6 +13,12 @@ public interface MembersRepositoryCustom {
 
   boolean existsByEmployeeNo(String employeeNo);
 
+  /**
+   * 사번으로 사용자 조회
+   *
+   * @param employeeNo 사번
+   * @return 사용자 정보 조회
+   */
   Optional<MemberEntity> findByEmployeeNo(String employeeNo);
 
   Optional<MemberEntity> findByUserId(String userId);

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

@@ -9,6 +9,16 @@ import org.springframework.data.domain.Page;
 
 public interface ModelMngRepositoryCustom {
 
+  /**
+   * 모델조회
+   *
+   * @param searchReq 페이징
+   * @param startDate 시작날짜
+   * @param endDate 종료날짜
+   * @param modelType 모델 타입 G1, G2, G3
+   * @param searchVal 모델 ver
+   * @return 모델 목록
+   */
   Page<ModelMngDto.ModelList> findModelMgmtList(
       ModelMngDto.searchReq searchReq,
       LocalDate startDate,

src/main/java/com/kamco/cd/kamcoback/scheduler/config/ShpKeyLock.java

@@ -7,19 +7,76 @@ import org.springframework.stereotype.Component;
 @Component
 public class ShpKeyLock {
 
+  /**
+   * key별 Lock 객체를 저장하는 맵
+   *
+   * <p>- key: 예) shp 파일 경로, uuid, 도엽번호 등 - value: 해당 key 전용 ReentrantLock
+   *
+   * <p>ConcurrentHashMap을 사용하여 멀티스레드 환경에서도 안전하게 접근 가능
+   */
   private final ConcurrentHashMap<String, ReentrantLock> locks = new ConcurrentHashMap<>();
 
+  /**
+   * 특정 key에 대한 Lock 시도
+   *
+   * @param key 동시성 제어 대상 식별자
+   * @return true → 락 획득 성공 false → 이미 다른 스레드가 사용 중
+   */
   public boolean tryLock(String key) {
+
+    /**
+     * computeIfAbsent 설명:
+     *
+     * <p>- 해당 key가 이미 존재하면 기존 Lock 반환 - 없으면 새 ReentrantLock 생성 후 저장
+     *
+     * <p>동시성 환경에서도 원자적으로 실행됨
+     */
     ReentrantLock lock = locks.computeIfAbsent(key, k -> new ReentrantLock());
+
+    /**
+     * tryLock():
+     *
+     * <p>- 대기하지 않고 즉시 시도 - 이미 다른 스레드가 점유 중이면 false 반환
+     *
+     * <p>→ 다운로드 중복 방지에 적합
+     */
     return lock.tryLock();
   }
 
+  /**
+   * 특정 key에 대한 Lock 해제
+   *
+   * <p>반드시 tryLock 성공한 동일 스레드에서 호출해야 함
+   */
   public void unlock(String key) {
+
+    // 해당 key에 등록된 Lock 조회
     ReentrantLock lock = locks.get(key);
+
+    /**
+     * isHeldByCurrentThread():
+     *
+     * <p>- 현재 스레드가 해당 락을 보유 중인지 확인 - 다른 스레드가 unlock 호출하는 것 방지
+     */
     if (lock != null && lock.isHeldByCurrentThread()) {
+
+      // 실제 락 해제
       lock.unlock();
-      // 메모리 누수 방지(락이 비어있으면 제거)
+
+      /**
+       * 메모리 누수 방지 처리
+       *
+       * <p>hasQueuedThreads(): - 현재 이 락을 기다리는 스레드가 있는지 확인
+       *
+       * <p>대기 스레드가 없다면 locks 맵에서 제거하여 불필요한 Lock 객체 정리
+       */
       if (!lock.hasQueuedThreads()) {
+
+        /**
+         * remove(key, lock):
+         *
+         * <p>- 현재 맵에 등록된 값이 'lock'일 경우에만 제거 - 동시성 안전 (CAS 방식)
+         */
         locks.remove(key, lock);
       }
     }

src/main/java/com/kamco/cd/kamcoback/scheduler/service/MapSheetInferenceJobService.java

@@ -1,9 +1,8 @@
 package com.kamco.cd.kamcoback.scheduler.service;
 
 import com.fasterxml.jackson.core.JsonProcessingException;
-import com.fasterxml.jackson.core.type.TypeReference;
 import com.fasterxml.jackson.databind.ObjectMapper;
-import com.kamco.cd.kamcoback.common.exception.CustomApiException;
+import com.kamco.cd.kamcoback.common.inference.service.InferenceCommonService;
 import com.kamco.cd.kamcoback.config.resttemplate.ExternalHttpClient;
 import com.kamco.cd.kamcoback.config.resttemplate.ExternalHttpClient.ExternalCallResult;
 import com.kamco.cd.kamcoback.inference.dto.InferenceDetailDto.InferenceBatchSheet;
@@ -19,7 +18,6 @@ import java.nio.file.Paths;
 import java.time.ZonedDateTime;
 import java.util.HashSet;
 import java.util.List;
-import java.util.Map;
 import java.util.Objects;
 import java.util.Optional;
 import java.util.Set;
@@ -31,7 +29,6 @@ import lombok.extern.log4j.Log4j2;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.http.HttpHeaders;
 import org.springframework.http.HttpMethod;
-import org.springframework.http.HttpStatus;
 import org.springframework.http.MediaType;
 import org.springframework.scheduling.annotation.Scheduled;
 import org.springframework.stereotype.Service;
@@ -43,6 +40,7 @@ public class MapSheetInferenceJobService {
 
   private final InferenceResultCoreService inferenceResultCoreService;
   private final ShpPipelineService shpPipelineService;
+  private final InferenceCommonService inferenceCommonService;
 
   private final ExternalHttpClient externalHttpClient;
   private final ObjectMapper objectMapper;
@@ -357,7 +355,7 @@ public class MapSheetInferenceJobService {
     m.setPriority(5d);
     log.info("[BEFORE INFERENCE] BEFORE SendDto={}", m);
     // 추론 실행 api 호출
-    Long batchId = ensureAccepted(m);
+    Long batchId = inferenceCommonService.ensureAccepted(m);
 
     SaveInferenceAiDto saveInferenceAiDto = new SaveInferenceAiDto();
     saveInferenceAiDto.setUuid(uuid);
@@ -369,73 +367,6 @@ public class MapSheetInferenceJobService {
     inferenceResultCoreService.update(saveInferenceAiDto);
   }
 
-  /**
-   * api 호출
-   *
-   * @param dto
-   * @return
-   */
-  // 같은함수가 왜 두개지
-  private Long ensureAccepted(InferenceSendDto dto) {
-    if (dto == null) {
-      log.warn("not InferenceSendDto dto");
-      throw new CustomApiException("BAD_REQUEST", HttpStatus.BAD_REQUEST);
-    }
-
-    // 1) 요청 로그
-    log.info("");
-    log.info("========================================================");
-    log.info("[SEND INFERENCE] Inference request dto= {}", dto);
-    log.info("========================================================");
-    log.info("");
-    // 2) local 환경 임시 처리
-    //    if ("local".equals(profile)) {
-    //      if (dto.getPred_requests_areas() == null) {
-    //        throw new IllegalStateException("pred_requests_areas is null");
-    //      }
-    //
-    // dto.getPred_requests_areas().setInput1_scene_path("/kamco-nfs/requests/2023_local.geojson");
-    //
-    // dto.getPred_requests_areas().setInput2_scene_path("/kamco-nfs/requests/2024_local.geojson");
-    //    }
-
-    // 3) HTTP 호출
-    HttpHeaders headers = new HttpHeaders();
-    headers.setContentType(MediaType.APPLICATION_JSON);
-    headers.setAccept(List.of(MediaType.APPLICATION_JSON));
-
-    // TODO 어떤 URL로 어떤파리티러로 요청한 로딩해야지
-    ExternalCallResult<String> result =
-        externalHttpClient.call(inferenceUrl, HttpMethod.POST, dto, headers, String.class);
-
-    if (result.statusCode() < 200 || result.statusCode() >= 300) {
-      log.error("Inference API failed. status={}, body={}", result.statusCode(), result.body());
-      throw new CustomApiException("BAD_GATEWAY", HttpStatus.BAD_GATEWAY);
-    }
-
-    // 4) 응답 파싱
-    try {
-      List<Map<String, Object>> list =
-          objectMapper.readValue(result.body(), new TypeReference<>() {});
-
-      if (list.isEmpty()) {
-        // 어떤 URL로 어떤파리티러로 요청한 정보를 봐야 재현을 할듯하지요
-        throw new IllegalStateException("Inference response is empty");
-      }
-
-      Object batchIdObj = list.get(0).get("batch_id");
-      if (batchIdObj == null) {
-        throw new IllegalStateException("batch_id not found in response");
-      }
-
-      return Long.valueOf(batchIdObj.toString());
-
-    } catch (Exception e) {
-      log.error("Failed to parse inference response. body={}", result.body(), e);
-      throw new CustomApiException("INVALID_INFERENCE_RESPONSE", HttpStatus.BAD_GATEWAY);
-    }
-  }
-
   /**
    * 실행중인 profile
    *